Add .deepStrict or .deepStrip to recursively change schema mode

[ramos-ph]

Say we have the following schema:

const schema = z.object({
  name: z.object({
    firstName: z.string(),
    lastName: z.string(),
  }),
  email: z.string(),
});

When we call .strict().parse(), it won't affect the name schema, or deeper schemas on that matter, so .parse won't throw an error:

const user = schema.strict().parse({
  name: {
    firstName: "John",
    lastName: "Doe",
    foo: "Bar", // passing an unknown key
  },
  email: "[email protected]",
});

console.log(user); // expected to throw an error.
/*
{
  name: { firstName: 'John', lastName: 'Doe' },
  email: '[email protected]'
}
*/

Perhaps an .deepStrict method could be added, so Zod can turn every inner schema strict, so we don't have to define it in every single object, or do a function that alters the schema manually.

const user = z.object({
  name: z.object({ ... }).strip(),
  phone: z.object({ ... }),
  address: z.object({ ... }),
}).deepStrict() // just like calling .strict() on every property, except the ones where .strip() is being called explicitly.

Is this something doable or is there an existing workaround for that?

[JacobWeisenburger]

an argument could be made for .deepStrict. I think you have a good use case for this, however, I don't think we would do .deepStrip, because strip is the default behavior.

[ramos-ph]

Makes sense. I suggested it because I'm using in a project where strict mode is a must and we would need that behavior too. But we could change it if deepStrict was implemented

[danny-does-stuff]

I would be interested in seeing deepStrict as well!

[Aschen]

I ran into the same issue. Here is what I did for a recursive strict schema:

function makeStrict<TSchema extends z.ZodType<any, any>>(
  schema: TSchema extends z.ZodObject<any, any> ? TSchema : never
): TSchema {
  if (schema instanceof z.ZodObject) {
    const newShape: { [key: string]: z.ZodType<any, any> } = {}

    Object.entries(schema.shape).forEach(([key, subSchema]: any) => {
      newShape[key] = makeStrict(subSchema)
    })

    // @ts-ignore
    return z.object(newShape).strict()
  }

  return schema
}

const schema = z.object({
  _id: z.string(),
  email: z.string().optional(),
  first_name: z.string(),
  last_name: z.string(),
  date_created: z.string(),
  date_updated: z.string(),
})

const strictSchema = makeStrict<typeof schema>(schema)

[kernwig]

Thanks @Aschen. I tried this, but it doesn't recurse into arrays and their contained objects.

[Aschen]

I adapted the function, this example is working:

import * as z from 'zod'

function makeStrict<TSchema extends z.ZodType<any, any>>(
  schema: TSchema extends z.ZodObject<any, any> ? TSchema : never
): TSchema {
  if (schema instanceof z.ZodObject) {
    const newShape: { [key: string]: z.ZodType<any, any> } = {}

    for (const [key, subSchema] of Object.entries(schema.shape)) {
      if (subSchema instanceof z.ZodArray) {
        const strictItemSchema = makeStrict(subSchema.element)
        newShape[key] = z.array(strictItemSchema)
      } else if (subSchema instanceof z.ZodObject) {
        newShape[key] = makeStrict(subSchema)
      } else {
        newShape[key] = subSchema as any
      }
    }

    return z.object(newShape).strict() as unknown as TSchema
  }

  return schema
}

const schema = z.object({
  _id: z.string(),
  email: z.string().optional(),
  cities: z.array(
    z.object({
      name: z.string(),
      country: z.string(),
    })
  ),
})

const strictSchema = makeStrict<typeof schema>(schema)

// Raise an error because the property "foobar" is not defined in the schema
strictSchema.parse({
  _id: '123',
  cities: [{ name: 'Paris', country: 'France', foobar: true }],
})

[jaens]

Here's a more general and correct utility that also handles optionals, nullables, and tuples.

It's based on the fact that ZodType is a functor and trivially supports a map-like function which can be used to apply any type transformation.

mapOnSchema can be used to implement deepPartial, deepStrict, or really, any transformation that acts "locally" on types in a schema.

[ChrisLincoln]

I have objects with junk I don't want to type, but also need to preserve, and need a deepPassthrough()