@gabrielbryk/json-schema-to-zod 2.7.2

package/dist/esm/cli.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { parseArgs, parseOrReadJSON, readPipe } from "./utils/cliTools.js";
+const params = {
+    input: {
+        shorthand: "i",
+        value: "string",
+        required: process.stdin.isTTY &&
+            "input is required when no JSON or file path is piped",
+        description: "JSON or a source file path. Required if no data is piped.",
+    },
+    output: {
+        shorthand: "o",
+        value: "string",
+        description: "A file path to write to. If not supplied stdout will be used.",
+    },
+    name: {
+        shorthand: "n",
+        value: "string",
+        description: "The name of the schema in the output.",
+    },
+    depth: {
+        shorthand: "d",
+        value: "number",
+        description: "Maximum depth of recursion before falling back to z.any(). Defaults to 0.",
+    },
+    module: {
+        shorthand: "m",
+        value: ["esm", "cjs", "none"],
+        description: "Module syntax; 'esm', 'cjs' or 'none'. Defaults to 'esm'.",
+    },
+    type: {
+        shorthand: "t",
+        value: "string",
+        description: "The name of the (optional) inferred type export."
+    },
+    noImport: {
+        shorthand: "ni",
+        description: "Removes the `import { z } from 'zod';` or equivalent from the output."
+    },
+    withJsdocs: {
+        shorthand: "wj",
+        description: "Generate jsdocs off of the description property.",
+    },
+};
+async function main() {
+    const args = parseArgs(params, process.argv, true);
+    const input = args.input || (await readPipe());
+    const jsonSchema = parseOrReadJSON(input);
+    const zodSchema = jsonSchemaToZod(jsonSchema, {
+        name: args.name,
+        depth: args.depth,
+        module: args.module || "esm",
+        noImport: args.noImport,
+        type: args.type,
+        withJsdocs: args.withJsdocs,
+    });
+    if (args.output) {
+        mkdirSync(dirname(args.output), { recursive: true });
+        writeFileSync(args.output, zodSchema);
+    }
+    else {
+        console.log(zodSchema);
+    }
+}
+void main();

package/dist/esm/index.js

@@ -0,0 +1,28 @@
+export * from "./Types.js";
+export * from "./jsonSchemaToZod.js";
+export * from "./parsers/parseAllOf.js";
+export * from "./parsers/parseAnyOf.js";
+export * from "./parsers/parseArray.js";
+export * from "./parsers/parseBoolean.js";
+export * from "./parsers/parseConst.js";
+export * from "./parsers/parseDefault.js";
+export * from "./parsers/parseEnum.js";
+export * from "./parsers/parseIfThenElse.js";
+export * from "./parsers/parseMultipleType.js";
+export * from "./parsers/parseNot.js";
+export * from "./parsers/parseNull.js";
+export * from "./parsers/parseNullable.js";
+export * from "./parsers/parseNumber.js";
+export * from "./parsers/parseObject.js";
+export * from "./parsers/parseOneOf.js";
+export * from "./parsers/parseSchema.js";
+export * from "./parsers/parseSimpleDiscriminatedOneOf.js";
+export * from "./parsers/parseString.js";
+export * from "./utils/anyOrUnknown.js";
+export * from "./utils/half.js";
+export * from "./utils/jsdocs.js";
+export * from "./utils/omit.js";
+export * from "./utils/withMessage.js";
+export * from "./zodToJsonSchema.js";
+import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
+export default jsonSchemaToZod;

package/dist/esm/jsonSchemaToZod.js

