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

package/dist/esm/jsonSchemaToZod.js

@@ -1,172 +1,6 @@
-"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 refNameByPointer = new Map();
-    const usedNames = new Set();
-    const exportRefs = rest.exportRefs ?? true;
-    const withMeta = rest.withMeta ?? true;
-    if (name)
-        usedNames.add(name);
-    // 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
-        ? orderDeclarations(Array.from(declarations.entries()), dependencies)
-            .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
-        ? (0, jsdocs_js_1.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" : ""}`;
+import { analyzeSchema } from "./core/analyzeSchema.js";
+import { emitZod } from "./core/emitZod.js";
+export const jsonSchemaToZod = (schema, options = {}) => {
+    const analysis = analyzeSchema(schema, options);
+    return emitZod(analysis);
 };
-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,38 +1,41 @@
-"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");
+import { parseSchema } from "./parseSchema.js";
+import { half } from "../utils/half.js";
+const originalIndexKey = "__originalIndex";
 const ensureOriginalIndex = (arr) => {
-    let newArr = [];
+    const 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: {} });
+            newArr.push(item ? { [originalIndexKey]: i } : { [originalIndexKey]: i, not: {} });
         }
-        else if (originalIndex in item) {
+        else if (typeof item === "object" &&
+            item !== null &&
+            originalIndexKey in item) {
             return arr;
         }
         else {
-            newArr.push({ ...item, [originalIndex]: i });
+            newArr.push({ ...item, [originalIndexKey]: i });
         }
     }
     return newArr;
 };
-function parseAllOf(schema, refs) {
+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 (0, parseSchema_js_1.parseSchema)(item, {
+        return parseSchema(item, {
             ...refs,
-            path: [...refs.path, "allOf", item[originalIndex]],
+            path: [
+                ...refs.path,
+                "allOf",
+                item[originalIndexKey] ?? 0,
+            ],
         });
     }
     else {
-        const [left, right] = (0, half_js_1.half)(ensureOriginalIndex(schema.allOf));
+        const [left, right] = half(ensureOriginalIndex(schema.allOf));
         return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
             allOf: right,
         }, refs)})`;

package/dist/esm/parsers/parseAnyOf.js

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

package/dist/esm/parsers/parseArray.js

@@ -1,14 +1,11 @@
-"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) => {
+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) => (0, parseSchema_js_1.parseSchema)(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
+        let tuple = `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
         if (schema.contains) {
-            const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
+            const containsSchema = parseSchema(schema.contains, {
                 ...refs,
                 path: [...refs.path, "contains"],
             });
@@ -27,18 +24,18 @@ const parseArray = (schema, refs) => {
         return tuple;
     }
     let r = !schema.items
-        ? `z.array(${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`
-        : `z.array(${(0, parseSchema_js_1.parseSchema)(schema.items, {
+        ? `z.array(${anyOrUnknown(refs)})`
+        : `z.array(${parseSchema(schema.items, {
             ...refs,
             path: [...refs.path, "items"],
         })})`;
-    r += (0, withMessage_js_1.withMessage)(schema, "minItems", ({ json }) => ({
+    r += withMessage(schema, "minItems", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
         messagePrefix: ", { error: ",
         messageCloser: " })",
     }));
-    r += (0, withMessage_js_1.withMessage)(schema, "maxItems", ({ json }) => ({
+    r += withMessage(schema, "maxItems", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
         messagePrefix: ", { error: ",
@@ -69,7 +66,7 @@ const parseArray = (schema, refs) => {
 })`;
     }
     if (schema.contains) {
-        const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
+        const containsSchema = parseSchema(schema.contains, {
             ...refs,
             path: [...refs.path, "contains"],
         });
@@ -87,4 +84,3 @@ const parseArray = (schema, refs) => {
     }
     return r;
 };
-exports.parseArray = parseArray;

package/dist/esm/parsers/parseBoolean.js

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

package/dist/esm/parsers/parseConst.js

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

package/dist/esm/parsers/parseDefault.js

@@ -1,8 +1,4 @@
-"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);
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseDefault = (_schema, refs) => {
+    return anyOrUnknown(refs);
 };
-exports.parseDefault = parseDefault;

package/dist/esm/parsers/parseEnum.js

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

package/dist/esm/parsers/parseIfThenElse.js

