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

package/dist/{esm/generators → generators}/generateBundle.js

@@ -1,36 +1,50 @@
 import { analyzeSchema } from "../core/analyzeSchema.js";
 import { emitZod } from "../core/emitZod.js";
+import { liftInlineObjects } from "../utils/liftInlineObjects.js";
 export const generateSchemaBundle = (schema, options = {}) => {
-    const module = options.module ?? "esm";
     if (!schema || typeof schema !== "object") {
         throw new Error("generateSchemaBundle requires an object schema");
     }
-    const defs = schema.$defs || {};
-    const definitions = schema.definitions || {};
+    const liftOpts = options.liftInlineObjects ?? {};
+    const useLift = liftOpts.enable !== false;
+    const liftedSchema = useLift
+        ? liftInlineObjects(schema, {
+            enable: true,
+            nameForPath: liftOpts.nameForPath,
+            parentName: options.splitDefs?.rootTypeName ?? options.splitDefs?.rootName ?? schema.title,
+            dedup: liftOpts.dedup === true,
+            allowInDefs: liftOpts.allowInDefs,
+        }).schema
+        : schema;
+    const defs = liftedSchema.$defs || {};
+    const definitions = liftedSchema.definitions || {};
     const defNames = Object.keys(defs);
     const { rootName, rootTypeName, defInfoMap } = buildBundleContext(defNames, defs, options);
     const files = [];
-    const targets = planBundleTargets(schema, defs, definitions, defNames, options, rootName, rootTypeName);
+    const targets = planBundleTargets(liftedSchema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName);
     for (const target of targets) {
         const usedRefs = target.usedRefs;
-        const analysis = analyzeSchema(target.schemaWithDefs, {
-            ...options,
-            module,
-            name: target.schemaName,
-            type: target.typeName,
-            parserOverride: createRefHandler(target.defName, defInfoMap, usedRefs, {
-                ...(target.schemaWithDefs.$defs || {}),
-                ...(target.schemaWithDefs.definitions || {}),
-            }, options),
-        });
-        const zodSchema = emitZod(analysis);
-        const finalSchema = buildSchemaFile(zodSchema, usedRefs, defInfoMap, module);
+        const zodParts = [];
+        for (const member of target.members) {
+            const analysis = analyzeSchema(member.schemaWithDefs, {
+                ...options,
+                name: member.schemaName,
+                type: member.typeName,
+                parserOverride: createRefHandler(member.defName, defInfoMap, usedRefs, {
+                    ...(member.schemaWithDefs.$defs || {}),
+                    ...(member.schemaWithDefs.definitions || {}),
+                }, options, target.groupId),
+            });
+            const zodSchema = emitZod(analysis);
+            zodParts.push(zodSchema);
+        }
+        const finalSchema = buildSchemaFile(zodParts, usedRefs, defInfoMap);
         files.push({ fileName: target.fileName, contents: finalSchema });
     }
     // Nested types extraction (optional)
     const nestedTypesEnabled = options.nestedTypes?.enable;
     if (nestedTypesEnabled) {
-        const nestedTypes = collectNestedTypes(schema, defs, defNames, rootTypeName ?? rootName);
+        const nestedTypes = collectNestedTypes(liftedSchema, defs, defNames, rootTypeName ?? rootName);
         if (nestedTypes.length > 0) {
             const nestedFileName = options.nestedTypes?.fileName ?? "nested-types.ts";
             const nestedContent = generateNestedTypesFile(nestedTypes);
@@ -53,13 +67,16 @@ const buildDefInfoMap = (defNames, defs, options) => {
         const pascalName = toPascalCase(defName);
         const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
         const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
+        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
         map.set(defName, {
             name: defName,
             pascalName,
             schemaName,
             typeName,
+            fileName,
             dependencies,
             hasCycle: false,
+            groupId: "",
         });
     }
     return map;
@@ -72,13 +89,21 @@ const buildBundleContext = (defNames, defs, options) => {
         if (info)
             info.hasCycle = true;
     }
+    const groups = buildSccGroups(defInfoMap);
+    for (const [groupId, members] of groups) {
+        for (const defName of members) {
+            const info = defInfoMap.get(defName);
+            if (info)
+                info.groupId = groupId;
+        }
+    }
     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);
-    return { defInfoMap, rootName, rootTypeName };
+    return { defInfoMap, rootName, rootTypeName, groups };
 };
-const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options) => {
+const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options, currentGroupId) => {
     const useLazyCrossRefs = options.refResolution?.lazyCrossRefs ?? true;
     return (schema, refs) => {
         if (typeof schema["$ref"] === "string") {
@@ -93,7 +118,7 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                 const refInfo = defInfoMap.get(refName);
                 if (refInfo) {
                     // Track imports when referencing other defs
-                    if (refName !== currentDefName) {
+                    if (refName !== currentDefName && refInfo.groupId !== currentGroupId) {
                         usedRefs.add(refName);
                     }
                     const isCycle = refName === currentDefName || (refInfo.hasCycle && !!currentDefName);
@@ -107,7 +132,14 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                     if (resolved)
                         return resolved;
                     if (isCycle && useLazyCrossRefs) {
-                        return `z.lazy(() => ${refInfo.schemaName})`;
+                        const inObjectProperty = refs.path.includes("properties") ||
+                            refs.path.includes("patternProperties") ||
+                            refs.path.includes("additionalProperties");
+                        if (inObjectProperty && refName === currentDefName) {
+                            // Self-recursion inside object getters can safely reference the schema name
+                            return refInfo.schemaName;
+                        }
+                        return `z.lazy<typeof ${refInfo.schemaName}>(() => ${refInfo.schemaName})`;
                     }
                     return refInfo.schemaName;
                 }
@@ -125,42 +157,72 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
         return undefined;
     };
 };
-const buildSchemaFile = (zodCode, usedRefs, defInfoMap, module) => {
-    if (module !== "esm")
-        return zodCode;
-    const imports = [];
+const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap) => {
+    const groupFileById = new Map();
+    for (const info of defInfoMap.values()) {
+        if (!groupFileById.has(info.groupId)) {
+            groupFileById.set(info.groupId, info.fileName.replace(/\.ts$/, ".js"));
+        }
+    }
+    const importsByFile = new Map();
     for (const refName of [...usedRefs].sort()) {
         const refInfo = defInfoMap.get(refName);
         if (refInfo) {
-            imports.push(`import { ${refInfo.schemaName} } from './${refName}.schema.js';`);
+            const groupFile = groupFileById.get(refInfo.groupId) ?? refInfo.fileName.replace(/\.ts$/, ".js");
+            const path = `./${groupFile}`;
+            const set = importsByFile.get(path) ?? new Set();
+            set.add(refInfo.schemaName);
+            importsByFile.set(path, set);
         }
     }
-    if (!imports.length)
-        return zodCode;
-    return zodCode.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`);
+    const imports = [];
+    for (const [path, names] of [...importsByFile.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        imports.push(`import { ${[...names].sort().join(", ")} } from '${path}';`);
+    }
+    const body = zodCodeParts
+        .map((code, idx) => {
+        if (idx === 0)
+            return code;
+        return code.replace(/^import \{ z \} from "zod"\n?/, "");
+    })
+        .join("\n");
+    const withImports = imports.length
+        ? body.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`)
+        : body;
+    return withImports;
 };
-const planBundleTargets = (rootSchema, defs, definitions, defNames, options, rootName, rootTypeName) => {
+const planBundleTargets = (rootSchema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName) => {
     const targets = [];
+    const groupById = new Map();
     for (const defName of defNames) {
-        const defSchema = defs[defName];
-        const defSchemaWithDefs = {
-            ...defSchema,
-            $defs: { ...defs, ...defSchema?.$defs },
-            definitions: {
-                ...defSchema.definitions,
-                ...definitions,
-            },
-        };
-        const pascalName = toPascalCase(defName);
-        const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
-        const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
-        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
+        const info = defInfoMap.get(defName);
+        const gid = info?.groupId || defName;
+        if (!groupById.has(gid))
+            groupById.set(gid, []);
+        groupById.get(gid).push(defName);
+    }
+    for (const [groupId, memberDefs] of groupById.entries()) {
+        const orderedDefs = orderGroupMembers(memberDefs, defInfoMap);
+        const members = orderedDefs.map((defName) => {
+            const defSchema = defs[defName];
+            const defSchemaWithDefs = {
+                ...defSchema,
+                $defs: { ...defs, ...defSchema?.$defs },
+                definitions: {
+                    ...defSchema.definitions,
+                    ...definitions,
+                },
+            };
+            const pascalName = toPascalCase(defName);
+            const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
+            const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
+            return { defName, schemaWithDefs: defSchemaWithDefs, schemaName, typeName };
+        });
+        const fileName = defInfoMap.get(memberDefs[0])?.fileName ?? `${memberDefs[0]}.schema.ts`;
         targets.push({
-            defName,
-            schemaWithDefs: defSchemaWithDefs,
-            schemaName,
-            typeName,
+            groupId,
             fileName,
+            members,
             usedRefs: new Set(),
             isRoot: false,
         });
@@ -168,17 +230,22 @@ const planBundleTargets = (rootSchema, defs, definitions, defNames, options, roo
     if (options.splitDefs?.includeRoot ?? true) {
         const rootFile = options.splitDefs?.fileName?.("root", { isRoot: true }) ?? "workflow.schema.ts";
         targets.push({
-            defName: null,
-            schemaWithDefs: {
-                ...rootSchema,
-                definitions: {
-                    ...rootSchema.definitions,
-                    ...definitions,
-                },
-            },
-            schemaName: rootName,
-            typeName: rootTypeName,
+            groupId: "root",
             fileName: rootFile,
+            members: [
+                {
+                    defName: null,
+                    schemaWithDefs: {
+                        ...rootSchema,
+                        definitions: {
+                            ...rootSchema.definitions,
+                            ...definitions,
+                        },
+                    },
+                    schemaName: rootName,
+                    typeName: rootTypeName,
+                },
+            ],
             usedRefs: new Set(),
             isRoot: true,
         });
@@ -187,9 +254,13 @@ const planBundleTargets = (rootSchema, defs, definitions, defNames, options, roo
 };
 const findRefDependencies = (schema, validDefNames) => {
     const deps = new Set();
+    const seen = new WeakSet();
     function traverse(obj) {
         if (obj === null || typeof obj !== "object")
             return;
+        if (seen.has(obj))
+            return;
+        seen.add(obj);
         if (Array.isArray(obj)) {
             obj.forEach(traverse);
             return;
@@ -209,6 +280,35 @@ const findRefDependencies = (schema, validDefNames) => {
     traverse(schema);
     return deps;
 };
+const orderGroupMembers = (defs, defInfoMap) => {
+    const inGroup = new Set(defs);
+    const visited = new Set();
+    const temp = new Set();
+    const result = [];
+    const visit = (name) => {
+        if (visited.has(name))
+            return;
+        if (temp.has(name)) {
+            return;
+        }
+        temp.add(name);
+        const info = defInfoMap.get(name);
+        if (info) {
+            for (const dep of info.dependencies) {
+                if (inGroup.has(dep)) {
+                    visit(dep);
+                }
+            }
+        }
+        temp.delete(name);
+        visited.add(name);
+        result.push(name);
+    };
+    for (const name of defs) {
+        visit(name);
+    }
+    return result;
+};
 const detectCycles = (defInfoMap) => {
     const cycleNodes = new Set();
     const visited = new Set();
@@ -242,6 +342,52 @@ const detectCycles = (defInfoMap) => {
     }
     return cycleNodes;
 };
+const buildSccGroups = (defInfoMap) => {
+    const indexMap = new Map();
+    const lowLink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    let index = 0;
+    const groups = new Map();
+    const strongConnect = (node) => {
+        indexMap.set(node, index);
+        lowLink.set(node, index);
+        index += 1;
+        stack.push(node);
+        onStack.add(node);
+        const info = defInfoMap.get(node);
+        if (info) {
+            for (const dep of info.dependencies) {
+                if (!indexMap.has(dep)) {
+                    strongConnect(dep);
+                    lowLink.set(node, Math.min(lowLink.get(node), lowLink.get(dep)));
+                }
+                else if (onStack.has(dep)) {
+                    lowLink.set(node, Math.min(lowLink.get(node), indexMap.get(dep)));
+                }
+            }
+        }
+        if (lowLink.get(node) === indexMap.get(node)) {
+            const members = [];
+            let w;
+            do {
+                w = stack.pop();
+                if (w) {
+                    onStack.delete(w);
+                    members.push(w);
+                }
+            } while (w && w !== node);
+            const groupId = members.sort().join("__");
+            groups.set(groupId, members);
+        }
+    };
+    for (const name of defInfoMap.keys()) {
+        if (!indexMap.has(name)) {
+            strongConnect(name);
+        }
+    }
+    return groups;
+};
 const collectNestedTypes = (rootSchema, defs, defNames, rootTypeName) => {
     const allNestedTypes = [];
     for (const defName of defNames) {
@@ -317,6 +463,26 @@ const generateNestedTypesFile = (nestedTypes) => {
         " * They are extracted using TypeScript indexed access types.",
         " */",
         "",
+        "type Access<T, P extends readonly (string | number)[]> =",
+        "  P extends []",
+        "    ? NonNullable<T>",
+        "    : P extends readonly [infer H, ...infer R]",
+        "      ? H extends \"items\"",
+        "        ? Access<NonNullable<T> extends Array<infer U> ? U : unknown, Extract<R, (string | number)[]>>",
+        "        : H extends \"additionalProperties\"",
+        "          ? Access<NonNullable<T> extends Record<string, infer V> ? V : unknown, Extract<R, (string | number)[]>>",
+        "          : H extends number",
+        "            ? Access<NonNullable<T> extends Array<infer U> ? U : unknown, Extract<R, (string | number)[]>>",
+        "            : H extends string",
+        "              ? Access<",
+        "                  H extends keyof NonNullable<T>",
+        "                    ? NonNullable<NonNullable<T>[H]>",
+        "                    : unknown,",
+        "                  Extract<R, (string | number)[]>",
+        "                >",
+        "              : unknown",
+        "      : unknown;",
+        "",
     ];
     const byParent = new Map();
     for (const info of nestedTypes) {
@@ -336,16 +502,8 @@ const generateNestedTypesFile = (nestedTypes) => {
     }
     lines.push("");
     const buildAccessExpr = (parentType, propertyPath) => {
-        let accessExpr = parentType;
-        for (const prop of propertyPath) {
-            const accessor = prop === "items"
-                ? "[number]"
-                : typeof prop === "number"
-                    ? `[${prop}]`
-                    : `[${JSON.stringify(prop)}]`;
-            accessExpr = `NonNullable<${accessExpr}${accessor}>`;
-        }
-        return accessExpr;
+        const path = propertyPath.map((prop) => (typeof prop === "number" ? prop : JSON.stringify(prop))).join(", ");
+        return `Access<${parentType}, [${path}]>`;
     };
     for (const [parentType, types] of [...byParent.entries()].sort()) {
         lines.push(`// From ${parentType}`);

package/dist/{esm/index.js → index.js}

@@ -24,10 +24,16 @@ export * from "./parsers/parseString.js";
 export * from "./utils/anyOrUnknown.js";
 export * from "./utils/buildRefRegistry.js";
 export * from "./utils/cycles.js";
+export * from "./utils/esmEmitter.js";
+export * from "./utils/extractInlineObject.js";
 export * from "./utils/half.js";
 export * from "./utils/jsdocs.js";
+export * from "./utils/liftInlineObjects.js";
+export * from "./utils/namingService.js";
 export * from "./utils/omit.js";
+export * from "./utils/resolveRef.js";
 export * from "./utils/resolveUri.js";
+export * from "./utils/schemaRepresentation.js";
 export * from "./utils/withMessage.js";
 export * from "./zodToJsonSchema.js";
 import { jsonSchemaToZod } from "./jsonSchemaToZod.js";

package/dist/jsonSchemaToZod.js

@@ -0,0 +1,17 @@
+import { analyzeSchema } from "./core/analyzeSchema.js";
+import { emitZod } from "./core/emitZod.js";
+import { liftInlineObjects } from "./utils/liftInlineObjects.js";
+export const jsonSchemaToZod = (schema, options = {}) => {
+    const liftOpts = options.liftInlineObjects ?? {};
+    const sourceSchema = liftOpts.enable !== false
+        ? liftInlineObjects(schema, {
+            enable: true,
+            nameForPath: liftOpts.nameForPath,
+            parentName: options.name,
+            dedup: liftOpts.dedup === true,
+            allowInDefs: liftOpts.allowInDefs,
+        }).schema
+        : schema;
+    const analysis = analyzeSchema(sourceSchema, options);
+    return emitZod(analysis);
+};

package/dist/parsers/parseAllOf.js

@@ -0,0 +1,125 @@
+import { parseSchema } from "./parseSchema.js";
+import { half } from "../utils/half.js";
+const originalIndexKey = "__originalIndex";
+/**
+ * Check if a schema defines object properties (inline object shape) without any refs.
+ */
+const isInlineObjectOnly = (schema) => {
+    if (typeof schema !== "object" || schema === null)
+        return false;
+    const obj = schema;
+    // Must have properties
+    if (!obj.properties || Object.keys(obj.properties).length === 0)
+        return false;
+    // Must NOT have $ref or $dynamicRef (can't use spread with refs)
+    if (obj.$ref || obj.$dynamicRef)
+        return false;
+    return true;
+};
+/**
+ * Parse just the shape entries from an object schema (without z.object wrapper).
+ * Returns array of "key: expression" strings for spreading.
+ */
+const parseObjectShape = (schema, refs, pathPrefix) => {
+    const shapeEntries = [];
+    const shapeTypes = [];
+    for (const key of Object.keys(schema.properties)) {
+        const propSchema = schema.properties[key];
+        const parsedProp = parseSchema(propSchema, {
+            ...refs,
+            path: [...pathPrefix, "properties", key],
+        });
+        const hasDefault = typeof propSchema === "object" && propSchema.default !== undefined;
+        const required = Array.isArray(schema.required)
+            ? schema.required.includes(key)
+            : typeof propSchema === "object" && propSchema.required === true;
+        const optional = !hasDefault && !required;
+        const valueExpr = optional
+            ? `${parsedProp.expression}.optional()`
+            : parsedProp.expression;
+        const valueType = optional
+            ? `z.ZodOptional<${parsedProp.type}>`
+            : parsedProp.type;
+        shapeEntries.push(`${JSON.stringify(key)}: ${valueExpr}`);
+        shapeTypes.push(`${JSON.stringify(key)}: ${valueType}`);
+    }
+    return { shapeEntries, shapeTypes };
+};
+/**
+ * Check if all allOf members can be combined using spread syntax.
+ * Only works when ALL members are inline objects (no $refs).
+ * Returns the merged object if possible, undefined otherwise.
+ */
+const trySpreadPattern = (allOfMembers, refs) => {
+    const shapeEntries = [];
+    const shapeTypes = [];
+    for (let i = 0; i < allOfMembers.length; i++) {
+        const member = allOfMembers[i];
+        const idx = member[originalIndexKey] ?? i;
+        // Only handle pure inline objects - no refs allowed
+        if (!isInlineObjectOnly(member)) {
+            return undefined;
+        }
+        // Extract shape entries from inline object
+        const { shapeEntries: entries, shapeTypes: types } = parseObjectShape(member, refs, [...refs.path, "allOf", idx]);
+        shapeEntries.push(...entries);
+        shapeTypes.push(...types);
+    }
+    if (shapeEntries.length === 0)
+        return undefined;
+    return {
+        expression: `z.object({ ${shapeEntries.join(", ")} })`,
+        type: `z.ZodObject<{ ${shapeTypes.join(", ")} }>`,
+    };
+};
+const ensureOriginalIndex = (arr) => {
+    const newArr = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item === "boolean") {
+            newArr.push(item ? { [originalIndexKey]: i } : { [originalIndexKey]: i, not: {} });
+        }
+        else if (typeof item === "object" &&
+            item !== null &&
+            originalIndexKey in item) {
+            return arr;
+        }
+        else {
+            newArr.push({ ...item, [originalIndexKey]: i });
+        }
+    }
+    return newArr;
+};
+export function parseAllOf(schema, refs) {
+    if (schema.allOf.length === 0) {
+        return { expression: "z.never()", type: "z.ZodNever" };
+    }
+    else if (schema.allOf.length === 1) {
+        const item = schema.allOf[0];
+        return parseSchema(item, {
+            ...refs,
+            path: [
+                ...refs.path,
+                "allOf",
+                item[originalIndexKey] ?? 0,
+            ],
+        });
+    }
+    else {
+        // Try spread pattern first (more efficient than intersection)
+        // This works when all members are either $refs to object schemas or inline objects
+        const indexed = ensureOriginalIndex(schema.allOf);
+        const spreadResult = trySpreadPattern(indexed, refs);
+        if (spreadResult) {
+            return spreadResult;
+        }
+        // Fallback to intersection-based approach
+        const [left, right] = half(indexed);
+        const leftResult = parseAllOf({ allOf: left }, refs);
+        const rightResult = parseAllOf({ allOf: right }, refs);
+        return {
+            expression: `z.intersection(${leftResult.expression}, ${rightResult.expression})`,
+            type: `z.ZodIntersection<${leftResult.type}, ${rightResult.type}>`,
+        };
+    }
+}

package/dist/parsers/parseAnyOf.js

@@ -0,0 +1,28 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { extractInlineObject } from "../utils/extractInlineObject.js";
+export const parseAnyOf = (schema, refs) => {
+    if (!schema.anyOf.length) {
+        return anyOrUnknown(refs);
+    }
+    if (schema.anyOf.length === 1) {
+        return parseSchema(schema.anyOf[0], {
+            ...refs,
+            path: [...refs.path, "anyOf", 0],
+        });
+    }
+    // Rule 1: Extract inline objects to top-level declarations
+    const members = schema.anyOf.map((memberSchema, i) => {
+        const extracted = extractInlineObject(memberSchema, refs, [...refs.path, "anyOf", i]);
+        if (extracted) {
+            return { expression: extracted, type: `typeof ${extracted}` };
+        }
+        return parseSchema(memberSchema, { ...refs, path: [...refs.path, "anyOf", i] });
+    });
+    const expressions = members.map(m => m.expression).join(", ");
+    const types = members.map(m => m.type).join(", ");
+    const expression = `z.union([${expressions}])`;
+    // Use readonly tuple for union type annotations (required for recursive type inference)
+    const type = `z.ZodUnion<readonly [${types}]>`;
+    return { expression, type };
+};