Required object with optional fields

[florianakos]

Hi

I noticed something unexpected when trying to validate objects and fields. In the particular case, I had an object with few random fields, one field was itself an object that was required, but had all of its internal fields defined as optional. I would have expected this to work, but zod parse throws an error.

Example:

const example = z.object({ 
    field1: z.string().optional(), 
    field2: z.object({ first: z.string().optional(), second: z.string().optional()}).required(), 
    field3: z.number().optional()
})

Then trying to validate it, when both fields of field2 are there it works, when one is missing it fails:

> example.safeParse({ field1: 'something', field2: { first: 'bar', second: 'bar'}, field3: 123})
{
  success: true,
  data: {
    field1: 'something',
    field2: { first: 'bar', second: 'bar' },
    field3: 123
  }
}
> example.safeParse({ field1: 'something', field2: { first: 'bar'}, field3: 123})
{ success: false, error: [Getter] }

My expectation would be that either fields of first or second being present should satisfy the field2 schema and the latter validation should succeed, but it does not and instead, both fields need to be present.

Is there something that I'm doing wrong, or is this expected?

Thanks!

[JacobWeisenburger]

https://github.com/colinhacks/zod#required

Contrary to the .partial method, the .required method makes all properties required.

Try doing something like this:

const schema = z.object( {
    field2: z.object( {
        first: z.string(),
        second: z.string(),
    } ).partial(),
} )

console.log( schema.parse( { field2: { first: 'foo', second: 'bar' } } ) ) // { field2: { first: 'foo', second: 'bar' } }
console.log( schema.parse( { field2: { first: 'bar' } } ) ) // { field2: { first: 'bar' } }
console.log( schema.parse( { field2: {} } ) ) // { field2: {} }

const result = schema.safeParse( {} )
!result.success && console.log( result.error.issues )
// [
//     {
//         code: "invalid_type",
//         expected: "object",
//         received: "undefined",
//         path: [ "field2" ],
//         message: "Required"
//     }
// ]

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

[florianakos]

Hi @JacobWeisenburger , thanks for the response.

My intention with the schema is to enforce the presence of at least one field as required, such that { field2: {} } would result in validation error because field2 contains empty object.

These should satisfy the schema:

• { field2: { first: '...' } }
• { field2: { second: '...' } }
• { field2: { first: '...', second: '...' } }

Is there any way to express that with ZOD?

[JacobWeisenburger]

Is this what you are looking for?

const schema = z.object( {
    field2: z.union( [
        z.object( { first: z.string(), second: z.string() } ),
        z.object( { first: z.string() } ),
        z.object( { second: z.string() } ),
    ] )
} )

console.log( schema.safeParse( { field2: { first: 'bar' } } ).success ) // true
console.log( schema.safeParse( { field2: { second: 'bar' } } ).success ) // true
console.log( schema.safeParse( { field2: { first: 'foo', second: 'bar' } } ).success ) // true
console.log( schema.safeParse( { field2: {} } ).success ) // false

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

[florianakos]

Thanks, I discovered this option of using the union and wondered if there was any better way that does not require duplication in the definition.

[JacobWeisenburger]

Is this what you are looking for?

const objectSchema = z.object( {
    first: z.string(),
    second: z.string(),
} )

const schema = z.object( {
    field2: z.union( [
        objectSchema,
        objectSchema.pick( { first: true } ),
        objectSchema.pick( { second: true } ),
    ] )
} )

console.log( schema.safeParse( { field2: { first: 'bar' } } ).success ) // true
console.log( schema.safeParse( { field2: { second: 'bar' } } ).success ) // true
console.log( schema.safeParse( { field2: { first: 'foo', second: 'bar' } } ).success ) // true
console.log( schema.safeParse( { field2: {} } ).success ) // false

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

[muhsin-life]

example?

[zhe]

how about using .partial? https://zod.dev/?id=partial

const example = z.object({ 
    field1: z.string().optional(), 
    field2: z.object({ first: z.string(), second: z.string()}).partial(), 
    field3: z.number().optional()
})

// both true
example.safeParse({ field1: 'something', field2: { first: 'bar', second: 'bar'}, field3: 123})
example.safeParse({ field1: 'something', field2: { first: 'bar'}, field3: 123})