Recursively remove schema defaults

[dermotduffy]

Hello,

I'm seeking a means of recursively discarding schema defaults. Something akin to deepPartial that strips defaults, or a recursive version of removeDefault.

const schema = z.object(/* complex nested schema with defaults */)
const output = schema.deepRemoveDefault();
output.safeParse(/* parse the schema but no defaults used */)

Any bright ideas?

Thanks!

[scotttrinh]

You probably have a good reason for not doing this, but is there any reason not to define the base schema as not containing the defaults and then extend that schema with defaults? I know that isn't the DRY-est solution, but there isn't anything built into zod to do this, and I imagine doing it as a generic function will be tricky to get the return type inference to be correct.

[dermotduffy]

Thanks for the feedback! Issue with that is purely that it would involve defining the schema in 1 place (without defaults), then overriding every single attribute (with defaults) somewhere else -- feels more error prone and duplicative, vs a singular definition (with defaults) that is stripped out in a single call somewhere else [were such a call to be available!]. Schema is large and multi-way nested.

[JacobWeisenburger]

Could you provide some of the code that you are wanting to use this on? maybe there is a different approach that could solve your problem rather than trying to add/remove defaults. May there's not a different way, but it's worth a shot, right? :D

[dermotduffy]

Sure! The full schema is here but it's fairly large and complex to fully understand it all. Perhaps more useful is a distilled example/description:

Use case:

• Need 1 schema for configuration parsing with heavy use of defaults.
• Need another (very similar) schema for separate configuration overrides, but without defaults.
• These two then get combined in various ways during runtime.

Example configuration schema right now (nested objects can probably be ignored, but can be found at the above link):

const liveConfigSchema = z
  .object({
    provider: z.enum(LIVE_PROVIDERS).default(liveConfigDefault.provider),
    preload: z.boolean().default(liveConfigDefault.preload),
    webrtc: webrtcConfigSchema,
    jsmpeg: jsmpegConfigSchema,
    controls: z
      .object({
        thumbnails: thumbnailsControlSchema
          .merge(
            z.object({
              media: z
                .enum(['clips', 'snapshots'])
                .default(liveConfigDefault.controls.thumbnails.media),
            }),
          )
          .default(liveConfigDefault.controls.thumbnails),
      })
      .default(liveConfigDefault.controls),
  })
  .merge(actionsSchema)
  .default(liveConfigDefault);

My goal was to make a version of that schema without defaults. Without a removeDefaultsDeep type call, I'm throwing around things like this -- which are very verbose and fairly ugly:

const liveOverridableConfigSchema = z
  .object({
    provider: z.enum(LIVE_PROVIDERS).optional(),
    webrtc: webrtcConfigSchema,
    jsmpeg: jsmpegConfigSchema,
    controls: z
      .object({
        next_previous: liveNextPreviousControlConfigSchema.optional(),
        thumbnails: thumbnailsControlSchema
          .merge(
            z.object({
              media: z.enum(['clips', 'snapshots']),
            }),
          )
          .optional(),
      })
      .optional(),
  })
  .merge(actionsSchema);

// Use of shape below is to allow adding defaults to the overridable schema above, without redefining said shape.

const liveConfigSchema = liveOverridableConfigSchema
  .extend({
    // Replace attributes from the overridable schema with those with defaults.
    provider: liveOverridableConfigSchema.shape.provider.default(
      liveConfigDefault.provider,
    ),
    controls: z
      .object({
        next_previous: liveNextPreviousControlConfigSchema
          .extend({
            size: liveNextPreviousControlConfigSchema.shape.size.default(
              liveConfigDefault.controls.next_previous.size,
            ),
            style: liveNextPreviousControlConfigSchema.shape.style.default(
              liveConfigDefault.controls.next_previous.style,
            ),
          })
          .default(liveConfigDefault.controls.next_previous),
        thumbnails: thumbnailsControlSchema
          .extend({
            mode: thumbnailsControlSchema.shape.mode.default(
              liveConfigDefault.controls.thumbnails.mode,
            ),
            size: thumbnailsControlSchema.shape.size.default(
              liveConfigDefault.controls.thumbnails.size,
            ),
            media: z
              .enum(['clips', 'snapshots'])
              .default(liveConfigDefault.controls.thumbnails.media),
          })
          .default(liveConfigDefault.controls.thumbnails),
      })
      .default(liveConfigDefault.controls),

    // Non-overrideable parameters.
    preload: z.boolean().default(liveConfigDefault.preload),
    lazy_load: z.boolean().default(liveConfigDefault.lazy_load),
    draggable: z.boolean().default(liveConfigDefault.draggable),
    overrides: z
      .object({
        conditions: frigateCardConditionSchema,
        overrides: liveOverridableConfigSchema,
      })
      .array()
      .optional(),
  })
  .default(liveConfigDefault);

The other option would be to keep the schemas entirely separate and just redefine the, knowing that the resultant types will be compatible -- but that feels error prone.

[JacobWeisenburger]

You are right, this is very complex. Sorry if I'm asking dumb questions. What are you trying to achieve by having the same schema but without defaults? Why can't you use the one with defaults in both situations?

[dermotduffy]

The 'with defaults' schema is a fairly stock YAML-based configuration -- I want to support minimal user-provided configuration, hence the use of defaults.

For advanced setups, depending on conditions the user can specify, I need to be able to override that configuration -- I'm doing this by merging the base configuration (the one with defaults), with 1 or more sets of overrides that the user specifies based on conditions that the user also specifies. I cannot allow defaults in these overrides, since I then could not tell apart the overrides the user actually specified vs the ones that just happened to be the default in the schema.

For example, (just to illustrate) if the base configuration was:

