Passing a variable that holds an array of schemas into z.discriminatedUnion() fails

[gahabeen]

Description

Passing a variable that holds an array of schemas to a z.discriminatedUnion() isn't possible on [email protected].

📍 Run the issue

const ThingSchemas = [
  z.object({ type: z.literal('vehicle'), name: z.string() }),
  z.object({ type: z.literal('food'), name: z.string() })
];

const Thing = z.discriminatedUnion('type', ThingSchemas);

would prompt Source provides no match for required element at position 0 in target error.

✅ By-pass it

const ThingSchemas = [
  z.object({ type: z.literal('vehicle'), name: z.string() }),
  z.object({ type: z.literal('food'), name: z.string() })
];

const Thing = z.discriminatedUnion('type', [ThingSchemas[0], ...ThingSchemas.slice(1)]);

Manually structuring the first item of the array and spreading the rest for the win 🤟

[JacobWeisenburger]

What are you wanting to be done about this? Or are you just posting it so other people can use your solution?

[gahabeen]

I'd have expected to work out of the batch. Or am I wrong that it should work? 🤔
So mostly raising the issue and sharing a "hacky" solution for the ones in need 🤟

[willruggiano]

It's not hacky; it's just how Typescript works. ThingSchemas is inferred to be an z.ZodObject<...>[].

Perhaps a request that comes out of this issue would be to allow z.discriminatedUnion to take a readonly []? I haven't looked at the internals of discriminatedUnion to know if this is feasible. But, if so, you could just add a as const to the end of your ThingSchemas declaration.

const ThingSchemas = [
  z.object({ type: z.literal('vehicle'), name: z.string() }),
  z.object({ type: z.literal('food'), name: z.string() })
] as const;  // <-- add this

which causes ThingSchemas to have an inferred type similar to: readonly [z.ZodObject<...>, z.ZodObject<...>]

[willruggiano]

which satisfies the type expected by discriminatedUnion, except for the readonly part.

You could of course manually remove that with a mapped type;

type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
}

and then;

z.discriminatedUnion("type", ThingSchemas as Mutable<typeof ThingSchemas>);

but now we're starting to get more verbose than the OP's "hacky" solution