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:)

[aprilmintacpineda]

This won't infer the correct typings, now role has type of [string, ...string[] instead of Role.

[ap0nia]

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

export function enumToPgEnum<T extends Record<string, any>>(
  myEnum: T,
): [T[keyof T], ...T[keyof T][]] {
  return Object.values(myEnum).map((value: any) => `${value}`) as any
}

export const roleEnum = pgEnum('role', enumToPgEnum(Role))

[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[]

[Weixuanf]

ohhh actually this one worked best, as [eCategoryType, ...eCategoryType[]] this is much better than [string, ...string[]!

[incompletude]

Not trying to be harsh, but I think the Drizzle team is missing the point. What we expect from a TypeScript ORM is that it provides the types we are working with. Prisma and TypeORM offer this out of the box, while Drizzle expects us to infer types or even pre-create them ourselves to do some additional work for them to be used by Drizzle.

[aprilmintacpineda]

I've used TypeORM, I don't think it does it better than Drizzle. Though I think this part can be improved by Drizzle to use the type of the argument we're passing to mysqlEnum, instead of it insisting on [string, ...string[]]