Feature request: one of fields required

If I am not mistaken right now you have to use refine and write your own logic to support such a feature. Zods goal is a nice developer experience and I think this would a good addition.

const schema = z.object({
  name: z.string().nonempty(),
  familyName: z.string().nonempty(),
  email: z.string().email(),
  phone: z.string(),
}).oneOf('email', 'phone')

This schema would only require nonempty email or phone.

[liamfd]

If I understand correctly, one downside of the refinement is that it doesn’t carry through to the type system, so TS won’t understand that exactly one of these keys has a value.

I know in TS you can express this “exactly one” requirement like:

type Person = {
  name: string;
  familyName: string;
} & (
  | { email: string; phone?: undefined }
  | { email?: undefined; phone: string }
);

(Which correctly requires exactly one of those two keys, lets you destructure, types result.email ?? result.phone as string instead of string | undefined, etc.)

Looks like you can more or less directly translate this to zod (which is awesome!):

  const base = z.strictObject({
    name: z.string(),
    familyName: z.string(),
  });
  const schema = z.union([
    base.merge(
      z.strictObject({ email: z.string(), phone: z.undefined().optional() })
    ),
    base.merge(
      z.strictObject({ email: z.undefined().optional(), phone: z.string() })
    ),
  ]);
  
  schema.parse({ name: 'a', familyName: 'b', email: 'c' }) // passes (good)
  schema.parse({ name: 'a', familyName: 'b', phone: 'd' }) // passes (good)
  schema.parse({ name: 'a', familyName: 'b', email: 'c', phone: 'd' }) // throws (good)
  schema.parse({ name: 'a', familyName: 'b' }) // throws (good)
  
  const result = schema.parse({...});
  const { email, phone } = result; // can destructure both 
 
  // this wouldn't work with the refinement because it doesn't carry through to the type, TS would see
  // this as string | undefined
  const contact: string = result.email ?? result.phone; // works

Not sure if there’s a more elegant way to do this, but it seems to be working. Also, I’m pretty sure this could be adapted to support “at least one of a or b” instead of “exactly one”.

---

Just thought I’d share in case anyone else comes across this issue trying to figure out how to get this working like I did.

[colinhacks]

I think this is a nice idea but too niche to introduce into core. If people disagree feel free to comment and perhaps I’ll revisit this.

It’s easy enough to split out this logic in a reusable way.

const oneOf = (keys: string[]) => (val: any) => {
  for (const k of keys) {
    if (val[k] !== undefined) return true;
  }
  return false;
};

z.object({
  a: z.string(),
  b: z.string(),
}).refine(oneOf(['a', 'b']), 'Must have either a or b.');