What is zod's approach to conditionally requiring fields?

[ljunio]

I have a situation where I need to conditionally require another field based on the validity of another field. AFAIK, we can only enforce this by using refine or superRefine. The enforcement however only comes to fruition through the use of addIssue(...). Is there a way to actually set a field as a required or optional or is that basically what refine/superRefine does under the hood?

[scotttrinh]

I have a situation where I need to conditionally require another field based on the validity of another field.

You have a few choices, but it depends on what those conditions are. In all things, it's best to be as truthful to the schema as you can, which sometimes requires multiple schemas or some duplication.

Other than refine, you might also be able to represent your schema as a union where each member has a shape that is valid based on some rules, like:

const fooSchema = z.object({
  bar: z.string().min(1),
  baz: z.string().min(1),
});

const bazSchema = z.object({
  bar: z.literal(""),
  baz: z.literal(""),
});

const schema = z.union([fooSchema, bazSchema]);

schema.safeParse({ bar: "not empty", baz: "" }); // failure
schema.safeParse({ bar: "", baz: "" }); // success
schema.safeParse({ bar: "not empty", baz: "not empty also" }); // success

It might help to provide some simple examples of what problem you're trying to model.

[JacobWeisenburger]

There might be other ways to do this, but I feel like refine is the best way to be the most clear.

Here's a simple example of how to use refine for this.

const myString = z.object( {
    foo: z.string(),

    // must be optional or parse will fail before refinement is applied
    bar: z.string().optional(),
} ).refine( input => {

    // allows bar to be optional only when foo is 'foo'
    if ( input.foo !== 'foo' && input.bar === undefined ) return false

    return true
} )

// bar is optional here
console.log( myString.safeParse( { foo: 'foo' } ).success ) // true
console.log( myString.safeParse( { foo: 'foo', bar: 'bar' } ).success ) // true
console.log( myString.safeParse( { foo: 'foo', bar: undefined } ).success ) // true

// bar is required here
console.log( myString.safeParse( { foo: 'not foo', bar: 'bar' } ).success ) // true
console.log( myString.safeParse( { foo: 'not foo' } ).success ) // false
console.log( myString.safeParse( { foo: 'not foo', bar: undefined } ).success ) // false

[Aaronius]

I'm trying to do something similar to @ljunio and followed your example. One problem I have is that I'm trying to merge myString, in your example, into another object. Basically:

const otherObject = z.object({}).merge(myString);

But I can't because ZodEffects isn't assignable to AnyZodObject.

[Aaronius]

Similarly, I can't merge a ZodUnion into a ZodObject or a ZodObject into a ZodUnion. Also, this gets really tricky when I try to use ZodEffects or ZodUnions for objects that are part of a ZodDiscriminatedUnion. 😓

[tkowalski-exxeta]

This seems to be a bug IMHO. Does any ticket exist for this?

[gabeodame]

You can apply superRefine after merging example

const mergedSchema = schemaA.merge(schemaB)
export const FormSchema = mergedSchema.superRefine((data, ctx) => {
  if (condition) {
    ctx.addIssue({
      code: z.ZodIssueCode.custom,
      message: "custom message",
      path: ["property"],
    });
  }
});

[bizmich]

how to make optional if its initially required ?

[toxsick]

There is also #1394 now

[ramil-thrive]

I came up with something like this:

const registrationFormSchema = z.object({
    firstName: firstNameValidator,
    lastName: lastNameValidator,
    email: z.string().optional(), // Keeping both email and phone optional on base schema and validating values inside `superRefine`
    phone: z.string().optional(),
    postalCode: canadianPostalCodeValidator,
    specificGroupServices: z.string().optional(),
    isOntarioResident: booleanRadioGroupValidator,
    isAllowedToWorkInCanada: booleanRadioGroupValidator,
    isStudent: booleanRadioGroupValidator,
    hasAgreedToTermsAndPolicies: z.boolean(),
  })
  // Perform conditional validation to ensure either a valid email or phone number is provided.
  .superRefine(({ email, phone }, refinementContext) => {
    if (email === '' && phone !== '' && !getIsValidMobilePhone(phone ?? '')) {
      return refinementContext.addIssue({
        code: z.ZodIssueCode.custom,
        message: i18n.t('forms.validations.invalid.phone'),
        path: ['phone'],
      });
    }

    if (email !== '' && phone === '' && !getIsValidEmail(email ?? '')) {
      return refinementContext.addIssue({
        code: z.ZodIssueCode.custom,
        message: i18n.t('forms.validations.invalid.email'),
        path: ['email'],
      });
    }
  });

Example UI:

[asifsaho]

perfect, this helped me a lot. I was blocked for days! thanks for sharing :)

[ashwary23]

I have another question @ramil-thrive .
lets say I have another schema
optionalFieldsSchema: z.object({ field1: z.string(), field2: z.string() })
and I want it to be added to registrationFormSchema only if isStudent === true
can you let me know the solution, I am blocked since long.

[micahjon]

Hey @ashwary23 , I've run into a similar situation before where I want to entirely remove parts of my schema based on a form's conditional logic. The first step is making all conditional fields .optional() e.g.

 optionalFieldsSchema: z.object({ field1: z.string(), field2: z.string() }).optional(),

The next part is tricky: you need to detect when this field is hidden and remove it from your form's data before validation, so that any validation errors in the hidden field's value doesn't prevent submission (assuming you're using shouldUnregister = false). I ran into this again and again, and eventually wrote my own tiny helper library from conditional logic in React Hook Form and Zod:
https://github.com/micahjon/rhf-conditional-logic

Essentially, I just define conditions outside of my Zod schema (for optional fields)...

const conditions = {
    optionalFieldsSchema: getValues => getValues("isStudent") === true
}

And then prune them pre-validation & post-submission. Not an ideal solution but at least this way it's type-safe and declarative, and scales to many conditions, while my schema remains clean & simple.

[dlibis]

small correction to your code, return refinementContext at the end