Using a union for the discriminator with discriminatedUnions fails

[affanshahid]

Using a union for the discriminator value with discriminatedUnions yields this runtime error:

Error: A discriminator value for key `status` could not be extracted from all schema options

Sample code:

const myUnion = z.discriminatedUnion("status", [
  z.object({ status: z.union([z.literal("success"), z.literal("ok")]) , data: z.string() }),
  z.object({ status: z.literal("failed"), error: z.instanceof(Error) }),
]);

myUnion.parse({ status: "success", data: "yippie ki yay" });

The valid type for this would be something like:

type myUnion = {
  status: "success" | "ok";
  data: string;
} | {
  status: "failed";
  error: Error;
}

The workaround is to duplicate the the entry for each value in the inner union.

[conorbrandon]

I just ran into this same issue (the case of using a ZodUnion discriminator comprised of only ZodLiterals).

I went here to file an issue and found this was the latest one. Perfect timing! 🤯

1. Would it be feasible to allow ZodUnions with only ZodLiterals as a valid discriminator option? I totally understand if not, because another workaround (@affanshahid) is to use a ZodEnum, which has the exact same effect as ZodUnion<ZodLiteral[]>.
2. Maybe instead, the discriminator schema in ZodDiscriminatedUnionOption could be restricted from ZodTypeAny to one of the actual allowed schemas as seen in getDiscriminator?
3. Perhaps, the error message:
   1. Could be improved to indicate exactly which schema was unable to be extracted, instead of just saying "all"?
   2. Include as part of the message which schemas are even allowed as discriminators?
4. The discriminated union docs could make a note about common pitfalls? (i.e. which schemas are even allowed as discriminators)

I really enjoy using Zod, and many thanks to all who've contributed to make it great, but I feel there could be an improvement made here somewhere... (At least in the documentation? 🥲)

[affanshahid]

Thanks for the enum suggestion @conorbrandon. I can't use the enum approach it seems since it only accepts a list of strings and in my actual use case the discriminator is a number.

[conorbrandon]

Ah, gotcha!

[JacobWeisenburger]

Is this what you are looking for?

const myUnion = z.discriminatedUnion( 'status', [
    z.object( {
        status: z.literal( 'success' ),
        data: z.string(),
    } ),
    z.object( {
        status: z.literal( 'ok' ),
        data: z.string(),
    } ),
    z.object( {
        status: z.literal( 'failed' ),
        error: z.instanceof( Error ),
    } ),
] )

myUnion.parse( { status: 'success', data: 'yippie ki yay' } )

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

[Anoesj]

Hmm, what a shame it only supports z.enum, but not z.union. Is there a way to get around this without specifying all literals in separate objects if the literals are numbers?