Extracting default values

[mendrik]

Is there a way to extract an object from a schema that recursively collects all default values without using deepPartial or the need to provide a dummy object for non-optional properties?

I use zod with react-hook-form and looking for a way to set default values inside the schema.

Great work, btw.

[scotttrinh]

Lemme make sure I understand what you're asking here: you want a static way to extract a (potentially recursive) object that represents any "default" values in a given ZodObject (and potentially any nested ZodObjects)?

It's probably doable since the default value is stored in the ZodDefault

zod/src/types.ts

Line 3183 in 72fa277

data = this._def.defaultValue();

[mendrik]

I have something like this

ZNodeSettingsBase.merge(
  object({
    nodeType: literal(NodeType.Number),
    integer: boolean().default(true),
    validation: object({
      min: number().optional(),
      max: number().optional()
    }),
    display: object({
      prefix: string().optional(),
      suffix: string().optional()
    })
  })
)

and what I would like to get back from this is something like this:

{
    ...
    nodeType: "Number",
    integer: true,
    validation: {},
    display: {}
  }

worst case scenario I can write that myself, just need to know how I can traverse the schema tree, if that makes any sense :)

[mendrik]

Ok I got it semi-hacky but seems to do the job:

import { AnyZodObject, ZodDefault, ZodTypeAny } from 'zod'
import { TypeOf } from 'zod/lib/types'

const objectHandler = (zodRef: AnyZodObject): Record<string, ZodTypeAny> =>
  Object.keys(zodRef.shape).reduce((carry, key) => {
    const res = generateDefaults<ZodTypeAny>(zodRef.shape[key])
    return {
      ...carry,
      ...(res ? { [key]: res } : {})
    }
  }, {} as Record<string, ZodTypeAny>)

export const generateDefaults = <T extends ZodTypeAny>(zodRef: T): TypeOf<typeof zodRef> => {
  const typeName = zodRef._def.typeName
  if (/ZodObject|ZodRecord/.test(typeName)) {
    return objectHandler(zodRef as any)
  } else if (/ZodDefault/.test(typeName)) {
    return (zodRef as any as ZodDefault<T>)._def.defaultValue()
  }
  return undefined
}

[scotttrinh]

Two thoughts/suggestions:

1. I think you can use instanceof to clean up the regexp checks a bit, and give the compiler better type narrowing to avoid needing to cast.
2. Records can't meaningfully have a default value since they don't really have a meaningful set of keys in all instances. In fact, unless the key type is a finite enum, it would need to return an infinitely large object with every possible string as a key 😅. I think records with defaults do work to supply a kind of sparse record with default values, but that seems like a pretty strange edge case.

CodeSandbox

const objectHandler = (zodRef: z.AnyZodObject): Record<string, z.ZodTypeAny> =>
  Object.keys(zodRef.shape).reduce((carry, key) => {
    const res = generateDefaults<z.ZodTypeAny>(zodRef.shape[key]);
    return {
      ...carry,
      ...(res ? { [key]: res } : {})
    };
  }, {} as Record<string, z.ZodTypeAny>);

export const generateDefaults = <T extends z.ZodTypeAny>(
  zodRef: T
): z.infer<typeof zodRef> => {
  if (zodRef instanceof z.ZodObject) {
    return objectHandler(zodRef);
  } else if (zodRef instanceof z.ZodDefault) {
    return zodRef._def.defaultValue();
  }
  return undefined;
};