JSON Schema to Zod

{
  "$defs": {
    "Role": { "enum": ["admin", "user"] }
  },
  "type": "object",
  "properties": {
    "id": { "type": "integer" },
    "role": { "$ref": "#/$defs/Role" },
    "nick": { "type": ["string", "null"] }
  },
  "required": ["id"]
}

import * as z from "zod";


export const RoleSchema = z.enum([
    "admin",
    "user",
]);
export type Role = z.infer<typeof RoleSchema>;

export const RootSchema = z.object({
    "id": z.number(),
    "nick": z.union([z.null(), z.string()]).optional(),
    "role": RoleSchema.optional(),
});
export type Root = z.infer<typeof RootSchema>;

Four schema features in one pass. The $defs entry becomes its own exported schema and is referenced, not copied; an all-string enum becomes z.enum; type [string, null] becomes a union with z.null in it; and only id is in required, so the other two carry .optional().

{
  "type": "object",
  "properties": {
    "email": { "type": "string", "format": "email", "pattern": "^.+@.+$", "maxLength": 254 },
    "age": { "type": "integer", "minimum": 0, "maximum": 130 },
    "tags": { "type": "array", "items": { "type": "string" }, "uniqueItems": true }
  },
  "required": ["email"]
}

import * as z from "zod";


export const RootSchema = z.object({
    "age": z.number().optional(),
    "email": z.string(),
    "tags": z.array(z.string()).optional(),
});
export type Root = z.infer<typeof RootSchema>;

The honest half of the tool: six assertions went in and none came out, so the result accepts any string as an email, any number as an age. The dropped-keyword list names all six with their pointers, so restoring the checks is a checklist.

{
  "type": "object",
  "required": ["id", "createdAt"],
  "properties": {
    "id": { "type": "string", "format": "uuid" },
    "createdAt": { "type": "string", "format": "date-time" }
  }
}

import * as z from "zod";


export const RootSchema = z.object({
    "createdAt": z.coerce.date(),
    "id": z.string(),
});
export type Root = z.infer<typeof RootSchema>;

Exactly one format is understood, and it changes the value: "date-time" becomes z.coerce.date(), so parsing returns a Date object rather than the string that went in. "uuid" leaves a bare z.string() behind — worth knowing before an id is trusted.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["label"],
  "properties": {
    "label": { "type": "string" },
    "next": { "$ref": "#" }
  }
}

import * as z from "zod";


export type Next = {
    "label": string;
    "next"?: Next;
};
export const NextSchema: z.ZodType<Next> = z.lazy(() =>
    z.object({
        "label": z.string(),
        "next": NextSchema.optional(),
    })
);

export const RootSchema = z.object({
    "label": z.string(),
    "next": NextSchema.optional(),
});
export type Root = z.infer<typeof RootSchema>;

The edge case worth seeing early. A schema that points at itself needs z.lazy plus a hand-written type annotation, because inference cannot close the loop — and the recursive half is named after the property that reached it, Next, not after the root.