Retrieve default values from schema

[oscartbeaumont]

I am trying to build a form abstraction around Zod. Currently it works as follows:

const  = useForm({
  schema: z.object({
    name: z.string(),
    demo: z.number(),
  }),
  // This object is of type `Partial<z.infer<S>>` where `S` is the schema above.
  defaultValues: {
    name: "todo"
  }
});

Now I would like to remove the defaultValues argument and use Zod's built-in defaults for better DX. Like the following:

const  = useForm({
  schema: z.object({
    name: z.string().default("todo"),
    demo: z.number(),
  }),
});

The way useForm works internally is that it needs the default values so it can set them to the HTML input elements. I was hoping Zod would give me all of the default values similar to the manually written defaultValues argument I was previously using.

I saw in issue #201 it was recommended to use schema.parse({}). This does not work for my use case because I don't want to be required to set a default value on every field.

In issue #213 there was another workaround but it would greatly comprise DX so it doesn't work for me either.

I think this could be fixed by either:

• Providing a method to get the default values from the schema. schema.getDefaults()
• Providing a way to parse a schema which instead of failing on errors would return a partial object of all fields it could successfully parse. This would make schema.parse({}) work and it would just not include all fields without a default set.

Thanks for any help that can be provided and I have been loving using Zod in my projects!

[JacobWeisenburger]

Is this what you are looking for?

function getDefaults<Schema extends z.AnyZodObject>(schema: Schema) {
    return Object.fromEntries(
        Object.entries(schema.shape).map(([key, value]) => {
            if (value instanceof z.ZodDefault) return [key, value._def.defaultValue()]
            return [key, undefined]
        })
    )
}

const schema = z.object({
    name: z.string().default('todo'),
    demo: z.number(),
})

console.log(getDefaults(schema))
// { name: 'todo', demo: undefined }

[ArekBartnik]

What if schema is an union?

const baseObject = z.object({
  // whatever
});

const mySchema = baseObject
  .extend({ first: z.string().default("first ok") })
  .or(baseObject.extend({ second: z.string().default("second ok") }))

[LMinato]

Did you find any solution for this ?
I'm very interested to get the schema from the discriminator and then parse to get the default values.

[naviens]

This feature will be quite useful, for providing initial value to the form,
similar feature in Yup is yupSchema.getDefault()

[oscartbeaumont]

@JacobWeisenburger that worked perfectly! Thanks for your help!

I do agree with @naviens it would be nice to have this as a helper in Zod itself but if that's not something that would be considered this issue can be closed.

[naviens]

@JacobWeisenburger
Above suggested solution got failed if we have .refine syntax as part of the schema validation. Example schema, where getDefaults function fails,

const changePasswordSchema = zod.object({
    old_password: zod.string(),
    new_password1: zod.string()
    new_password2: zod.string()
    }).refine((data) => data.new_password1 === data.new_password2, {
        message: "Password doesn't mactch",
        path: ["new_password2"]
})

Error Trace

validators.ts:14 Uncaught (in promise) TypeError: Cannot convert undefined or null to object
    at Function.entries (<anonymous>)
    at getSchemaDefaults (validators.ts:14:16)

[JacobWeisenburger]

Is this what you are looking for?

function getDefaults<Schema extends z.AnyZodObject> ( schema: Schema ) {
    return Object.fromEntries(
        Object.entries( schema.shape ).map( ( [ key, value ] ) => {
            if ( value instanceof z.ZodDefault ) return [ key, value._def.defaultValue() ]
            return [ key, undefined ]
        } )
    )
}

const changePasswordSchema = z.object( {
    old_password: z.string(),
    new_password1: z.string(),
    new_password2: z.string(),
} ).refine( ( data ) => data.new_password1 === data.new_password2, {
    message: "Password doesn't mactch",
    path: [ "new_password2" ]
} )

console.log( getDefaults( changePasswordSchema._def.schema ) )
// { old_password: undefined, new_password1: undefined, new_password2: undefined }

[lukasvice]