@@ -1,14 +1,11 @@
-"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, {
+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 = (0, parseSchema_js_1.parseSchema)(schema.else, {
+    const $else = parseSchema(schema.else, {
         ...refs,
         path: [...refs.path, "else"],
     });
@@ -17,7 +14,7 @@ const parseIfThenElse = (schema, refs) => {
     ? ${$then}.safeParse(value)
     : ${$else}.safeParse(value);
   if (!result.success) {
-    const issues = result.error.issues ?? result.error.errors ?? [];
+    const issues = result.error.issues;
     issues.forEach((issue) => ctx.addIssue(issue))
   }
 })`;
@@ -32,4 +29,3 @@ const parseIfThenElse = (schema, refs) => {
     }
     return result;
 };
-exports.parseIfThenElse = parseIfThenElse;

package/dist/esm/parsers/parseMultipleType.js

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

package/dist/esm/parsers/parseNot.js

@@ -1,12 +1,8 @@
-"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, {
+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")`;
 };
-exports.parseNot = parseNot;

package/dist/esm/parsers/parseNull.js

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

package/dist/esm/parsers/parseNullable.js

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

package/dist/esm/parsers/parseNumber.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNumber = void 0;
-const withMessage_js_1 = require("../utils/withMessage.js");
-const parseNumber = (schema) => {
+import { withMessage } from "../utils/withMessage.js";
+export const parseNumber = (schema) => {
     const formatError = schema.errorMessage?.format;
     const numericFormatMap = {
         int32: "z.int32",
@@ -18,7 +15,7 @@ const parseNumber = (schema) => {
     let r = mappedFormat ? `${mappedFormat}(${formatParams})` : "z.number()";
     if (schema.type === "integer") {
         if (!mappedFormat) {
-            r += (0, withMessage_js_1.withMessage)(schema, "type", () => ({
+            r += withMessage(schema, "type", () => ({
                 opener: ".int(",
                 closer: ")",
                 messagePrefix: "{ error: ",
@@ -28,7 +25,7 @@ const parseNumber = (schema) => {
     }
     else {
         if (!mappedFormat) {
-            r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+            r += withMessage(schema, "format", ({ value }) => {
                 if (value === "int64") {
                     return {
                         opener: ".int(",
@@ -40,7 +37,7 @@ const parseNumber = (schema) => {
             });
         }
     }
-    r += (0, withMessage_js_1.withMessage)(schema, "multipleOf", ({ value, json }) => {
+    r += withMessage(schema, "multipleOf", ({ value, json }) => {
         if (value === 1) {
             if (r.startsWith("z.number().int(")) {
                 return;
@@ -61,7 +58,7 @@ const parseNumber = (schema) => {
     });
     if (typeof schema.minimum === "number") {
         if (schema.exclusiveMinimum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+            r += withMessage(schema, "minimum", ({ json }) => ({
                 opener: `.gt(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -69,7 +66,7 @@ const parseNumber = (schema) => {
             }));
         }
         else {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+            r += withMessage(schema, "minimum", ({ json }) => ({
                 opener: `.gte(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -78,7 +75,7 @@ const parseNumber = (schema) => {
         }
     }
     else if (typeof schema.exclusiveMinimum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => ({
+        r += withMessage(schema, "exclusiveMinimum", ({ json }) => ({
             opener: `.gt(${json}`,
             closer: ")",
             messagePrefix: ", { error: ",
@@ -87,7 +84,7 @@ const parseNumber = (schema) => {
     }
     if (typeof schema.maximum === "number") {
         if (schema.exclusiveMaximum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+            r += withMessage(schema, "maximum", ({ json }) => ({
                 opener: `.lt(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -95,7 +92,7 @@ const parseNumber = (schema) => {
             }));
         }
         else {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+            r += withMessage(schema, "maximum", ({ json }) => ({
                 opener: `.lte(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -104,7 +101,7 @@ const parseNumber = (schema) => {
         }
     }
     else if (typeof schema.exclusiveMaximum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => ({
+        r += withMessage(schema, "exclusiveMaximum", ({ json }) => ({
             opener: `.lt(${json}`,
             closer: ")",
             messagePrefix: ", { error: ",
@@ -113,4 +110,3 @@ const parseNumber = (schema) => {
     }
     return r;
 };
-exports.parseNumber = parseNumber;