z.enum() breaks if you pass it an actual enum or array created by destructuring enum using Object.values()`

[rogadev]

This can't possibly be how Zod is designed to handle enum validation...

I would have thought this would work:

import { z } from 'zod';

enum PizzaType {
  Canadian = 'Canadian',
  Cheese = 'Cheese',
  Hawaiian = 'Hawaiian',
  MeatLovers = 'Meat Lovers',
  Pepperoni = 'Pepperoni',
  Vegetarian = 'Vegetarian',
}

const orderSchema = z.object({
  id: z.number(),
  type: z.enum(PizzaType)
})

const order = {
  id: 1,
  type: 'Canadian'
}

orderSchema.safeParse(order)

Looks good to me. Logical. Simple. Should definitely work. Right?

error TS2769: No overload matches this call.
      Overload 1 of 2, '(values: readonly [string, ...string[]], params?: RawCreateParams): ZodEnum<[string, ...string[]]>', gave the following error.
        Argument of type 'typeof PizzaType' is not assignable to parameter of type 'readonly [string, ...string[]]'.
      Overload 2 of 2, '(values: [string, ...string[]], params?: RawCreateParams): ZodEnum<[string, ...string[]]>', gave the following error.
        Argument of type 'typeof PizzaType' is not assignable to parameter of type '[string, ...string[]]'.

    34     .enum(PizzaType)
                  ~~~~~~~

Okay, well that's weird. I guess I'll just do Object.values(PizzaType)?

const orderSchema = z.object({
  id: z.number(),
  type: z.enum(Object.values(PizzaType))
})

error TS2769: No overload matches this call.
      Overload 1 of 2, '(values: readonly [string, ...string[]], params?: RawCreateParams): ZodEnum<[string, ...string[]]>', gave the following error.
        Argument of type 'typeof PizzaType' is not assignable to parameter of type 'readonly [string, ...string[]]'.
      Overload 2 of 2, '(values: [string, ...string[]], params?: RawCreateParams): ZodEnum<[string, ...string[]]>', gave the following error.
        Argument of type 'typeof PizzaType' is not assignable to parameter of type '[string, ...string[]]'.

    34     .enum(Object.values(PizzaType))
                  ~~~~~~~~~~~~~~~~~

Uh, okay... How about destructuring into a new array of strings.

const orderSchema = z.object({
  id: z.number(),
  type: z.enum([...Object.values(PizzaType)])
})

error TS2769: No overload matches this call.
      Overload 1 of 2, '(values: readonly [string, ...string[]], params?: RawCreateParams): ZodEnum<[string, ...string[]]>', gave the following error.
        Argument of type 'typeof PizzaType' is not assignable to parameter of type 'readonly [string, ...string[]]'.
      Overload 2 of 2, '(values: [string, ...string[]], params?: RawCreateParams): ZodEnum<[string, ...string[]]>', gave the following error.
        Argument of type 'typeof PizzaType' is not assignable to parameter of type '[string, ...string[]]'.

    34     .enum([...Object.values(PizzaType)])
                  ~~~~~~~~~~~~~~~~~

Okay, well, I don't know how much uglier I need to get... I mean this would be even uglier, but I guess I could try:

const orderSchema = z.object({
  id: z.number(),
  type: z.enum([
      PizzaType.Canadian,
      PizzaType.Cheese,
      PizzaType.Hawaiian,
      PizzaType.MeatLovers,
      PizzaType.Pepperoni,
      PizzaType.Vegetarian,
    ]
})

✅ Yup! Looks good to me!

WHY, ZOD!? WHY!? 😭

[JacobWeisenburger]

Is this what you are looking for?
https://github.com/colinhacks/zod#native-enums

enum PizzaType {
    Canadian = 'Canadian',
    Cheese = 'Cheese',
    Hawaiian = 'Hawaiian',
    MeatLovers = 'Meat Lovers',
    Pepperoni = 'Pepperoni',
    Vegetarian = 'Vegetarian',
}

const orderSchema = z.object( {
    id: z.number(),
    type: z.nativeEnum( PizzaType )
} )

const order = {
    id: 1,
    type: 'Canadian'
}

orderSchema.safeParse( order )

Other Resources:
https://gist.github.com/JacobWeisenburger/1c72eda9e823cd6caed327db470f0613

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[silent-tan]

but how about const enum

[fnandogp]

I usually create enum with as const.

// types/title.ts
import { getOptions } from '@lib/enum'

export const Title = {
  Mr: 'mr',
  Mrs: 'mrs',
  Miss: 'miss',
  Ms: 'ms',
  Dr: 'dr',
} as const
export type Title = (typeof Title)[keyof typeof Title]

Then I have this utility file to help me with zod.

// lib/enum.ts
export function getValues<T extends Record<string, any>>(obj: T) {
  return Object.values(obj) as [(typeof obj)[keyof T]]
}

When creating the zod object I use:

// schemas/profile.ts
export const SaveContactDetailsFields = z.object({
  title: z.enum(getValues(Title), {
    errorMap: () => ({
      message: 'Please select your title',
    }),
  }),
...
})

[rogadev]

Would it not make more sense to have .enum() handle real enums and instead have a .enumString() or .enumLike() method instead? It seems pretty counter intuitive to me. Better yet would be if .enum() handled both native and non-native JavaScript enums.

[JacobWeisenburger]

I'm not sure what you mean, because as far as I know, JavaScript doesn't have native enums. TypeScript has native enums, which are converted into just a regular object at runtime.

---

Why you should not use TypeScript Enums:

• TypeScript's Worst Feature (And How To Avoid It)
• Enums considered harmful
• How to use TypeScript Enums and why not to, maybe

[rogadev]

Sorry, mistyped it - TypeScript enums.

[mrhyde]

Why you should not use TypeScript Enums:

• TypeScript's Worst Feature (And How To Avoid It)
• Enums considered harmful
• How to use TypeScript Enums and why not to, maybe

Before making a bold statement based on videos that try to attract attention with catchy titles, consider at least reading the comments. You will notice that many people disagree with the downsides described in those videos because they are often exaggerated or pulled out of thin air.

[mjp0]

So, let me get this straight: I can do z.enum(["foo", bar"]) but I can't do const e = ["foo", bar"]; z.enum(e)?

This makes zero sense. I have a bunch of SSOT JSON lists which I though I could just push as enums.

[lorenzoa7]

Same issue here...

[andredezzy]

Same issue

[mariuslundgard]

Try const e = ["foo", bar"] as const; z.enum(e)

[scotttrinh]

The fundamental issue is the z.enum (as well as a few other Zod schema types) is written in a way that guarantees that the array you feed it has at least one value of the array's element type. This is the only way to actually get compile-time information about the values of the enum.

If all you care about is having a schema that validates if a value is included in another array, you can make a custom Zod type like:

const e = ["foo", "bar"];

const oneOfE = z.custom<string>((val) => e.includes(val));

If, on the other hand you do want to have access to "foo" and "bar" at compile time, and those strings are actually constant in your code and compile time (via assignment to a variable), you can use as const to indicate to TypeScript that this is a constant value in your program.

If it's actually dynamic (like in the example given of loading JSON from disk or the network, etc), then yeah, the z.custom check will work, but you won't get anything useful out of the type, just string, which might be fine for your use case!

[letstri]

I've created a utility function to enhance the type safety of Zod enums.

The zodEnum function takes an array of values and casts it to a tuple type where the first element is of the same type as the array, and the rest are of the same type as well.

const zodEnum = <T>(arr: T[]): [T, ...T[]] => arr as [T, ...T[]];

Now, you can use this function to satisfy Zod's enum typization.

For example, let's say you have a type 'UserType' and array with it:

type UserType = 'admin' | 'user';

const userTypes = ['admin', 'user'] satisfies UserType[];

By applying the zodEnum function, you satisfy Zod's enum expectations, and the type checker will no longer raise an error.

// With error
z.enum(userTypes);

// Without error
z.enum(zodEnum(userTypes));

Or you can validate it:

z.enum(zodEnum<UserType>(['admin', 'user']));

[babpulss]

I've tried like below
z.enum(['', ...Object.values(obj)])

[AbubakarWebDev]

Maybe this could be considered as a hacky way to do it, but it works 100%, and you can also do it using the below approach:

const ASPECT_RATIOS = {
  ONE_BY_ONE: '1:1',

  THREE_BY_TWO: '3:2',
  TWO_BY_THREE: '2:3',

  FOUR_BY_FIVE: '4:5',
  FIVE_BY_FOUR: '5:4',

  FOUR_BY_THREE: '4:3',
  THREE_BY_FOUR: '3:4',

  NINE_BY_SIXTEEN: '9:16',
  SIXTEEN_BY_NINE: '16:9',

  FIVE_BY_TWELVE: '5:12',
  TWELVE_BY_FIVE: '12:5',
} as const;

export const AspectRatioSchema = z.enum([
  ASPECT_RATIOS.ONE_BY_ONE,
  ...Object.values(ASPECT_RATIOS),
]);

// infer the above schema type
export type AspectRatioSchemaType = z.infer<typeof AspectRatioSchema>;

You can also verify the typescript inter for this type from the screenshot below:

The reason for the above solution working is that the Zod enum can accept read-only strings while spreading the read-only string array.