Unfortunately this solution does not work with pipe either.

z.string().transform((value) => (value === '' ? null : value))
  .pipe(z.coerce.number().nullable().default(null))

The type is number | null but the default value is returned as undefined.

It would be really nice to have a fully functional solution built into in Zod.

[aheissenberger]

I would also prefer a native support in zod to access the structure - my current "hack" uses Zod to Json Schema to export the schema to a JSON structure and then parse this to an object which only contains the props with the default values.

This code is not been tested in production and might break in many cases!

import { zodToJsonSchema } from "zod-to-json-schema";
import { ZodSchema } from 'zod';

type PropertySchema = {
    default?: any;
    type: 'object' | 'array' | 'string' | 'number';
    properties?: Record<string, PropertySchema>;
    items?: PropertySchema;
};

function getProperties(defaults: Record<string, any>, properties?: Record<string, PropertySchema>) {
    if (!properties) {
        return;
    }
    Object.keys(properties).forEach((prop) => {
        if (properties[prop].hasOwnProperty('default')) {
            defaults[prop] = properties[prop].default;
        } else if (properties[prop].type === 'object') {
            defaults[prop] = {};
            getProperties(defaults[prop], properties[prop].properties);
        } else if (properties[prop].type === 'array') {
            defaults[prop] = [];
            if (properties[prop].items && properties?.[prop]?.items?.type === 'object') {
                defaults[prop].push({});
                getProperties(defaults[prop][0], properties?.[prop]?.items?.properties);
            }
        } else if (properties[prop].type === 'string') {
            defaults[prop] = '';
        } else if (properties[prop].type === 'number') {
            defaults[prop] = 0;
        }
    });
}

export function jsonSchemaExtractDefaults(schema: { definitions: Record<string, { properties: Record<string, PropertySchema> }>, $ref: string }) {
    const { properties } = schema.definitions[schema.$ref.split('/').pop() as string];
    const result: Record<string, any> = {};
    getProperties(result, properties);

    return result;
}

export function zodExtractDefaults<T extends ZodSchema<any>>(schema: T) {
    const jsonSchema = zodToJsonSchema(schema, 'tempSchema');
    // @ts-ignore
    return jsonSchemaExtractDefaults(jsonSchema);
}

zod schema

const idType = "Place"
const idRegex = new RegExp(idType + `#[A-Za-z0-9_-]{21}`)
const PlaceId = z.string().regex(idRegex).default('')
const TemplateProps = z
    .object({
        placeId: PlaceId,
        paxMax: z.number().min(0).default(30),
        groupMax: z.number().min(0).default(2),
        groupPaxMax: z.number().min(0).default(30)
    })
    .refine((schema) => schema.groupMax <= schema.groupPaxMax, {
        message: "groupMax>groupMax to big!",
        path: ["groupMax"]
    })
    .refine((schema) => schema.groupPaxMax <= schema.paxMax, {
        message: "groupPaxMax>PaxMax",
        path: ["groupPaxMax"]
    });
const mschema = z.object({
    name: z.string().min(1).max(50).default(""),
    props: TemplateProps
});

JSON Schema with Zod to Json Schema

{
    "$ref": "#/definitions/mySchema",
    "definitions": {
        "mySchema": {
            "type": "object",
            "properties": {
                "name": {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 50,
                    "default": ""
                },
                "props": {
                    "type": "object",
                    "properties": {
                        "placeId": {
                            "type": "string",
                            "pattern": "Place#[A-Za-z0-9_-]{21}",
                            "default": ""
                        },
                        "paxMax": {
                            "type": "number",
                            "minimum": 0,
                            "default": 30
                        },
                        "groupMax": {
                            "type": "number",
                            "minimum": 0,
                            "default": 2
                        },
                        "groupPaxMax": {
                            "type": "number",
                            "minimum": 0,
                            "default": 30
                        }
                    },
                    "required": [
                        "placeId"
                    ],
                    "additionalProperties": false
                }
            },
            "required": [
                "name",
                "props"
            ],
            "additionalProperties": false
        }
    },
    "$schema": "http://json-schema.org/draft-07/schema#"
}

