Enum From Object Literal Keys

[danielyogel]

As discussed in other issues in this repo, it is not trivial to create an enum from an object literal keys, or even from an array of strings: (Argument of type 'K[]' is not assignable to parameter of type '[string, ...string[]]'. Source provides no match for required element at position 0 in target.ts(2769))

Any objection to the following solution?
Is there something I'm missing?
Thanks.

import { z } from 'zod';
import { keys } from 'fp-ts/lib/Record';

export function ObjectKeysEnum<K extends string>(obj: Record<K, any>) {
  return z.enum([keys(obj)[0], ...keys(obj)]);
}

[JacobWeisenburger]

I'm not exactly sure what you are asking, but it seems that your solution works ok. However, the types aren't intuitive in my opinion, which is not your fault. Unfortunately it's a problem with typescript.

If I were doing this, I would expect that keysEnum would be z.ZodEnum<["bar", "baz"]>, but it comes out as z.ZodEnum<["bar" | "baz", ...("bar" | "baz")[]]>. The reason for this is that it's not easy to make a tuple from a union of strings.

see here for more info:
https://stackoverflow.com/questions/55127004/how-to-transform-union-type-to-tuple-type

Since keyof returns a union of strings, it's problematic to make a tuple from it.

// I'm not familiar with fp-ts, so I made my own keys function, I'm pretty sure it's close enough to what you were using.
const keys = <K extends string> ( r: Record<K, any> ): K[] => Object.keys( r ) as K[]

export function ObjectKeysEnum<K extends string> ( obj: Record<K, any> ) {
    return z.enum( [ keys( obj )[ 0 ], ...keys( obj ) ] )
}

const obj = { bar: 'bar', baz: 'baz' } as const
type ObjKeys = keyof typeof obj
//-> ObjKeys = "bar" | "baz"

const keysEnum = ObjectKeysEnum( obj )
// -> keysEnum: z.ZodEnum<["bar" | "baz", ...("bar" | "baz")[]]>

keysEnum.safeParse( 'bar' ).success // true
keysEnum.safeParse( 'baz' ).success // true
keysEnum.safeParse( 'something else' ).success // false

I hope this helps, please let me know if you have any questions. Or if I didn't answer your question, please clarify what you are asking.

[danielyogel]

Thanks! I think we understand each other.

I haven't deeply read the Stack Overflow explanation, but looks like this "ObjectKeysEnum" util does what it does 100% fine, and is very useful in many situations - so I would suggest adding something like that to Zod's core.

[JacobWeisenburger]

I'm not really understanding why something like this needs to be added to Zod core. Could you please explain more why you think it should be. I'm not saying it shouldn't, I'm just wanting to understand what your reasoning is.

[danielyogel]

A good fit for this would be anytime you have some generated object literal, that describes some type, that for some reason you need to also represent as a Zod type (and you want the transformation to be generic).

A specific example example would be my usage of Prisma ORM, where I declare Enums in Prisma’s DSL, then import a generated object literal that describes this Enum, then transform it into a Zod’s Enum so my tRPC (a lib I use to create type safe APIs) will have the same type as the Prisma’s one. Before this change, anytime I’ve changed the Prisma’s Enum I had to manually change also the Zod Enum, because the first key was specified explicitly, after this change this transformation is generic so happens automatically.

[JacobWeisenburger]

I'm having a hard time picturing what that would look like in code. Would you be able to provide a generic code example where this would be useful? I'm thinking it would be helpful to see some code that didn't involve any libraries other than Zod.

I'm thinking that what you are talking about is related to How tol solve this DRY violation #822. But I'm wanting to be sure that you are talking about the same thing.

Full disclosure, I'm not the person you need to convince to get this added to Zod core, but I'm trying to help so when that person comes along to see your idea, then they have all the info they need to make an informed decision. Hopefully, I haven't sounded like a jerk with all my questions. lol :D

Also, if you are really wanting this to get added to Zod core. Consider adding a pull request for it. It's a ton easier/faster for the reviewers of a library to approve a pull request than it is to only give them an idea and then ask for someone else to write the code.

[sbking]

@JacobWeisenburger Sorry to revive this old thread, but here is a concrete example of how this could be useful:

const ordering = {
  new: (a, b) => b.createdAt - a.createdAt,
  old: (a, b) => a.createdAt - b.createdAt,
  popular: (a, b) => b.comments.length - a.comments.length,
} satisfies Record<string, (a: Post, b: Post) => number>;

const orderingSchema = z.keyof(ordering);

// ...

const sortParam = url.searchParams.get('sort');
posts.sort(ordering[orderingSchema.parse(sortParam)]);

