@gabrielbryk/json-schema-to-zod 2.7.4 → 2.8.0

package/dist/esm/jsonSchemaToZod.js

@@ -1,32 +1,61 @@
-import { parseSchema } from "./parsers/parseSchema.js";
-import { expandJsdocs } from "./utils/jsdocs.js";
-export const jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest } = {}) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToZod = void 0;
+const parseSchema_js_1 = require("./parsers/parseSchema.js");
+const jsdocs_js_1 = require("./utils/jsdocs.js");
+const cycles_js_1 = require("./utils/cycles.js");
+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, {
+    // Pass 1: collect declarations/dependencies to detect cycles before emitting
+    const pass1 = {
+        module,
+        name,
+        path: [],
+        seen: new Map(),
+        declarations: new Map(),
+        dependencies: new Map(),
+        inProgress: new Set(),
+        refNameByPointer,
+        usedNames,
+        root: schema,
+        currentSchemaName: name,
+        ...rest,
+        withMeta,
+    };
+    (0, parseSchema_js_1.parseSchema)(schema, pass1);
+    const names = Array.from(pass1.declarations.keys());
+    const cycleRefNames = (0, cycles_js_1.detectCycles)(names, pass1.dependencies);
+    const { componentByName } = (0, cycles_js_1.computeScc)(names, pass1.dependencies);
+    // Pass 2: generate with cycle awareness
+    const declarations = new Map();
+    const dependencies = new Map();
+    const parsedSchema = (0, parseSchema_js_1.parseSchema)(schema, {
         module,
         name,
         path: [],
         seen: new Map(),
         declarations,
+        dependencies,
         inProgress: new Set(),
         refNameByPointer,
         usedNames,
         root: schema,
         currentSchemaName: name,
+        cycleRefNames,
+        cycleComponentByName: componentByName,
         ...rest,
         withMeta,
     });
     const declarationBlock = declarations.size
-        ? Array.from(declarations.entries())
+        ? orderDeclarations(Array.from(declarations.entries()), dependencies)
             .map(([refName, value]) => {
             const shouldExport = exportRefs && module === "esm";
             const decl = `${shouldExport ? "export " : ""}const ${refName} = ${value}`;
@@ -35,7 +64,7 @@ export const jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest
             .join("\n")
         : "";
     const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description
-        ? expandJsdocs(schema.description)
+        ? (0, jsdocs_js_1.expandJsdocs)(schema.description)
         : "";
     const lines = [];
     if (module === "cjs" && !noImport) {
@@ -72,3 +101,72 @@ export const jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest
     const shouldEndWithNewline = module === "esm" || module === "cjs";
     return `${combined}${shouldEndWithNewline ? "\n" : ""}`;
 };
+exports.jsonSchemaToZod = jsonSchemaToZod;
+function orderDeclarations(entries, dependencies) {
+    const valueByName = new Map(entries);
+    const depGraph = new Map();
+    // Seed with explicit dependencies recorded during parsing
+    for (const [from, set] of dependencies.entries()) {
+        const onlyKnown = new Set();
+        for (const dep of set) {
+            if (valueByName.has(dep) && dep !== from) {
+                onlyKnown.add(dep);
+            }
+        }
+        if (onlyKnown.size)
+            depGraph.set(from, onlyKnown);
+    }
+    // Also infer deps by scanning declaration bodies for referenced names
+    const names = Array.from(valueByName.keys());
+    for (const [name, value] of entries) {
+        const deps = depGraph.get(name) ?? new Set();
+        for (const candidate of names) {
+            if (candidate === name)
+                continue;
+            const matcher = new RegExp(`\\b${candidate}\\b`);
+            if (matcher.test(value)) {
+                deps.add(candidate);
+            }
+        }
+        if (deps.size)
+            depGraph.set(name, deps);
+    }
+    const ordered = [];
+    const perm = new Set();
+    const temp = new Set();
+    const visit = (name) => {
+        if (perm.has(name))
+            return;
+        if (temp.has(name)) {
+            // Cycle detected; break it but still include the node.
+            temp.delete(name);
+            perm.add(name);
+            ordered.push(name);
+            return;
+        }
+        temp.add(name);
+        const deps = depGraph.get(name);
+        if (deps) {
+            for (const dep of deps) {
+                if (valueByName.has(dep)) {
+                    visit(dep);
+                }
+            }
+        }
+        temp.delete(name);
+        perm.add(name);
+        ordered.push(name);
+    };
+    for (const name of valueByName.keys()) {
+        visit(name);
+    }
+    const unique = [];
+    const seen = new Set();
+    for (const name of ordered) {
+        if (!seen.has(name)) {
+            seen.add(name);
+            unique.push(name);
+        }
+    }
+    return unique.map((name) => [name, valueByName.get(name)]);
+}

package/dist/esm/parsers/parseAllOf.js

@@ -1,5 +1,8 @@
-import { parseSchema } from "./parseSchema.js";
-import { half } from "../utils/half.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAllOf = parseAllOf;
+const parseSchema_js_1 = require("./parseSchema.js");
+const half_js_1 = require("../utils/half.js");
 const originalIndex = Symbol("Original index");
 const ensureOriginalIndex = (arr) => {
     let newArr = [];
@@ -17,19 +20,19 @@ const ensureOriginalIndex = (arr) => {
     }
     return newArr;
 };
-export function parseAllOf(schema, refs) {
+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, {
+        return (0, parseSchema_js_1.parseSchema)(item, {
             ...refs,
             path: [...refs.path, "allOf", item[originalIndex]],
         });
     }
     else {
-        const [left, right] = half(ensureOriginalIndex(schema.allOf));
+        const [left, right] = (0, half_js_1.half)(ensureOriginalIndex(schema.allOf));
         return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
             allOf: right,
         }, refs)})`;

package/dist/esm/parsers/parseAnyOf.js

@@ -1,14 +1,18 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseAnyOf = (schema, refs) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnyOf = void 0;
+const parseSchema_js_1 = require("./parseSchema.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+const parseAnyOf = (schema, refs) => {
     return schema.anyOf.length
         ? schema.anyOf.length === 1
-            ? parseSchema(schema.anyOf[0], {
+            ? (0, parseSchema_js_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] }))
+                .map((schema, i) => (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "anyOf", i] }))
                 .join(", ")}])`
-        : anyOrUnknown(refs);
+        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
 };