defaults only

{
    "name": "",
    "props": {
        "placeId": "",
        "paxMax": 30,
        "groupMax": 2,
        "groupPaxMax": 30
    }
}

[andromidasj]

This was my crack at it. It works recursively, grabbing the default of any zod schema type if there is one, and undefined if there isn't. The recursion is helpful when chaining z.optional() and other wrapper types. It doesn't work with the above pipe() example, but should be doable with some tweaking:

export function getDefaults<TSchema extends z.AnyZodObject>(schema: TSchema) {
  function getDefaultValue(schema: z.ZodTypeAny): unknown {
    if (schema instanceof z.ZodDefault) return schema._def.defaultValue();
    if (!("innerType" in schema._def)) return undefined;
    return getDefaultValue(schema._def.innerType);
  }

  return Object.fromEntries(
    Object.entries(schema.shape).map(([key, value]) => {
      return [key, getDefaultValue(value)];
    })
  );
}

It's not perfect though. I get the typescript warning: Argument of type 'unknown' is not assignable to parameter of type 'ZodTypeAny'. ts(2345) where I invoke getDefaultValue, and a couple ESLint no-unsafe-argument errors. I'm happily open to feedback and tips that might help make this function typesafe without errors.

Result

const defaults = getDefaults(
  z.object({
    name: z.string().default("todo"),
    demo: z.number(),
  })
);
console.log(defaults);

{
    name: "todo",
    demo: undefined
}

And a more complex example

const defaults = getDefaults(
  z.object({
    cache: z.boolean().default(true),
    cache_expiration: z.number().default(60),
    run_again_delay: z.number().min(1).default(1),
    email: z.string().email().default("asdf@example.com"),
    playlist_report: z.boolean().optional().default(false),
    custom_repo: z.string().optional().default(""),
    verify_ssl: z.boolean().optional().default(true),
    check_nightly: z.boolean().nullable().default(false),
  })
);
console.log(defaults);

{
  cache: true,
  cache_expiration: 60,
  run_again_delay: 1,
  email: "asdf@example.com",
  playlist_report: false,
  custom_repo: "",
  verify_ssl: true,
  check_nightly: false,
}

I'll also echo what others have stated, saying that Zod should provide this functionality natively.

[metko]

Hi, this works for me for with refine, pipe and recursivly obj:

const validatorSchema  = z.object({
    firstname: z.string().min(2, "error on firstname"),
    lastname: z.string().transform((val) => val.length).pipe(z.number().min(5)),
    age: z.number(),
    address: z.object({
        address1: z.string().nonempty(),
        address2: z.string().nonempty(),
        country: z.string().nonempty(),
        insideobj: z.object({
            id: z.string(),
            insideobj: z.object({
                id: z.string()
            }),
        }),
        code: z.array(z.object({
            id: z.string(),
            somevalue: z.number().nonpositive(),
            insideobj: z.object({
                id: z.string()
            })
        }))
    })
})
.refine(({firstname, age}) => firstname ? age > 18 : true, {"message": "Age must be sup to 18"} )
.refine(schema => true)


function getDefaults<T extends z.ZodTypeAny>( schema: z.AnyZodObject | z.ZodEffects<any> ): z.infer<T> {
    
    // Check if it's a ZodEffect
    if (schema instanceof z.ZodEffects) {
        // Check if it's a recursive ZodEffect
        if (schema.innerType() instanceof z.ZodEffects) return getDefaults(schema.innerType())
        // return schema inner shape as a fresh zodObject
        return getDefaults(z.ZodObject.create(schema.innerType().shape))
    }

    function getDefaultValue(schema: z.ZodTypeAny): unknown {
        if (schema instanceof z.ZodDefault) return schema._def.defaultValue();
        // return an empty array if it is
        if (schema instanceof z.ZodArray) return [];
        // return an empty string if it is
        if (schema instanceof z.ZodString) return "";
        // return an content of object recursivly
        if (schema instanceof z.ZodObject) return getDefaults(schema);

        if (!("innerType" in schema._def)) return undefined;
        return getDefaultValue(schema._def.innerType);
  }
    
    return Object.fromEntries(
        Object.entries( schema.shape ).map( ( [ key, value ] ) => {
            return [key, getDefaultValue(value)];
        } )
    )
}