@@ -0,0 +1,74 @@
+import { parseSchema } from "./parsers/parseSchema.js";
+import { expandJsdocs } from "./utils/jsdocs.js";
+export const jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest } = {}) => {
+    if (type && (!name || module !== "esm")) {
+        throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
+    }
+    const declarations = new Map();
+    const refNameByPointer = new Map();
+    const usedNames = new Set();
+    const exportRefs = rest.exportRefs ?? true;
+    const withMeta = rest.withMeta ?? true;
+    if (name)
+        usedNames.add(name);
+    const parsedSchema = parseSchema(schema, {
+        module,
+        name,
+        path: [],
+        seen: new Map(),
+        declarations,
+        inProgress: new Set(),
+        refNameByPointer,
+        usedNames,
+        root: schema,
+        currentSchemaName: name,
+        ...rest,
+        withMeta,
+    });
+    const declarationBlock = declarations.size
+        ? Array.from(declarations.entries())
+            .map(([refName, value]) => {
+            const shouldExport = exportRefs && module === "esm";
+            const decl = `${shouldExport ? "export " : ""}const ${refName} = ${value}`;
+            return decl;
+        })
+            .join("\n")
+        : "";
+    const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description
+        ? expandJsdocs(schema.description)
+        : "";
+    const lines = [];
+    if (module === "cjs" && !noImport) {
+        lines.push(`const { z } = require("zod")`);
+    }
+    if (module === "esm" && !noImport) {
+        lines.push(`import { z } from "zod"`);
+    }
+    if (declarationBlock) {
+        lines.push(declarationBlock);
+    }
+    if (module === "cjs") {
+        const payload = name ? `{ ${JSON.stringify(name)}: ${parsedSchema} }` : parsedSchema;
+        lines.push(`${jsdocs}module.exports = ${payload}`);
+    }
+    else if (module === "esm") {
+        lines.push(`${jsdocs}export ${name ? `const ${name} =` : `default`} ${parsedSchema}`);
+    }
+    else if (name) {
+        lines.push(`${jsdocs}const ${name} = ${parsedSchema}`);
+    }
+    else {
+        lines.push(`${jsdocs}${parsedSchema}`);
+    }
+    let typeLine;
+    if (type && name) {
+        let typeName = typeof type === "string"
+            ? type
+            : `${name[0].toUpperCase()}${name.substring(1)}`;
+        typeLine = `export type ${typeName} = z.infer<typeof ${name}>`;
+    }
+    const joined = lines.filter(Boolean).join("\n\n");
+    const combined = typeLine ? `${joined}\n${typeLine}` : joined;
+    const shouldEndWithNewline = module === "esm" || module === "cjs";
+    return `${combined}${shouldEndWithNewline ? "\n" : ""}`;
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/parsers/parseAllOf.js

@@ -0,0 +1,37 @@
+import { parseSchema } from "./parseSchema.js";
+import { half } from "../utils/half.js";
+const originalIndex = Symbol("Original index");
+const ensureOriginalIndex = (arr) => {
+    let newArr = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item === "boolean") {
+            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+        }
+        else if (originalIndex in item) {
+            return arr;
+        }
+        else {
+            newArr.push({ ...item, [originalIndex]: i });
+        }
+    }
+    return newArr;
+};
+export function parseAllOf(schema, refs) {
+    if (schema.allOf.length === 0) {
+        return "z.never()";
+    }
+    else if (schema.allOf.length === 1) {
+        const item = schema.allOf[0];
+        return parseSchema(item, {
+            ...refs,
+            path: [...refs.path, "allOf", item[originalIndex]],
+        });
+    }
+    else {
+        const [left, right] = half(ensureOriginalIndex(schema.allOf));
+        return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
+            allOf: right,
+        }, refs)})`;
+    }
+}

package/dist/esm/parsers/parseAnyOf.js

@@ -0,0 +1,14 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseAnyOf = (schema, refs) => {
+    return schema.anyOf.length
+        ? schema.anyOf.length === 1
+            ? parseSchema(schema.anyOf[0], {
+                ...refs,
+                path: [...refs.path, "anyOf", 0],
+            })
+            : `z.union([${schema.anyOf
+                .map((schema, i) => parseSchema(schema, { ...refs, path: [...refs.path, "anyOf", i] }))
+                .join(", ")}])`
+        : anyOrUnknown(refs);
+};

package/dist/esm/parsers/parseArray.js

@@ -0,0 +1,67 @@
+import { withMessage } from "../utils/withMessage.js";
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseArray = (schema, refs) => {
+    if (Array.isArray(schema.items)) {
+        let tuple = `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
+        if (schema.contains) {
+            const containsSchema = parseSchema(schema.contains, {
+                ...refs,
+                path: [...refs.path, "contains"],
+            });
+            const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
+            const maxContains = schema.maxContains;
+            tuple += `.superRefine((arr, ctx) => {
+  const matches = arr.filter((item) => ${containsSchema}.safeParse(item).success).length;
+  if (${minContains ?? 0} && matches < ${minContains ?? 0}) {
+    ctx.addIssue({ code: "custom", message: "Array contains too few matching items" });
+  }
+  if (${maxContains ?? "undefined"} !== undefined && matches > ${maxContains ?? "undefined"}) {
+    ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
+  }
+})`;
+        }
+        return tuple;
+    }
+    let r = !schema.items
+        ? `z.array(${anyOrUnknown(refs)})`
+        : `z.array(${parseSchema(schema.items, {
+            ...refs,
+            path: [...refs.path, "items"],
+        })})`;
+    r += withMessage(schema, "minItems", ({ json }) => [
+        `.min(${json}`,
+        ", ",
+        ")",
+    ]);
+    r += withMessage(schema, "maxItems", ({ json }) => [
+        `.max(${json}`,
+        ", ",
+        ")",
+    ]);
+    if (schema.uniqueItems === true) {
+        r += withMessage(schema, "uniqueItems", () => [
+            ".unique(",
+            "",
+            ")",
+        ]);
+    }
+    if (schema.contains) {
+        const containsSchema = parseSchema(schema.contains, {
+            ...refs,
+            path: [...refs.path, "contains"],
+        });
+        const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
+        const maxContains = schema.maxContains;
+        r += `.superRefine((arr, ctx) => {
+  const matches = arr.filter((item) => ${containsSchema}.safeParse(item).success).length;
+  if (${minContains ?? 0} && matches < ${minContains ?? 0}) {
+    ctx.addIssue({ code: "custom", message: "Array contains too few matching items" });
+  }
+  if (${maxContains ?? "undefined"} !== undefined && matches > ${maxContains ?? "undefined"}) {
+    ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
+  }
+})`;
+    }
+    return r;
+};