+exports.parseAnyOf = parseAnyOf;

package/dist/esm/parsers/parseArray.js

@@ -1,11 +1,14 @@
-import { withMessage } from "../utils/withMessage.js";
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseArray = (schema, refs) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArray = void 0;
+const withMessage_js_1 = require("../utils/withMessage.js");
+const parseSchema_js_1 = require("./parseSchema.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+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] }))}])`;
+        let tuple = `z.tuple([${schema.items.map((v, i) => (0, parseSchema_js_1.parseSchema)(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
         if (schema.contains) {
-            const containsSchema = parseSchema(schema.contains, {
+            const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
                 ...refs,
                 path: [...refs.path, "contains"],
             });
@@ -24,30 +27,49 @@ export const parseArray = (schema, refs) => {
         return tuple;
     }
     let r = !schema.items
-        ? `z.array(${anyOrUnknown(refs)})`
-        : `z.array(${parseSchema(schema.items, {
+        ? `z.array(${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`
+        : `z.array(${(0, parseSchema_js_1.parseSchema)(schema.items, {
             ...refs,
             path: [...refs.path, "items"],
         })})`;
-    r += withMessage(schema, "minItems", ({ json }) => [
-        `.min(${json}`,
-        ", ",
-        ")",
-    ]);
-    r += withMessage(schema, "maxItems", ({ json }) => [
-        `.max(${json}`,
-        ", ",
-        ")",
-    ]);
+    r += (0, withMessage_js_1.withMessage)(schema, "minItems", ({ json }) => ({
+        opener: `.min(${json}`,
+        closer: ")",
+        messagePrefix: ", { error: ",
+        messageCloser: " })",
+    }));
+    r += (0, withMessage_js_1.withMessage)(schema, "maxItems", ({ json }) => ({
+        opener: `.max(${json}`,
+        closer: ")",
+        messagePrefix: ", { error: ",
+        messageCloser: " })",
+    }));
     if (schema.uniqueItems === true) {
-        r += withMessage(schema, "uniqueItems", () => [
-            ".unique(",
-            "",
-            ")",
-        ]);
+        r += `.superRefine((arr, ctx) => {
+  const seen = new Set();
+  for (const [index, value] of arr.entries()) {
+    let key;
+    if (value && typeof value === "object") {
+      try {
+        key = JSON.stringify(value);
+      } catch {
+        key = String(value);
+      }
+    } else {
+      key = JSON.stringify(value);
+    }
+
+    if (seen.has(key)) {
+      ctx.addIssue({ code: "custom", message: "Array items must be unique", path: [index] });
+      return;
+    }
+
+    seen.add(key);
+  }
+})`;
     }
     if (schema.contains) {
-        const containsSchema = parseSchema(schema.contains, {
+        const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
             ...refs,
             path: [...refs.path, "contains"],
         });
@@ -65,3 +87,4 @@ export const parseArray = (schema, refs) => {
     }
     return r;
 };
+exports.parseArray = parseArray;

package/dist/esm/parsers/parseBoolean.js

@@ -1,3 +1,7 @@
-export const parseBoolean = (_schema) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+const parseBoolean = (_schema) => {
     return "z.boolean()";
 };
+exports.parseBoolean = parseBoolean;

package/dist/esm/parsers/parseConst.js

@@ -1,3 +1,7 @@
-export const parseConst = (schema) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConst = void 0;
+const parseConst = (schema) => {
     return `z.literal(${JSON.stringify(schema.const)})`;
 };
+exports.parseConst = parseConst;

package/dist/esm/parsers/parseDefault.js

@@ -1,4 +1,8 @@
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseDefault = (_schema, refs) => {
-    return anyOrUnknown(refs);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefault = void 0;
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+const parseDefault = (_schema, refs) => {
+    return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
 };
+exports.parseDefault = parseDefault;

package/dist/esm/parsers/parseEnum.js

@@ -1,4 +1,7 @@
-export const parseEnum = (schema) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnum = void 0;
+const parseEnum = (schema) => {
     if (schema.enum.length === 0) {
         return "z.never()";
     }
@@ -15,3 +18,4 @@ export const parseEnum = (schema) => {
             .join(", ")}])`;
     }
 };
+exports.parseEnum = parseEnum;

package/dist/esm/parsers/parseIfThenElse.js

@@ -1,11 +1,14 @@
-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, {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfThenElse = void 0;
+const parseSchema_js_1 = require("./parseSchema.js");
+const parseIfThenElse = (schema, refs) => {
+    const $if = (0, parseSchema_js_1.parseSchema)(schema.if, { ...refs, path: [...refs.path, "if"] });
+    const $then = (0, parseSchema_js_1.parseSchema)(schema.then, {
         ...refs,
         path: [...refs.path, "then"],
     });
-    const $else = parseSchema(schema.else, {
+    const $else = (0, parseSchema_js_1.parseSchema)(schema.else, {
         ...refs,
         path: [...refs.path, "else"],
     });
@@ -14,7 +17,8 @@ export const parseIfThenElse = (schema, refs) => {
     ? ${$then}.safeParse(value)
     : ${$else}.safeParse(value);
   if (!result.success) {
-    result.error.errors.forEach((error) => ctx.addIssue(error))
+    const issues = result.error.issues ?? result.error.errors ?? [];
+    issues.forEach((issue) => ctx.addIssue(issue))
   }
 })`;
     // Store original if/then/else for JSON Schema round-trip
@@ -28,3 +32,4 @@ export const parseIfThenElse = (schema, refs) => {
     }
     return result;
 };
+exports.parseIfThenElse = parseIfThenElse;

package/dist/esm/parsers/parseMultipleType.js

@@ -1,6 +1,10 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseMultipleType = (schema, refs) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMultipleType = void 0;
+const parseSchema_js_1 = require("./parseSchema.js");
+const parseMultipleType = (schema, refs) => {
     return `z.union([${schema.type
-        .map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true }))
+        .map((type) => (0, parseSchema_js_1.parseSchema)({ ...schema, type }, { ...refs, withoutDefaults: true }))
         .join(", ")}])`;
 };
+exports.parseMultipleType = parseMultipleType;

package/dist/esm/parsers/parseNot.js

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

package/dist/esm/parsers/parseNull.js

@@ -1,3 +1,7 @@
-export const parseNull = (_schema) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNull = void 0;
+const parseNull = (_schema) => {
     return "z.null()";
 };
+exports.parseNull = parseNull;

package/dist/esm/parsers/parseNullable.js

@@ -1,8 +1,12 @@
-import { omit } from "../utils/omit.js";
-import { parseSchema } from "./parseSchema.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullable = void 0;
+const omit_js_1 = require("../utils/omit.js");
+const parseSchema_js_1 = require("./parseSchema.js");
 /**
  * For compatibility with open api 3.0 nullable
  */
-export const parseNullable = (schema, refs) => {
-    return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
+const parseNullable = (schema, refs) => {
+    return `${(0, parseSchema_js_1.parseSchema)((0, omit_js_1.omit)(schema, "nullable"), refs, true)}.nullable()`;
 };
+exports.parseNullable = parseNullable;

package/dist/esm/parsers/parseNumber.js

@@ -1,70 +1,116 @@
-import { withMessage } from "../utils/withMessage.js";
-export const parseNumber = (schema) => {
-    let r = "z.number()";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumber = void 0;
+const withMessage_js_1 = require("../utils/withMessage.js");
+const parseNumber = (schema) => {
+    const formatError = schema.errorMessage?.format;
+    const numericFormatMap = {
+        int32: "z.int32",
+        uint32: "z.uint32",
+        float32: "z.float32",
+        float64: "z.float64",
+        safeint: "z.safeint",
+        int64: "z.int64",
+        uint64: "z.uint64",
+    };
+    const mappedFormat = schema.format && numericFormatMap[schema.format] ? numericFormatMap[schema.format] : undefined;
+    const formatParams = formatError !== undefined ? `{ error: ${JSON.stringify(formatError)} }` : "";
+    let r = mappedFormat ? `${mappedFormat}(${formatParams})` : "z.number()";
     if (schema.type === "integer") {
-        r += withMessage(schema, "type", () => [".int(", ")"]);
+        if (!mappedFormat) {
+            r += (0, withMessage_js_1.withMessage)(schema, "type", () => ({
+                opener: ".int(",
+                closer: ")",
+                messagePrefix: "{ error: ",
+                messageCloser: " })",
+            }));
+        }
     }
     else {
-        r += withMessage(schema, "format", ({ value }) => {
-            if (value === "int64") {
-                return [".int(", ")"];
-            }
-        });
+        if (!mappedFormat) {
+            r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+                if (value === "int64") {
+                    return {
+                        opener: ".int(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                }
+            });
+        }
     }
-    r += withMessage(schema, "multipleOf", ({ value, json }) => {
+    r += (0, withMessage_js_1.withMessage)(schema, "multipleOf", ({ value, json }) => {
         if (value === 1) {
             if (r.startsWith("z.number().int(")) {
                 return;
             }
-            return [".int(", ")"];
+            return {
+                opener: ".int(",
+                closer: ")",
+                messagePrefix: "{ error: ",
+                messageCloser: " })",
+            };
         }
-        return [`.multipleOf(${json}`, ", ", ")"];
+        return {
+            opener: `.multipleOf(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        };
     });
     if (typeof schema.minimum === "number") {
         if (schema.exclusiveMinimum === true) {
-            r += withMessage(schema, "minimum", ({ json }) => [
-                `.gt(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+                opener: `.gt(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
         else {
-            r += withMessage(schema, "minimum", ({ json }) => [
-                `.gte(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+                opener: `.gte(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
     }
     else if (typeof schema.exclusiveMinimum === "number") {
-        r += withMessage(schema, "exclusiveMinimum", ({ json }) => [
-            `.gt(${json}`,
-            ", ",
-            ")",
-        ]);
+        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => ({
+            opener: `.gt(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        }));
     }
     if (typeof schema.maximum === "number") {
         if (schema.exclusiveMaximum === true) {
-            r += withMessage(schema, "maximum", ({ json }) => [
-                `.lt(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+                opener: `.lt(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
         else {
-            r += withMessage(schema, "maximum", ({ json }) => [
-                `.lte(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+                opener: `.lte(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
     }
     else if (typeof schema.exclusiveMaximum === "number") {
-        r += withMessage(schema, "exclusiveMaximum", ({ json }) => [
-            `.lt(${json}`,
-            ", ",
-            ")",
-        ]);
+        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => ({
+            opener: `.lt(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        }));
     }
     return r;
 };
+exports.parseNumber = parseNumber;