const defaultValue = getDefaults<typeof validatorSchema>(validatorSchema)

output:

{
   "address1": "",
   "address2": "",
   "country": "",
   "insideobj": {
       "id": "",
       "insideobj": {
           "id": ""
       }
   },
   "code": []
}

[lucas-santosP]

This is the only one working for me so far. But using refine or superRefine in an object that is inside another object makes the value to be undefined.

Ex: Following your example but adding refine into the address object schema.

const validatorSchema = z.object({
  firstname: z.string().min(2, "error on firstname"),
  lastname: z
    .string()
    .transform((val) => val.length)
    .pipe(z.number().min(5)),
  age: z.number(),
  address: z
    .object({
      address1: z.string().nonempty(),
      address2: z.string().nonempty(),
      country: z.string().nonempty(),
      insideobj: z.object({
        id: z.string(),
        insideobj: z.object({ id: z.string() }),
      }),
      code: z.array(
        z.object({
          id: z.string(),
          somevalue: z.number().nonpositive(),
          insideobj: z.object({
            id: z.string(),
          }),
        })
      ),
    })
    .refine(({ address1 }) => address1 === "something", { message: "Error msg" }) // this
    .refine((schema) => true),
});

Output:

{
  address: undefined;
  age: undefined;
  firstname: "";
  lastname: undefined;
}

Edit:
I manage to fix checking in getDefaultValue if the schema is a ZodEffects if so then call getDefaults recursively.

if (schema instanceof z.ZodObject || schema instanceof z.ZodEffects) return getDefaults(schema);

[TonyGravagno]

@lucas-santosP it looks like @metko revised his response to account for ZodEffects:

    // Check if it's a ZodEffect
    if (schema instanceof z.ZodEffects) {
        // Check if it's a recursive ZodEffect
        if (schema.innerType() instanceof z.ZodEffects) return getDefaults(schema.innerType())
        // return schema inner shape as a fresh zodObject
        return getDefaults(z.ZodObject.create(schema.innerType().shape))
    }

Can you verifiy that the revised code has the same net effect as your one line edit?

+1 on getting this or equivalent added into Zod core. I came here looking for a solution to this exact challenge.

[TonyGravagno]

@metko : How does your execution avoid this problem?

My naive attempt to defeat the warning:

Object.entries( schema.shape as z.ZodRawShape ).map( ... )

[lucas-santosP]

@lucas-santosP it looks like @metko revised his response to account for ZodEffects:

    // Check if it's a ZodEffect
    if (schema instanceof z.ZodEffects) {
        // Check if it's a recursive ZodEffect
        if (schema.innerType() instanceof z.ZodEffects) return getDefaults(schema.innerType())
        // return schema inner shape as a fresh zodObject
        return getDefaults(z.ZodObject.create(schema.innerType().shape))
    }

Can you verifiy that the revised code has the same net effect as your one line edit?

+1 on getting this or equivalent added into Zod core. I came here looking for a solution to this exact challenge.

Yes, when I replied I tested already with that revised code included, and did not work for me.

[wjbright]

Does anyone have a typesafe version of this solution that returns only the object with the defaults and their types?

[TonyGravagno]

Building on the recursive model provided by others here, I'm providing an update that accommodates all issues and schema to-date.

This is all just a work-in-progress. There are still anomalies that should be resolved - see below. But so far I'm able to use this for my purposes and I think it's pretty good.
I'm hoping we can continue to build on this. Thanks for the base and the opportunity ... I've learned a lot about Zod here and a good deal about TypeScript as well.

Features / Solved Issues