animal: z.string().default('dog'),
food: z.string().default('bone'),

... the user could provide a set of overrides and conditions that could override that ...

overrides:
  -  condition:
       [conditions listed here]
     overrides:
       food: treats
  - condition:
       [conditions listed here]
    overrides:
      animal: dog

... if I reused the 'with defaults' schema for the overrides, and the above overrides were iteratively merged in (assuming the conditions met), I'd end up with:

animal: dog <-- OK, since this is what the user specified
food: bone <-- NOT OK, this is the default from the schema, should be 'treats' since the user overrode this in the previous set of overrides.

Thank you again for listening, apologies for the overly complex usecase...

[JacobWeisenburger]

oof, the rabbit hole just keeps getting deeper.

After looking into it more, making deepRemoveDefaults wasn't too complicated. So it could be a cool idea for Zod to add, but until they do, here is a function that should work. I haven't done a ton of testing on this, so you may need to make a few tweeks. I just copied deepPartialify and made a few changes. Hope this solves your problem.

function deepRemoveDefaults ( schema: z.ZodTypeAny ): any {
    if ( schema instanceof z.ZodDefault )
        return deepRemoveDefaults( schema.removeDefault() )

    if ( schema instanceof z.ZodObject ) {
        const newShape: any = {}

        for ( const key in schema.shape ) {
            const fieldSchema = schema.shape[ key ]
            newShape[ key ] = z.ZodOptional.create( deepRemoveDefaults( fieldSchema ) )
        }
        return new z.ZodObject( {
            ...schema._def,
            shape: () => newShape,
        } ) as any
    }

    if ( schema instanceof z.ZodArray )
        return z.ZodArray.create( deepRemoveDefaults( schema.element ) )

    if ( schema instanceof z.ZodOptional )
        return z.ZodOptional.create( deepRemoveDefaults( schema.unwrap() ) )

    if ( schema instanceof z.ZodNullable )
        return z.ZodNullable.create( deepRemoveDefaults( schema.unwrap() ) )

    if ( schema instanceof z.ZodTuple )
        return z.ZodTuple.create( schema.items.map( ( item: any ) => deepRemoveDefaults( item ) ) )

    return schema
}

const schema = z.object( {
    string: z.string().default( 'default' ),
    number: z.number().default( 42 ),
    object: z.object( {
        nestedString: z.string().default( 'default' ),
    } ).default( {} ),
} ).default( {} )

const schemaNoDefaults = deepRemoveDefaults( schema )

const schemaTestObj: z.infer<typeof schema> = { string: 'foo', number: 123, object: { nestedString: 'bar' } }

console.log( schema.safeParse( schemaTestObj ) ) // { success: true, data: { string: 'foo', number: 123, object: { nestedString: 'bar' } } }
console.log( schema.safeParse( undefined ) ) // { success: true, data: { string: 'default', number: 42, object: { nestedString: 'default' } } }

console.log( schemaNoDefaults.safeParse( schemaTestObj ) ) // { success: true, data: { string: 'foo', number: 123, object: { nestedString: 'bar' } } }
console.log( schemaNoDefaults.safeParse( {} ) ) // { success: true, data: {} }

[dermotduffy]

Thank you for the answer & inspiration @JacobWeisenburger ! That works nicely.

[kylesuss]

Sadly, the return type of deepRemoveDefaults is any so it feels like this solution loses all type inference, which is a deal breaker for me. Back to the drawing board 🤔

[flroux]

You can use a separate generic type like this:

type DeepRemoveDefault<I extends ZodTypeAny> =
  I extends ZodDefault<infer T> ? T
  : I extends ZodObject<infer T, infer U, infer C, infer O, infer I> ? ZodObject<{[P in keyof T]: DeepRemoveDefault<T[P]>}, U, C, O ,I>
  : I extends ZodArray<infer T, infer C> ? ZodArray<DeepRemoveDefault<T>, C>
  : I extends ZodOptional<infer T> ? ZodOptional<DeepRemoveDefault<T>>
  : I extends ZodNullable<infer T> ? ZodNullable<DeepRemoveDefault<T>>
  : I;

function deepRemoveDefaults <I extends ZodTypeAny>(schema: I): DeepRemoveDefault<I> {
    if ( schema instanceof z.ZodDefault )
        return deepRemoveDefaults( schema.removeDefault() )

    if ( schema instanceof z.ZodObject ) {
        const newShape: any = {}

        for ( const key in schema.shape ) {
            const fieldSchema = schema.shape[ key ]
            newShape[ key ] = deepRemoveDefaults( fieldSchema )
        }
        return new z.ZodObject( {
            ...schema._def,
            shape: () => newShape,
        } ) as any
    }

    if ( schema instanceof z.ZodArray )
        return z.ZodArray.create( deepRemoveDefaults( schema.element ) ) as DeepRemoveDefault<I>

    if ( schema instanceof z.ZodOptional )
        return z.ZodOptional.create( deepRemoveDefaults( schema.unwrap() ) ) as DeepRemoveDefault<I>

    if ( schema instanceof z.ZodNullable )
        return z.ZodNullable.create( deepRemoveDefaults( schema.unwrap() ) ) as DeepRemoveDefault<I>

    return schema as DeepRemoveDefault<I>
}

[hi94740]

Sadly, the return type of deepRemoveDefaults is any so it feels like this solution loses all type inference, which is a deal breaker for me. Back to the drawing board 🤔

Can't we just use the type inferred from the original schema with defaults? Shouldn't they be the same?

[sosweetham]

is there any zod v4 implementation of this?

[ahrjarrett]

@sosweetham @traversable/zod supports this.

I put together a demo, lmk if you run into any issues.