Can't use discriminatedUnion after transform

[alexgleason]

I'm building a federated social media app (think like Mastodon) which validates external json data in ActivityStreams format.

There are various competing ways to implement a quote post, for example. I want to consolidate them into one:

const noteSchema = z.object({
  type: z.literal('Note'),
  id: apId,
  to: recipients,
  cc: recipients,
  content: z.string(),
  attachment: z.array(attachmentSchema).optional().catch(undefined),
  inReplyTo: apId.optional(),
  attributedTo: apId,
  published: published(),

  // Quote posting
  quoteUrl: apId.optional(),
  quoteURL: apId.optional(),
  quoteUri: apId.optional(),
  _misskey_quote: apId.optional(),
}).transform((note) => {
  const { quoteUrl, quoteUri, quoteURL, _misskey_quote, ...rest } = note;

  return {
    // Consolidate the quote into one field
    quoteUrl: quoteUrl || quoteUri || quoteURL || _misskey_quote,
    ...rest,
  }
});

This mostly works, but since transform returns a ZodEffect, I can no longer do a discriminated union over it.

I've tried accessing noteSchema._def.schema for the discriminated union, as suggested in #2056 (comment), but this returns the input schema.

Is there a better way to do what I'm trying to do with Zod?

[JacobWeisenburger]

Is this what you are looking for?

const noteSchema = z.object( {
    type: z.literal( 'Note' ),
    id: apId,
    to: recipients,
    cc: recipients,
    content: z.string(),
    attachment: z.array( attachmentSchema ).optional().catch( undefined ),
    inReplyTo: apId.optional(),
    attributedTo: apId,
    published: published(),
    quoteUrl: apId.optional(),
} )

const flexibleNoteSchema = noteSchema.extend( {
    quoteURL: apId.optional(),
    quoteUri: apId.optional(),
    _misskey_quote: apId.optional(),
} ).transform( ( note ) => {
    const { quoteUrl, quoteUri, quoteURL, _misskey_quote, ...rest } = note
    return {
        quoteUrl: quoteUrl || quoteUri || quoteURL || _misskey_quote,
        ...rest,
    }
} )

const objectSchema = z.union( [
    flexibleNoteSchema,
    actorSchema,
] ).pipe(
    z.discriminatedUnion( 'type', [
        noteSchema,
        actorSchema,
    ] )
)

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

[alexgleason]

Getting closer. Now z.infer<typeof objectSchema> only includes fields shared between actorSchema and noteSchema. Thanks for introducing me to pipe(), thinking about it ⚙️

[alexgleason]

Actually my text editor was just freaking out. This seems to be working!

[JacobWeisenburger]

Thanks so much for the sponsorship! 🙏

[codingedgar]

For anyone else finding this issue, this is a limitation of zod at least until v4 #2441 (comment)

The accepted answer is a valid workaround, but I have the hunch that it throws the advantage of using z.discriminatedUnion, which is fast parsing.

An alternative, that might be more efficient could be

const noteSchema = z.object( {
    type: z.literal( 'Note' ),
    id: apId,
    to: recipients,
    cc: recipients,
    content: z.string(),
    attachment: z.array( attachmentSchema ).optional().catch( undefined ),
    inReplyTo: apId.optional(),
    attributedTo: apId,
    published: published(),
    quoteUrl: apId.optional(),
} );

const objectSchema = z.discriminatedUnion( 'type', [
        noteSchema,
        actorSchema,
    ])
    .transform((val) =>
         val.type === 'Note'
               // put the transforms after the switch
               ? ({...val, quoteUrl: quoteUrl || quoteUri || quoteURL || _misskey_quote})
               : val
      )

(Or just use z.union no point piping? not sure if zod is smart enough to avoid what seems to be a double parsing, even tho the types make sense there is a runtime cost involved)