package/dist/esm/parsers/parseBoolean.js

@@ -0,0 +1,3 @@
+export const parseBoolean = (_schema) => {
+    return "z.boolean()";
+};

package/dist/esm/parsers/parseConst.js

@@ -0,0 +1,3 @@
+export const parseConst = (schema) => {
+    return `z.literal(${JSON.stringify(schema.const)})`;
+};

package/dist/esm/parsers/parseDefault.js

@@ -0,0 +1,4 @@
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseDefault = (_schema, refs) => {
+    return anyOrUnknown(refs);
+};

package/dist/esm/parsers/parseEnum.js

@@ -0,0 +1,17 @@
+export const parseEnum = (schema) => {
+    if (schema.enum.length === 0) {
+        return "z.never()";
+    }
+    else if (schema.enum.length === 1) {
+        // union does not work when there is only one element
+        return `z.literal(${JSON.stringify(schema.enum[0])})`;
+    }
+    else if (schema.enum.every((x) => typeof x === "string")) {
+        return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
+    }
+    else {
+        return `z.union([${schema.enum
+            .map((x) => `z.literal(${JSON.stringify(x)})`)
+            .join(", ")}])`;
+    }
+};

package/dist/esm/parsers/parseIfThenElse.js

@@ -0,0 +1,30 @@
+import { parseSchema } from "./parseSchema.js";
+export const parseIfThenElse = (schema, refs) => {
+    const $if = parseSchema(schema.if, { ...refs, path: [...refs.path, "if"] });
+    const $then = parseSchema(schema.then, {
+        ...refs,
+        path: [...refs.path, "then"],
+    });
+    const $else = parseSchema(schema.else, {
+        ...refs,
+        path: [...refs.path, "else"],
+    });
+    let result = `z.union([${$then}, ${$else}]).superRefine((value,ctx) => {
+  const result = ${$if}.safeParse(value).success
+    ? ${$then}.safeParse(value)
+    : ${$else}.safeParse(value);
+  if (!result.success) {
+    result.error.issues.forEach((issue) => ctx.addIssue({...issue}))
+  }
+})`;
+    // Store original if/then/else for JSON Schema round-trip
+    if (refs.preserveJsonSchemaForRoundTrip) {
+        const conditionalMeta = JSON.stringify({
+            if: schema.if,
+            then: schema.then,
+            else: schema.else,
+        });
+        result += `.meta({ __jsonSchema: { conditional: ${conditionalMeta} } })`;
+    }
+    return result;
+};

