drizzle enums

[cehenriques]

Hi.

I just started recently using drizzle coming from Prisma, and I'm trying to convert one of my projects to drizzle.
One thing I found less intuitive is how Drizzle manages enums.
For instance, in Prisma, I would create an enum on my schema like this:

enum Color {
  Red
  Green
  Blue
}

model Theme {
  id           Int         @id @default(autoincrement())
  color     Color       
}

And then I could use it normally like this in my project:

const myColor = Color.Red;

But in drizzle, we create an enum as a PgEnum:

export const colorEnum = pgEnum("color", ["Red", "Green", "Blue"]);

But then to access its values I can only do it like so:

const myColor = colorEnum.enumValues[0];

I need to rely on the editor's intellisense

to remind me that "[0]" is "Red", while on Prisma's approach, I can use a traditional TS enum and directly access its values.
Am I doing something wrong? Is there a better or alternative way to use the enums?
What approach do you guys use? Do you just create an actual enum to reference it throughout your project?

Thanks in advance.

[nathanchapman]

Hey @cehenriques! I agree this would be nice. Gave you an upvote 🚀

For now, you can use two approaches:

Approach 1: the drizzle-zod plugin with Zod's enum support

https://orm.drizzle.team/docs/zod
https://zod.dev/?id=zod-enums

This would give you something like:

import { z } from 'zod';
import { pgEnum, pgTable, serial } from 'drizzle-orm/pg-core';
import { createSelectSchema } from 'drizzle-zod';

const colorEnum = pgEnum('color', ['Red', 'Green', 'Blue']);

const themes = pgTable('themes', {
  id: serial('id').primaryKey(),
  color: colorEnum('color').notNull(), // or nullable, will change enum usage mentioned below
});

const selectThemeSchema = createSelectSchema(themes);

type Theme = z.infer<typeof selectThemeSchema>;

// If column is nullable
selectThemeSchema.shape.color._def.innerType.enum.Blue;
// If column is not nullable
selectThemeSchema.shape.color.enum.Blue;

Approach 2: Use Zod enums directly with enumValues (a "cleaner" approach IMO)

import { z } from 'zod';
import { pgEnum, pgTable, serial } from 'drizzle-orm/pg-core';
import { createSelectSchema } from 'drizzle-zod';

const colorEnum = pgEnum('color', ['Red', 'Green', 'Blue']);
const colorEnumSchema = z.enum(colorEnum.enumValues);

const themes = pgTable('themes', {
  id: serial('id').primaryKey(),
  color: colorEnum('color'),
});

const selectThemeSchema = createSelectSchema(themes);
type Theme = z.infer<typeof selectThemeSchema>;

colorEnumSchema.enum.Blue;

Hope this helps for now!

[Angelelz]

I don't use Zod, so I wanted to share what I've done before in a project.
I define a readonly array which will be my source of truth with the values that the enum needs.
I thought I could share some code in this playground. It relies on some typescript trickery though.

[sisimomo]

Very nice! Here's an enhanced version that leverages utility functions. This way, if it's applied across multiple enums, the approach is significantly tidier.

[henritouchard]

Hello !
For those looking for another option, i decided to revert the logic with an utility function.
I first define my js enum, and, giving it to the function, I create the pgEnum.
I think it provides easier way to add enum values.
Here is the code:

// Takes an enum and return an array with each values
export function enumToPgEnum(myEnum: any): [string, ...string[]] {
  return Object.values(myEnum).map((value: any) => `${value}`) as [string, ...string[]]
}

// Define an enum
export enum Role {
  APPLICANT = 'applicant',
  TRAINER = 'trainer',
  ADMIN = 'admin',
}

// Declare drizzle enum
export const roleEnum = pgEnum('role', enumToPgEnum(Role))

I didn't use it a lot so i'm not sure this technique is perfect but it seems working for my current needs.

[Weixuanf]

this one worked for me! thanks for putting it out here:)

[andrewbellucci]

If you're just looking for the typings so you can reuse them elsewhere, you can achieve this without any extra dependencies.

Use the following as an example:

const onboardingSteps = ["welcome", "setup", "complete"] as const;
type OnboardingStep = typeof onboardingSteps[number];
const onboardingStepEnum = pgEnum("onboarding_step", onboardingSteps);

[aprilmintacpineda]

A simple work around that I found:

enum eMyEnum {
  Value1 = 'Value1',
  Value2 = 'Value2'
}

export const  myTable = mysqlTable("my_table", {
  // ...other fields
  myField: mysqlEnum(
    "my_field",
     Object.values(eCategoryType) as [eCategoryType, ...eCategoryType[]]
  )
});

This will also keep the type so later when you query the table, myField will be of type eMyEnum.

const values = await db.query.myTable.findMany();

values.forEach(value => {
  value.myField // will be of type eMyEnum
});

The reason for this is because mysqlEnum is typed as [string, ...string[]] which is the same as string[] BUT it requires at least 1 element. So ['test'] would be a valid [string, ...string[]] and also a valid string[] BUT [] would NOT be a valid [string, ...string[]] but is a valid string[]