• No issues with null, undefined, or other types.
• Through deep recursion
• Handles pipe, transform, refine
• Uses .default() values if present.
• Defaults to min value on numerics.
• Optional parameter specifies whether arrays default to empty array, or to array with a single default element of the schema
• Function name changed to 'defaultInstance'
• Nested function names modified for changes in recursion
• Added comments
• Tested and accurate with all examples so far in this thread.
• Uses .default() values if present.

Anomalies

• Currently the default for an array is a single element of the defined type. That's not a great default. Solution: Omit arrays and run them back for separate instances that can populate the arrays like a template. Should this be coded (with an option) in to return an object, with one element the default for the schema with empty arrays, and other elements for arrays?
• Fields defined as non-empty default to empty string.
• No handling for pre-transforms, but there is for post-transforms. But a post-transform processes runtime data - what would the default for this be other than a transform on a default of null/empty/0?
• No handling for .brand()
• No handling for .set with .min()
• Similar lack of support for other values that are defined and modified by the methods in a way that makes getting a default a matter of guesswork.
• Does not support Unions : Which field schema would be used for the default??

Bottom line : It's REALLY REALLY REALLY important, if you want a default object from your schema, to set a .default() for all primitives and constructs. This code will process that. If you don't provide a default in the schema, it might be a long time before a feature like this can be built into Zod as a reliable component.

Function defaultInstance

import { z } from 'zod'

/**
 * defaultInstance
 * @param schema z.object schema definition
 * @param options Optional object, may include property:
 *                - defaultArrayEmpty: true
 * @returns Object of type schema with defaults for all fields
 * @example
 * const schema = z.object( { ... } )
 * const default1 = defaultInstance<typeof schema>(schema)
 * const default2 = defaultInstance<typeof schema>(
 *                  schema,{ defaultArrayEmpty: true} )
 */
export function defaultInstance<T extends z.ZodTypeAny>(
  schema: z.AnyZodObject | z.ZodEffects<any>,
  options: object = {}
): z.infer<T> {
  const defaultArrayEmpty = 'defaultArrayEmpty' in options ? options.defaultArrayEmpty : false
  function run(): z.infer<T> {
    if (schema instanceof z.ZodEffects) {
      if (schema.innerType() instanceof z.ZodEffects) {
        return defaultInstance(schema.innerType(), options) // recursive ZodEffect
      }
      // return schema inner shape as a fresh zodObject
      return defaultInstance(z.ZodObject.create(schema.innerType().shape), options)
    }

    if (schema instanceof z.ZodType) {
      let the_shape = schema.shape as z.ZodAny // eliminates 'undefined' issue
      let entries = Object.entries(the_shape)
      let temp = entries.map(([key, value]) => {
        let this_default =
          value instanceof z.ZodEffects ? defaultInstance(value, options) : getDefaultValue(value)
        return [key, this_default]
      })
      return Object.fromEntries(temp)
    } else {
      console.log(`Error: Unable to process this schema`)
      return null // unknown or undefined here results in complications
    }

    function getDefaultValue(dschema: z.ZodTypeAny): any {
      if (dschema instanceof z.ZodDefault) {
        if (!('_def' in dschema)) return undefined // error
        if (!('defaultValue' in dschema._def)) return undefined // error
        return dschema._def.defaultValue()
      }
      if (dschema instanceof z.ZodArray) {
        if (!('_def' in dschema)) return undefined // error
        if (!('type' in dschema._def)) return undefined // error
        // return empty array or array with one empty typed element
        return defaultArrayEmpty ? [] : [getDefaultValue(dschema._def.type as z.ZodAny)]
      }
      if (dschema instanceof z.ZodString) return ''
      if (dschema instanceof z.ZodNumber) {
        let value = dschema.minValue ?? 0
        return value
      }
      if (dschema instanceof z.ZodPipeline) {
        if (!('out' in dschema._def)) return undefined // error
        return getDefaultValue(dschema._def.out)
      }
      if (dschema instanceof z.ZodObject) {
        return defaultInstance(dschema, options)
      }
      if (dschema instanceof z.ZodAny && !('innerType' in dschema._def)) return undefined // error?
      return getDefaultValue(dschema._def.innerType)
    }
  }
  return run()
}

