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

package/dist/cjs/utils/cycles.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeScc = exports.detectCycles = exports.findRefDependencies = void 0;
+const findRefDependencies = (schema, validDefNames) => {
+    const deps = new Set();
+    function traverse(obj) {
+        if (obj === null || typeof obj !== "object")
+            return;
+        if (Array.isArray(obj)) {
+            obj.forEach(traverse);
+            return;
+        }
+        const record = obj;
+        if (typeof record["$ref"] === "string") {
+            const ref = record["$ref"];
+            const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+            if (match && validDefNames.includes(match[1])) {
+                deps.add(match[1]);
+            }
+        }
+        for (const value of Object.values(record)) {
+            traverse(value);
+        }
+    }
+    traverse(schema);
+    return deps;
+};
+exports.findRefDependencies = findRefDependencies;
+const detectCycles = (defNames, deps) => {
+    const cycleNodes = new Set();
+    const visited = new Set();
+    const recursionStack = new Set();
+    function dfs(node, path) {
+        if (recursionStack.has(node)) {
+            const cycleStart = path.indexOf(node);
+            for (let i = cycleStart; i < path.length; i++) {
+                cycleNodes.add(path[i]);
+            }
+            cycleNodes.add(node);
+            return;
+        }
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        recursionStack.add(node);
+        const targets = deps.get(node);
+        if (targets) {
+            for (const dep of targets) {
+                dfs(dep, [...path, node]);
+            }
+        }
+        recursionStack.delete(node);
+    }
+    for (const defName of defNames) {
+        if (!visited.has(defName))
+            dfs(defName, []);
+    }
+    return cycleNodes;
+};
+exports.detectCycles = detectCycles;
+const computeScc = (defNames, deps) => {
+    // Tarjan's algorithm, keeps mapping for quick "is this ref in my cycle?"
+    const index = new Map();
+    const lowlink = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const componentByName = new Map();
+    const cycleMembers = new Set();
+    let currentIndex = 0;
+    let componentId = 0;
+    const strongConnect = (v) => {
+        index.set(v, currentIndex);
+        lowlink.set(v, currentIndex);
+        currentIndex += 1;
+        stack.push(v);
+        onStack.add(v);
+        const neighbors = deps.get(v);
+        if (neighbors) {
+            for (const w of neighbors) {
+                if (!index.has(w)) {
+                    strongConnect(w);
+                    lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+                }
+                else if (onStack.has(w)) {
+                    lowlink.set(v, Math.min(lowlink.get(v), index.get(w)));
+                }
+            }
+        }
+        if (lowlink.get(v) === index.get(v)) {
+            const component = [];
+            let w;
+            do {
+                w = stack.pop();
+                if (w === undefined)
+                    break;
+                onStack.delete(w);
+                component.push(w);
+                componentByName.set(w, componentId);
+            } while (w !== v);
+            if (component.length > 1) {
+                component.forEach((name) => cycleMembers.add(name));
+            }
+            componentId += 1;
+        }
+    };
+    for (const name of defNames) {
+        if (!index.has(name)) {
+            strongConnect(name);
+        }
+    }
+    return { cycleMembers, componentByName };
+};
+exports.computeScc = computeScc;

package/dist/cjs/utils/withMessage.js

