Discriminated Union based on nested object property?

[sharedRoutine]

Hi there!

I've been playing around with Zod a lot lately and I've been defining a lot of different schemas. When I was reading up on discriminatedUnions, it got me thinking if the following was possible to define in zod:

{
   subscription: {
      type: 'typeA' | 'typeB'
  },
  event: {
      id: 1234 // only present in typeA subscriptions
      name: "abc"
  }
}

I could make this property option and use refine to check if type is typeA and then enforce id to be present, which is what I am currently going with.
However I'd like to define a discriminatedUnion based on the subscription type and then define the event object accordingly.

Is there any way this can be achieved?

e.g

z.discriminatedUnion("subscription.type", [
  z.object({ 
    subscription: z.object({ 
      type: z.literal("typeA") 
    }) 
  }),
  z.object({ 
    subscription: z.object({ 
      type: z.literal("typeB") 
    }) 
  }),
])

Thanks!

[DNoel26]

I find using superRefine for these more complicated use cases to work well so far. Maybe try something like

z
    .object({
        subscription: z.object(YourZodSchema).superRefine((val, ctx) => {
            if (val.type === 'typeA") {
                // do something
                // can add issue via ctx.addIssue
                // or can z.something().parse(val)
            } else {
                // do other thing
                // can other add issue via ctx.addIssue
                // or can other z.something().parse(val)
            }
        })
    })

[tazmaniax]

I need the same nested object property as a discriminator functionality but I get the impression it's still not supported despite all of the discussions in #2106 , yes?

[0xdevalias]

See also:

• Nested discriminated unions #1618
• https://www.ryanschiang.com/zod-nested-discriminated-union
• Deprecating z.discriminatedUnion? #2106
  • RFC: Faster unions (vs z.switch()) #3407

[0xdevalias]

I was hoping to be able to do something like this:

const statusQuerySchema = z.discriminatedUnion("customStatus.stage", [
  statusQueryFooResultSuccessSchema,
  statusQueryBarResultSuccessSchema,
]);

I'm not sure if this is a good way to achieve it, but I was playing around this afternoon and came up with this idea as a hacky workaround; basically using preprocess to create a root level key that I could then use as my discriminator:

z.preprocess(
  (input) => {
    if (typeof input !== "object" || input === null) return input;

    const result = z
      .object({
        customStatus: customStatusSchema,
      })
      .safeParse(input);

    if (result.success) {
      return {
        ...input,
        _flattenedCustomStatusStage: result.data.customStatus.stage,
        _flattenedCustomStatusStatus: result.data.customStatus.status,
      };
    }
  },
  z.discriminatedUnion("_flattenedCustomStatusStage", [
    statusQueryFooResultSuccessSchema,
    statusQueryBarResultSuccessSchema,
  ]),
);

[jonnysamps]

@0xdevalias thats a good workaround until there is first-class support.