Can zod make recursive schema?

[ricoarisandyw]

I want to create nested menu. so I wonder wether Zod schema has it or not.

here is my current code :

type InfinityText = {
    text: string
    children: InfinityText[]
}

function NestedMenu(props: { menu: InifinityText }) {}

<NestedMenu menu={[{text:"parent", children: [ { text: "children" } ] } ] } />

I try to do this but got error, because of declaration.

const infinityTextSchema = z.object({ text: z.string(), children: z.array(infinityTextSchema) });

Please help me to create those schema. big thanks. 👍

[JacobWeisenburger]

https://github.com/colinhacks/zod#recursive-types

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

[hinogi]

Is there a way to limit the allowed recursion depth?

[ShawnCone]

Hello, relating to this, is there a way to use preprocess with this recursive schema pattern?
With that pattern in https://github.com/colinhacks/zod#recursive-types

This works:

const baseCategorySchema = z.object({
    name: z.string(),
})

type Category = z.infer<typeof baseCategorySchema> & {
    subcategories: Category[]
}

const categorySchema: z.ZodType<Category> = baseCategorySchema.extend({
    subcategories: z.lazy(() => categorySchema.array()),
})

But if I changename: z.string() to name: z.preprocess((val) => z.string().parse(val), z.string())
this error arise for categorySchema:

Types of property 'someId' are incompatible.
          Type 'unknown' is not assignable to type 'string`

Any clue why this is happening and how to solve it?

[ThomasFindlay]

This is a very good question. I'm running into exactly the same issue.

[chpio]

Similar problem with the transform function. Giving the error "Types of property '_input' are incompatible." I think it's caused by ZodType assuming the types to be Input = Output.

Edit: Defining the Input type helped in my case, maybe it will help you too https://github.com/colinhacks/zod#zodtype-with-zodeffects

[manavi-litmusblox]

inferring from recursive schema gives any type. this is issue with z.lazy() method

[jeremyjacob]

Here's a more robust solution that merges both the input and output types if you're doing transforms in your schemas:

export type ZodCompositeType<
	T extends ZodTypeAny,
	U extends { [K in keyof U]: ZodType<any, ZodTypeDef, any> },
> = ZodType<
	z.output<T> & { [K in keyof U]: z.output<U[K]> },
	ZodTypeDef,
	z.input<T> & { [K in keyof U]: z.input<U[K]> }
>;

You'd use ZodCompositeType like:

const customerField = Customer.or(string().transform(Number)); // type transform would cause errors with `z.infer<...> & { ... }` as that only merges the output.
export const PaymentMethod: ZodCompositeType<
	typeof basePaymentMethod,
	{ customer: typeof customerField }
> = basePaymentMethod.extend({
	customer: z.lazy(() => customerField),
});