Support for z.lazy() and recursive schemas

[rattrayalex]

Currently, this code (copied from zod's recursive types docs):

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()),
});

const registry = new OpenAPIRegistry();
registry.register("Category", categorySchema);

const generator = new OpenAPIGenerator(registry.definitions, "3.0.0");

try {
  const document = generator.generateDocument({
    info: {
      version: "1.0.0",
      title: "My API",
    },
    servers: [{ url: "v1" }],
  });
  console.log(document);
} catch (err) {
  console.error(err);
}

Throws this error:

UnknownZodTypeError {
  message: 'Unknown zod object type, please specify `type` and other OpenAPI props using `ZodSchema.openapi`.',
  data: {
    currentSchema: { getter: [Function (anonymous)], typeName: 'ZodLazy' },
    schemaName: undefined
  }
}

Ideally, it would generate an OpenAPI spec like this:

const document = {
  components: {
    schemas: {
      Category: {
        type: "object",
        properties: {
          name: { type: "string" },
          subcategories: {
            type: "array",
            items: { $ref: "#/components/schemas/Category" },
          },
        },
      },
    },
  },
  ...etc,
};

This may require automatic resolution of registered schemas to $refs, which I filed here: #142

[AGalabov]

@rattrayalex thank you for this. Lazy schemas are something that we do not support at all as of today. I'll take a look at it.

[svgils]

Would adding

if (isZodType(schema, 'ZodLazy')) {
  return this.unwrapChained(schema.schema);
}

to unwrapChained() not be sufficient for adding zodLazy support?

[caoxing9]

what's this?

[svgils]

Lazy schemas have a schema property that returns the evaluated zod schema. Since the evaluated schema could be another lazy schema, or any other chained schema, it's result is to be unchained as well.

[jatinsandilya]

Is this supported now? Or is there a workaround you'd suggest in the meantime for recursive schemas?

[gco-lapala]

z.lazy is a kind of workaround that allows for manually defining a schema that cannot be computed due to primarily recursions and circular dependencies.
Can we expect a version of the .openapi() function that allows the same thing, namely to provide the schema to be used as is, rather than just a supplement to the calculated schema?
This way, we could use this function with any Zod element.