package/dist/esm/parsers/parseMultipleType.js

@@ -0,0 +1,6 @@
+import { parseSchema } from "./parseSchema.js";
+export const parseMultipleType = (schema, refs) => {
+    return `z.union([${schema.type
+        .map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true }))
+        .join(", ")}])`;
+};

package/dist/esm/parsers/parseNot.js

@@ -0,0 +1,8 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseNot = (schema, refs) => {
+    return `${anyOrUnknown(refs)}.refine((value) => !${parseSchema(schema.not, {
+        ...refs,
+        path: [...refs.path, "not"],
+    })}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`;
+};

package/dist/esm/parsers/parseNull.js

@@ -0,0 +1,3 @@
+export const parseNull = (_schema) => {
+    return "z.null()";
+};

package/dist/esm/parsers/parseNullable.js

@@ -0,0 +1,8 @@
+import { omit } from "../utils/omit.js";
+import { parseSchema } from "./parseSchema.js";
+/**
+ * For compatibility with open api 3.0 nullable
+ */
+export const parseNullable = (schema, refs) => {
+    return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
+};

package/dist/esm/parsers/parseNumber.js

@@ -0,0 +1,70 @@
+import { withMessage } from "../utils/withMessage.js";
+export const parseNumber = (schema) => {
+    let r = "z.number()";
+    if (schema.type === "integer") {
+        r += withMessage(schema, "type", () => [".int(", ")"]);
+    }
+    else {
+        r += withMessage(schema, "format", ({ value }) => {
+            if (value === "int64") {
+                return [".int(", ")"];
+            }
+        });
+    }
+    r += withMessage(schema, "multipleOf", ({ value, json }) => {
+        if (value === 1) {
+            if (r.startsWith("z.number().int(")) {
+                return;
+            }
+            return [".int(", ")"];
+        }
+        return [`.multipleOf(${json}`, ", ", ")"];
+    });
+    if (typeof schema.minimum === "number") {
+        if (schema.exclusiveMinimum === true) {
+            r += withMessage(schema, "minimum", ({ json }) => [
+                `.gt(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+        else {
+            r += withMessage(schema, "minimum", ({ json }) => [
+                `.gte(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+    }
+    else if (typeof schema.exclusiveMinimum === "number") {
+        r += withMessage(schema, "exclusiveMinimum", ({ json }) => [
+            `.gt(${json}`,
+            ", ",
+            ")",
+        ]);
+    }
+    if (typeof schema.maximum === "number") {
+        if (schema.exclusiveMaximum === true) {
+            r += withMessage(schema, "maximum", ({ json }) => [
+                `.lt(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+        else {
+            r += withMessage(schema, "maximum", ({ json }) => [
+                `.lte(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+    }
+    else if (typeof schema.exclusiveMaximum === "number") {
+        r += withMessage(schema, "exclusiveMaximum", ({ json }) => [
+            `.lt(${json}`,
+            ", ",
+            ")",
+        ]);
+    }
+    return r;
+};