Appetite for xor method (like joi) to require one of a set of object keys, but never together

[rubengmurray]

Unless I'm mistaken, a simple helper method for the functionality of xor (exclusive or) does not exist for zod.

The definition of xor would be:

Provide one of these N keys, but never together

Instead, all I can find is the recommended use of a chained .refine():

z.object(...)
  .refine(args =>
    !(args.val1 !== undefined && args.val2 !== undefined),
  { message: 'val1 and val2 cannot be provided together' },
  )
  .refine(args =>
    args.val1 === undefined && args.val2 === undefined,
  { message: 'one of val1 or val2 must be provided' },
  );

Is there opposition about introducing such a helper method?

I find it very cumbersome to write the refine logic and it's also a bore to read.

[ImPrankster]

I think if you only have a small set of possible combinations of keys, you can use Discriminated Unions

[rubengmurray]

Does that really fit the case I'm describing?

A discriminated union is a union of object schemas that all share a particular key.

---

In my example I reference a rule that refers to val1 & val2. There is no 'shared key'

The most basic schema representation of this would be:

const schema = z.object({
  val1: z.number(),
  val2: z.number(),
})

What is the discriminated union suggestion given there is no common key to check against? This also doesn't feel very scalable.

const myUnion = z.discriminatedUnion(?, [
  z.object({ val1: z.number() }),
  z.object({ val2: z.number() }),
]);

[roberto-red]

The .or schema method, although documented in the alias .union method, will only parse the first coincidence of the list of schemas passed:

Zod will test the input against each of the "options" in order and return the first value that validates successfully.

So it actually is a XOR functionally. Edit: oh, no. It won't fail when both params are provided. But at least let you have a single .refine for that case.

P.S.: I actually came here because the .union method does not allow to implement an schema that fits TypeScript non-exclusive union types.

[JacobWeisenburger]

Is this what you are looking for?

const schema = z.union( [
    z.object( { val1: z.string() } ).strict(),
    z.object( { val2: z.string() } ).strict(),
] )

console.log( schema.parse( { val1: 'a' } ) ) // { val1: 'a' }
console.log( schema.parse( { val2: 'b' } ) ) // { val2: 'b' }

const result = schema.safeParse( { val1: 'a', val2: 'b' } )
!result.success && console.log( result.error.issues )
// [
//     {
//         code: "unrecognized_keys",
//         keys: [ "val2" ],
//         path: [],
//         message: "Unrecognized key(s) in object: 'val2'"
//     }
// ]

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

[Lonli-Lokli]

That's a great example thanks, but can you also extend it with custom error, eg 'You cannot have both val1 and val2'?