In a production use case the ordering object would likely contain ordering specifiers to pass to an ORM rather than sort callbacks.

[JacobWeisenburger]

@sbking @danielyogel

I think I understand the problem better now. Thanks.

Here's how I would solve it:

function zodEnumFromObjKeys<K extends string> ( obj: Record<K, any> ): z.ZodEnum<[ K, ...K[] ]> {
    const [ firstKey, ...otherKeys ] = Object.keys( obj ) as K[]
    return z.enum( [ firstKey, ...otherKeys ] )
}

type Post = {
    createdAt: number
    comments: string[]
}

const ordering = {
    new: ( a: Post, b: Post ) => b.createdAt - a.createdAt,
    old: ( a: Post, b: Post ) => a.createdAt - b.createdAt,
    popular: ( a: Post, b: Post ) => b.comments.length - a.comments.length,
} as const
// } satisfies Record<string, (a: Post, b: Post) => number>
// you could use the new `satisfies` keyword here,
// but I'm using deno so I don't have that until the next release in a week or so. :(

const orderingSchema = zodEnumFromObjKeys( ordering )
type Ordering = z.infer<typeof orderingSchema>
// type Ordering = 'new' | 'old' | 'popular'

const sortParam = new URLSearchParams( 'sort=new' ).get( 'sort' )

const posts: Post[] = [
    {
        createdAt: 1,
        comments: [ 'a', 'b' ],
    },
    {
        createdAt: 2,
        comments: [ 'a', 'b', 'c' ],
    },
]

const sortedPosts = posts.slice().sort(
    ordering[ orderingSchema.parse( sortParam ) ]
)

console.log( sortParam )
// 'new'

console.log( posts )
// [
//   { createdAt: 1, comments: [ "a", "b" ] },
//   { createdAt: 2, comments: [ "a", "b", "c" ] }
// ]

console.log( sortedPosts )
// [
//   { createdAt: 2, comments: [ "a", "b", "c" ] },
//   { createdAt: 1, comments: [ "a", "b" ] }
// ]

[bennik88]

I have the same issue. Has anyone a solution for this? It seems not typesafe.

[feychenie]

I had the same issue and changed things a bit, and in the end ended up with something that is a bit simpler IMO.

Notice the ! that is needed if you have noUncheckedIndexedAccess in your tsconfig.json):

[ftzi]

Awesome, thanks! Note that you probably can do just as (keyof T)[]

[krisgrm]

hello, this is nice solution, works on my side for "simple" object.. this is object without nested properties..

but i cannot get to the nested attributes no matter what i try, any ideas how to solve it?

i cannot extract nested attributes in its own schemas, because the schemas are auto-generated fron json-schemas

[CanRau]

Very helpful thank you 🙏🏼
Is there currently a way to achieve the same for integers using z.enum or z.union with z.literal couldn't get it working so far. Not so ideal alternative might be to convert the integers to strings first, hmm 🤔

[rstacruz]

I was just having this issue. My simple fix was:

const [firstKey, ...otherKeys] = Object.keys(MY_OBJECT)

z.enum([firstKey, ...otherKeys])

// ...if that still throws an error, also try:
z.enum([firstKey!, ...otherKeys])

[ivanakcheurov]

the simplest solution I could get by combining answers of @feychenie and @rstacruz:

Solution that provides autocompletion and validates input

/** Converts a plain object's keys into ZodEnum with type safety and autocompletion */
function getZodEnumFromObjectKeys<TI extends Record<string, any>, R extends string = TI extends Record<infer R, any> ? R : never>(input: TI): z.ZodEnum<[R, ...R[]]> {
    const [firstKey, ...otherKeys] = Object.keys(input) as [R, ...R[]];
    return z.enum([firstKey, ...otherKeys]);
}

// now let's define a plain object with string keys
const countries = {
    "NL": 1,
    "BE": 2,
};

// and convert it into ZodEnum that supports autocompletion
const zCountries = getZodEnumFromObjectKeys(countries);
//    ^ const zCountries: z.ZodEnum<["NL" | "BE", ...("NL" | "BE")[]]>

type Country = z.infer<typeof zCountries>;
//    ^ type Country = "NL" | "BE"
const country = zCountries.parse(YOUR_INPUT);
//    ^ const country: "NL" | "BE"

[beeirl]

Autocomplete didn't work for me so I adapted this solution in case anybody is interested:

function zObjectKeys<T extends Record<string, any>>(obj: T) {
  const keys = Object.keys(obj) as Extract<keyof T, string>[]
  return z.enum(keys as [Extract<keyof T, string>, ...Extract<keyof T, string>[]])
}