@@ -7,14 +7,13 @@ function withMessage(schema, key, get) {
     if (value !== undefined) {
         const got = get({ value, json: JSON.stringify(value) });
         if (got) {
-            const opener = got[0];
-            const prefix = got.length === 3 ? got[1] : "";
-            const closer = got.length === 3 ? got[2] : got[1];
+            const { opener, closer, messagePrefix = "", messageCloser } = got;
             r += opener;
             if (schema.errorMessage?.[key] !== undefined) {
-                r += prefix + JSON.stringify(schema.errorMessage[key]);
+                r += messagePrefix + JSON.stringify(schema.errorMessage[key]);
+                r += messageCloser ?? closer;
+                return r;
             }
-            r;
             r += closer;
         }
     }

package/dist/esm/Types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/cli.js

@@ -1,8 +1,10 @@
 #!/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";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonSchemaToZod_js_1 = require("./jsonSchemaToZod.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cliTools_js_1 = require("./utils/cliTools.js");
 const params = {
     input: {
         shorthand: "i",
@@ -46,10 +48,10 @@ const params = {
     },
 };
 async function main() {
-    const args = parseArgs(params, process.argv, true);
-    const input = args.input || (await readPipe());
-    const jsonSchema = parseOrReadJSON(input);
-    const zodSchema = jsonSchemaToZod(jsonSchema, {
+    const args = (0, cliTools_js_1.parseArgs)(params, process.argv, true);
+    const input = args.input || (await (0, cliTools_js_1.readPipe)());
+    const jsonSchema = (0, cliTools_js_1.parseOrReadJSON)(input);
+    const zodSchema = (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(jsonSchema, {
         name: args.name,
         depth: args.depth,
         module: args.module || "esm",
@@ -58,8 +60,8 @@ async function main() {
         withJsdocs: args.withJsdocs,
     });
     if (args.output) {
-        mkdirSync(dirname(args.output), { recursive: true });
-        writeFileSync(args.output, zodSchema);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(args.output), { recursive: true });
+        (0, fs_1.writeFileSync)(args.output, zodSchema);
     }
     else {
         console.log(zodSchema);

package/dist/esm/generators/generateBundle.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaBundle = void 0;
+const jsonSchemaToZod_js_1 = require("../jsonSchemaToZod.js");
+const generateSchemaBundle = (schema, options = {}) => {
+    const module = options.module ?? "esm";
+    const rootName = options.splitDefs?.rootName ?? options.name ?? "RootSchema";
+    const rootTypeName = typeof options.type === "string"
+        ? options.type
+        : options.splitDefs?.rootTypeName ?? (typeof options.type === "boolean" && options.type ? rootName : undefined);
+    if (!schema || typeof schema !== "object") {
+        throw new Error("generateSchemaBundle requires an object schema");
+    }
+    const defs = schema.$defs || schema.definitions || {};
+    const defNames = Object.keys(defs);
+    const defInfoMap = buildDefInfoMap(defNames, defs, options);
+    const cycles = detectCycles(defInfoMap);
+    for (const defName of cycles) {
+        const info = defInfoMap.get(defName);
+        if (info)
+            info.hasCycle = true;
+    }
+    const files = [];
+    // Generate individual $def files
+    for (const defName of defNames) {
+        const info = defInfoMap.get(defName);
+        const usedRefs = new Set();
+        const defSchemaWithDefs = {
+            ...defs[defName],
+            $defs: defs,
+        };
+        const zodSchema = (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(defSchemaWithDefs, {
+            ...options,
+            module,
+            name: info.schemaName,
+            type: info.typeName,
+            parserOverride: createRefHandler(defName, defInfoMap, usedRefs, defs, options),
+        });
+        const finalSchema = buildSchemaFile(zodSchema, usedRefs, defInfoMap, module);
+        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
+        files.push({ fileName, contents: finalSchema });
+    }
+    // Generate root schema if requested
+    if (options.splitDefs?.includeRoot ?? true) {
+        const usedRefs = new Set();
+        const workflowSchemaWithDefs = {
+            ...schema,
+        };
+        const workflowZodSchema = (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(workflowSchemaWithDefs, {
+            ...options,
+            module,
+            name: rootName,
+            type: rootTypeName,
+            parserOverride: createRefHandler(null, defInfoMap, usedRefs, defs, options),
+        });
+        const finalWorkflow = buildSchemaFile(workflowZodSchema, usedRefs, defInfoMap, module);
+        const rootFile = options.splitDefs?.fileName?.("root", { isRoot: true }) ?? "workflow.schema.ts";
+        files.push({ fileName: rootFile, contents: finalWorkflow });
+    }
+    // Nested types extraction (optional)
+    const nestedTypesEnabled = options.nestedTypes?.enable;
+    if (nestedTypesEnabled) {
+        const nestedTypes = collectNestedTypes(schema, defs, defNames, rootTypeName ?? rootName);
+        if (nestedTypes.length > 0) {
+            const nestedFileName = options.nestedTypes?.fileName ?? "nested-types.ts";
+            const nestedContent = generateNestedTypesFile(nestedTypes);
+            files.push({ fileName: nestedFileName, contents: nestedContent });
+        }
+    }
+    return { files, defNames };
+};
+exports.generateSchemaBundle = generateSchemaBundle;
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+const toPascalCase = (str) => str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+const buildDefInfoMap = (defNames, defs, options) => {
+    const map = new Map();
+    for (const defName of defNames) {
+        const dependencies = findRefDependencies(defs[defName], defNames);
+        const pascalName = toPascalCase(defName);
+        const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
+        const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
+        map.set(defName, {
+            name: defName,
+            pascalName,
+            schemaName,
+            typeName,
+            dependencies,
+            hasCycle: false,
+        });
+    }
+    return map;
+};
+const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options) => {
+    return (schema, refs) => {
+        if (typeof schema["$ref"] === "string") {
+            const refPath = schema["$ref"];
+            const match = refPath.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+            if (match) {
+                const refName = match[1];
+                const refInfo = defInfoMap.get(refName);
+                if (refInfo) {
+                    // Track imports when referencing other defs
+                    if (refName !== currentDefName) {
+                        usedRefs.add(refName);
+                    }
+                    const isCycle = refName === currentDefName || (refInfo.hasCycle && !!currentDefName);
+                    const resolved = options.refResolution?.onRef?.({
+                        ref: refPath,
+                        refName,
+                        currentDef: currentDefName,
+                        path: refs.path,
+                        isCycle,
+                    });
+                    if (resolved)
+                        return resolved;
+                    return refInfo.schemaName;
+                }
+            }
+            const unknown = options.refResolution?.onUnknownRef?.({ ref: refPath, currentDef: currentDefName });
+            if (unknown)
+                return unknown;
+            return options.useUnknown ? "z.unknown()" : "z.any()";
+        }
+        // Inline $defs within a schema
+        if (schema["$defs"] && typeof schema["$defs"] === "object") {
+            return (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(schema, {
+                ...options,
+                module: options.module ?? "esm",
+                parserOverride: createRefHandler(currentDefName, defInfoMap, usedRefs, allDefs, options),
+            });
+        }
+        return undefined;
+    };
+};
+const buildSchemaFile = (zodCode, usedRefs, defInfoMap, module) => {
+    if (module !== "esm")
+        return zodCode;
+    const imports = [];
+    for (const refName of [...usedRefs].sort()) {
+        const refInfo = defInfoMap.get(refName);
+        if (refInfo) {
+            imports.push(`import { ${refInfo.schemaName} } from './${refName}.schema.js';`);
+        }
+    }
+    if (!imports.length)
+        return zodCode;
+    return zodCode.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`);
+};
+const findRefDependencies = (schema, validDefNames) => {
+    const deps = new Set();
+    function traverse(obj) {
+        if (obj === null || typeof obj !== "object")
+            return;
+        if (Array.isArray(obj)) {
+            obj.forEach(traverse);
+            return;
+        }
+        const record = obj;
+        if (typeof record["$ref"] === "string") {
+            const ref = record["$ref"];
+            const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+            if (match && validDefNames.includes(match[1])) {
+                deps.add(match[1]);
+            }
+        }
+        for (const value of Object.values(record)) {
+            traverse(value);
+        }
+    }
+    traverse(schema);
+    return deps;
+};
+const detectCycles = (defInfoMap) => {
+    const cycleNodes = new Set();
+    const visited = new Set();
+    const recursionStack = new Set();
+    function dfs(node, path) {
+        if (recursionStack.has(node)) {
+            const cycleStart = path.indexOf(node);
+            for (let i = cycleStart; i < path.length; i++) {
+                cycleNodes.add(path[i]);
+            }
+            cycleNodes.add(node);
+            return true;
+        }
+        if (visited.has(node))
+            return false;
+        visited.add(node);
+        recursionStack.add(node);
+        const info = defInfoMap.get(node);
+        if (info) {
+            for (const dep of info.dependencies) {
+                dfs(dep, [...path, node]);
+            }
+        }
+        recursionStack.delete(node);
+        return false;
+    }
+    for (const defName of defInfoMap.keys()) {
+        if (!visited.has(defName)) {
+            dfs(defName, []);
+        }
+    }
+    return cycleNodes;
+};
+const collectNestedTypes = (rootSchema, defs, defNames, rootTypeName) => {
+    const allNestedTypes = [];
+    for (const defName of defNames) {
+        const defSchema = defs[defName];
+        const parentTypeName = toPascalCase(defName);
+        const nestedTypes = findNestedTypesInSchema(defSchema, parentTypeName, defNames);
+        for (const nested of nestedTypes) {
+            nested.file = defName;
+            nested.parentType = parentTypeName;
+            allNestedTypes.push(nested);
+        }
+    }
+    const workflowNestedTypes = findNestedTypesInSchema({ properties: rootSchema.properties, required: rootSchema.required }, rootTypeName, defNames);
+    for (const nested of workflowNestedTypes) {
+        nested.file = "workflow";
+        nested.parentType = rootTypeName;
+        allNestedTypes.push(nested);
+    }
+    const uniqueNestedTypes = new Map();
+    for (const nested of allNestedTypes) {
+        if (!uniqueNestedTypes.has(nested.typeName) && nested.propertyPath.length > 0) {
+            uniqueNestedTypes.set(nested.typeName, nested);
+        }
+    }
+    return [...uniqueNestedTypes.values()];
+};
+const findNestedTypesInSchema = (schema, parentTypeName, defNames, currentPath = []) => {
+    const nestedTypes = [];
+    if (schema === null || typeof schema !== "object")
+        return nestedTypes;
+    const record = schema;
+    if (record.title && typeof record.title === "string" && record.type === "object") {
+        const title = record.title;
+        if (title !== parentTypeName && !defNames.map((d) => toPascalCase(d)).includes(title)) {
+            nestedTypes.push({
+                typeName: title,
+                parentType: parentTypeName,
+                propertyPath: [...currentPath],
+                file: "",
+            });
+        }
+    }
+    if (record.properties && typeof record.properties === "object") {
+        for (const [propName, propSchema] of Object.entries(record.properties)) {
+            nestedTypes.push(...findNestedTypesInSchema(propSchema, parentTypeName, defNames, [...currentPath, propName]));
+        }
+    }
+    if (Array.isArray(record.allOf)) {
+        for (const item of record.allOf) {
+            nestedTypes.push(...findNestedTypesInSchema(item, parentTypeName, defNames, currentPath));
+        }
+    }
+    if (record.items) {
+        nestedTypes.push(...findNestedTypesInSchema(record.items, parentTypeName, defNames, currentPath));
+    }
+    if (record.additionalProperties && typeof record.additionalProperties === "object") {
+        nestedTypes.push(...findNestedTypesInSchema(record.additionalProperties, parentTypeName, defNames, currentPath));
+    }
+    return nestedTypes;
+};
+const generateNestedTypesFile = (nestedTypes) => {
+    const lines = [
+        "/**",
+        " * Auto-generated nested type exports",
+        " * ",
+        " * These types are inline within parent schemas but commonly needed separately.",
+        " * They are extracted using TypeScript indexed access types.",
+        " */",
+        "",
+    ];
+    const byParent = new Map();
+    for (const info of nestedTypes) {
+        if (!byParent.has(info.parentType)) {
+            byParent.set(info.parentType, []);
+        }
+        byParent.get(info.parentType).push(info);
+    }
+    const imports = new Set();
+    for (const info of nestedTypes) {
+        imports.add(info.file);
+    }
+    for (const file of [...imports].sort()) {
+        const typeName = file === "workflow" ? "Workflow" : toPascalCase(file);
+        lines.push(`import type { ${typeName} } from './${file}.schema.js';`);
+    }
+    lines.push("");
+    for (const [parentType, types] of [...byParent.entries()].sort()) {
+        lines.push(`// From ${parentType}`);
+        for (const info of types.sort((a, b) => a.typeName.localeCompare(b.typeName))) {
+            if (info.propertyPath.length > 0) {
+                let accessExpr = parentType;
+                for (const prop of info.propertyPath) {
+                    accessExpr = `NonNullable<${accessExpr}['${prop}']>`;
+                }
+                lines.push(`export type ${info.typeName} = ${accessExpr};`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+};

package/dist/esm/index.js

@@ -1,28 +1,46 @@
-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;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Types.js"), exports);
+__exportStar(require("./generators/generateBundle.js"), exports);
+__exportStar(require("./jsonSchemaToZod.js"), exports);
+__exportStar(require("./parsers/parseAllOf.js"), exports);
+__exportStar(require("./parsers/parseAnyOf.js"), exports);
+__exportStar(require("./parsers/parseArray.js"), exports);
+__exportStar(require("./parsers/parseBoolean.js"), exports);
+__exportStar(require("./parsers/parseConst.js"), exports);
+__exportStar(require("./parsers/parseDefault.js"), exports);
+__exportStar(require("./parsers/parseEnum.js"), exports);
+__exportStar(require("./parsers/parseIfThenElse.js"), exports);
+__exportStar(require("./parsers/parseMultipleType.js"), exports);
+__exportStar(require("./parsers/parseNot.js"), exports);
+__exportStar(require("./parsers/parseNull.js"), exports);
+__exportStar(require("./parsers/parseNullable.js"), exports);
+__exportStar(require("./parsers/parseNumber.js"), exports);
+__exportStar(require("./parsers/parseObject.js"), exports);
+__exportStar(require("./parsers/parseOneOf.js"), exports);
+__exportStar(require("./parsers/parseSchema.js"), exports);
+__exportStar(require("./parsers/parseSimpleDiscriminatedOneOf.js"), exports);
+__exportStar(require("./parsers/parseString.js"), exports);
+__exportStar(require("./utils/anyOrUnknown.js"), exports);
+__exportStar(require("./utils/cycles.js"), exports);
+__exportStar(require("./utils/half.js"), exports);
+__exportStar(require("./utils/jsdocs.js"), exports);
+__exportStar(require("./utils/omit.js"), exports);
+__exportStar(require("./utils/withMessage.js"), exports);
+__exportStar(require("./zodToJsonSchema.js"), exports);
+const jsonSchemaToZod_js_1 = require("./jsonSchemaToZod.js");
+exports.default = jsonSchemaToZod_js_1.jsonSchemaToZod;