EDIT: Neglected to include TestSchema230512

export const TestSchema230512 = z
  .object({
    firstname: z.string().min(2, 'error on firstname'),
    lastname_with_pipe: z
      .string()
      .default('smith')
      .transform(val => val.length)
      .pipe(z.number().min(5)),
    age: z.number(),
    location_with_refine: z
      .object({
        address: z.object({
          street1: z.string(),
          street2: z.string(),
        }),
        country: z.object({
          id: z.object({
            alpha2: z.string().length(2),
            alpha3: z.string().length(3),
          }),
          name: z.string().nonempty().default('Not Specified'),
        }),
      })
      .refine(
        the_location => the_location.address.street2 !== '' && the_location.address.street1 === '',
        'Please move street2 to street1'
      ),
    pets_no_defaults: z.array(
      z.object({
        name: z.string(),
        age: z.number().nonnegative().lte(250)  // handle turtles,
      })
    ),
    children_with_defaults: z
      .array(
        z
          .object({
            name: z.string(),
            age: z.number().nonnegative().lte(120),
          })
          .default({ name: 'no name', age: 0 })
      )
      .default([{ name: 'no children', age: -1 }]),
  })
  .refine(
    me => me.age < 12,
    "You aren't really less than 12 years of age are ya?"
  )

EDIT: Default object from TestSchema230512

let default1 = defaultInstance<typeof TestSchema230512>(TestSchema230512
     , {defaultArrayEmpty: true} )

{
  "schema": "TestSchema230512",
  "default": {
    "firstname": "",
    "lastname_with_pipe": 5,
    "age": 0,
    "location_with_refine": {
      "address": {
        "street1": "",
        "street2": ""
      },
      "country": {
        "id": {
          "alpha2": "",
          "alpha3": ""
        },
        "name": "Not Specified"
      }
    },
    "pets_no_defaults": [], << No default element with option defaultArrayEmpty: true
    "children_with_defaults": [
      {
        "name": "no children",
        "age": -1
      }
    ]
  }
}

---

EDIT: 23/05/15 : Added support for ZodDate with new options

Further updates will be posted in this gist:
https://gist.github.com/TonyGravagno/2b744ceb99e415c4b53e8b35b309c29c

[sweetpalma]

Can't believe you have you have to write own boilerplate method for such basic operation.
Any libraries available?

[AleksandrHovhannisyan]

Noting this in case others have my use case: If all of your schema keys have default values, then you can just do schema.parse({}) to read the defaults. You can export this alongside your schema, like

export const SCHEMA_DEFAULTS = schema.parse({});

[narasimhajupally]

@AleksandrHovhannisyan but it requires us to put valid default values, we cannot prefill the whole form with valid default values.

[Ced-Sharp]

I had started to write an npm package that tries to be an answer to this problem in its own way. I stumbled upon this thread after creating the npm package, so I'm sorry if some things seem repetitive.

While I understand the different points that have been mentioned in this thread, it seems there are still some valid use cases (ex: generating forms with zod) where it is desirable to have "default" or "empty" values matching a Zod schema. My personal use case did not require anything too strict: I needed an object with values that are not necessarily "valid" according to the schema, but are "correct" in the sense of an empty form.

If the schema is .string().min(3), I want an empty string. No need for it to be 3 characters long.
But I want it to respect the .default() when defined.

For this specific use-case, I started an npm package where I welcome PRs:
https://github.com/Ced-Sharp/zod-defaults

If this was the wrong place to post this I apologize, please guide me as to where this belongs.

[Ced-Sharp]

I initially wrote this library using instanceof but since the version of zod that the package imports and the version of zod that the user might be using may differ, instanceof would fail due to being different objects.

For that reason, all tests against zod-related classes are done using constructor.name. Its not pretty and I would rather something cleaner, but "it works" TM.

[vadimyen]

Any news on this?