Function to create a union of literal dynamically

[william0bra]

Currently, it does not seem to be possible to create a function that does union of literal, like:

function unionOfLiterals<T extends string | number>(constants: readonly T[]): z.ZodUnion<[ZodTypeAny, ...ZodTypeAny[]]> {
  const literals = constants.map((constant) => z.literal(constant)) as [z.ZodLiteral<T>, ...z.ZodLiteral<T>[]];
  return z.union(literals);
}

const MY_CONSTANTS = ['a', 'b', 1] as const;
const unionType = createUnionType(MY_CONSTANTS);

This code gives the following typing error:

Argument of type '[ZodLiteral<T>, ...ZodLiteral<T>[]]' is not assignable to parameter of type 'readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]'.
  Source provides no match for required element at position 1 in target.ts(2345)

And a call to this method returns a z.ZodUnion<[ZodTypeAny, ...ZodTypeAny[]]> object.

Providing the constants directly is straightfoward:

z.union([z.literal('a'), z.literal('b'), z.literal(1)])

If that was possible, it would enable several use cases for using solely zod for API input validation. Now I end up losing typing when doing that indirectly.

Amazing library, by the way.

[JacobWeisenburger]

Is this what you are looking for?

function unionOfLiterals<T extends string | number> ( constants: readonly T[] ) {
    const literals = constants.map(
        x => z.literal( x )
    ) as unknown as readonly [ z.ZodLiteral<T>, z.ZodLiteral<T>, ...z.ZodLiteral<T>[] ]
    return z.union( literals )
}

const MY_CONSTANTS = [ 'a', 'b', 1 ] as const
const unionType = unionOfLiterals( MY_CONSTANTS )
type UnionType = z.infer<typeof unionType>
// type UnionType = "a" | "b" | 1

console.log( unionType.parse( 'a' ) ) // a
console.log( unionType.parse( 'b' ) ) // b
console.log( unionType.parse( 1 ) ) // 1
console.log( unionType.safeParse( 'foo' ).success ) // false

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

[william0bra]

The runtime works, the problem is that typescript identifies it as string[], instead of ('a' | 'b' | 1)[].

[JacobWeisenburger]

The runtime works, the problem is that typescript identifies it as string[], instead of ('a' | 'b' | 1)[].

Please show me where typescript identifies "it" as string[], instead of ('a' | 'b' | 1)[].

as you can see in my example above: type UnionType = "a" | "b" | 1

type UnionType = z.infer<typeof unionType>
// type UnionType = "a" | "b" | 1

[william0bra]

You are correct. When I started a blank project with your code it was working perfectly. It was an issue in my code. Thanks a lot.

[ImLunaHey]

here's a better version that doesnt require as const to be used.

function unionOfLiterals<const T extends readonly (string | number)[]>(constants: T) {
  const literals = constants.map((x) => z.literal(x)) as unknown as [
    z.ZodLiteral<T[number]>,
    z.ZodLiteral<T[number]>,
    ...z.ZodLiteral<T[number]>[],
  ];
  return z.union(literals);
}