@gabrielbryk/json-schema-to-zod 2.10.1 → 2.11.1

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 };
+};

package/dist/{esm/parsers → parsers}/parseArray.js

@@ -3,16 +3,20 @@ import { parseSchema } from "./parseSchema.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
 export const parseArray = (schema, refs) => {
     if (Array.isArray(schema.items)) {
-        let tuple = `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
+        // Tuple case
+        const itemResults = schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }));
+        let tuple = `z.tuple([${itemResults.map(r => r.expression).join(", ")}])`;
+        const tupleTypes = itemResults.map(r => r.type).join(", ");
+        let tupleType = `z.ZodTuple<[${tupleTypes}]>`;
         if (schema.contains) {
-            const containsSchema = parseSchema(schema.contains, {
+            const containsResult = parseSchema(schema.contains, {
                 ...refs,
                 path: [...refs.path, "contains"],
             });
             const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
             const maxContains = schema.maxContains;
             tuple += `.superRefine((arr, ctx) => {
-  const matches = arr.filter((item) => ${containsSchema}.safeParse(item).success).length;
+  const matches = arr.filter((item) => ${containsResult.expression}.safeParse(item).success).length;
   if (${minContains ?? 0} && matches < ${minContains ?? 0}) {
     ctx.addIssue({ code: "custom", message: "Array contains too few matching items" });
   }
@@ -20,15 +24,23 @@ export const parseArray = (schema, refs) => {
     ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
   }
 })`;
+            // In Zod v4, .superRefine() doesn't change the type
         }
-        return tuple;
+        return {
+            expression: tuple,
+            type: tupleType,
+        };
     }
-    let r = !schema.items
-        ? `z.array(${anyOrUnknown(refs)})`
-        : `z.array(${parseSchema(schema.items, {
+    // Array case
+    const anyOrUnknownResult = anyOrUnknown(refs);
+    const itemResult = !schema.items
+        ? anyOrUnknownResult
+        : parseSchema(schema.items, {
             ...refs,
             path: [...refs.path, "items"],
-        })})`;
+        });
+    let r = `z.array(${itemResult.expression})`;
+    let arrayType = `z.ZodArray<${itemResult.type}>`;
     r += withMessage(schema, "minItems", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
@@ -66,14 +78,14 @@ export const parseArray = (schema, refs) => {
 })`;
     }
     if (schema.contains) {
-        const containsSchema = parseSchema(schema.contains, {
+        const containsResult = parseSchema(schema.contains, {
             ...refs,
             path: [...refs.path, "contains"],
         });
         const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
         const maxContains = schema.maxContains;
         r += `.superRefine((arr, ctx) => {
-  const matches = arr.filter((item) => ${containsSchema}.safeParse(item).success).length;
+  const matches = arr.filter((item) => ${containsResult.expression}.safeParse(item).success).length;
   if (${minContains ?? 0} && matches < ${minContains ?? 0}) {
     ctx.addIssue({ code: "custom", message: "Array contains too few matching items" });
   }
@@ -82,5 +94,9 @@ export const parseArray = (schema, refs) => {
   }
 })`;
     }
-    return r;
+    // In Zod v4, .superRefine() doesn't change the type, so no wrapping needed
+    return {
+        expression: r,
+        type: arrayType,
+    };
 };

package/dist/parsers/parseBoolean.js

@@ -0,0 +1,4 @@
+export const parseBoolean = () => ({
+    expression: "z.boolean()",
+    type: "z.ZodBoolean",
+});

package/dist/parsers/parseConst.js

@@ -0,0 +1,22 @@
+export const parseConst = (schema) => {
+    const value = schema.const;
+    const expression = `z.literal(${JSON.stringify(value)})`;
+    // Determine the literal type based on the value type
+    let type;
+    if (typeof value === "string") {
+        type = `z.ZodLiteral<${JSON.stringify(value)}>`;
+    }
+    else if (typeof value === "number") {
+        type = `z.ZodLiteral<${value}>`;
+    }
+    else if (typeof value === "boolean") {
+        type = `z.ZodLiteral<${value}>`;
+    }
+    else if (value === null) {
+        type = "z.ZodLiteral<null>";
+    }
+    else {
+        type = "z.ZodLiteral<unknown>";
+    }
+    return { expression, type };
+};

package/dist/parsers/parseEnum.js

@@ -0,0 +1,35 @@
+export const parseEnum = (schema) => {
+    if (schema.enum.length === 0) {
+        return {
+            expression: "z.never()",
+            type: "z.ZodNever",
+        };
+    }
+    else if (schema.enum.length === 1) {
+        // union does not work when there is only one element
+        const value = schema.enum[0];
+        return {
+            expression: `z.literal(${JSON.stringify(value)})`,
+            type: `z.ZodLiteral<${typeof value === "string" ? JSON.stringify(value) : value}>`,
+        };
+    }
+    else if (schema.enum.every((x) => typeof x === "string")) {
+        const values = schema.enum;
+        // Zod v4 ZodEnum uses object format: { key: "key"; ... }
+        const enumObject = values.map((x) => `${JSON.stringify(x)}: ${JSON.stringify(x)}`).join("; ");
+        return {
+            expression: `z.enum([${values.map((x) => JSON.stringify(x))}])`,
+            type: `z.ZodEnum<{ ${enumObject} }>`,
+        };
+    }
+    else {
+        // Mixed types: create union of literals
+        const literalTypes = schema.enum.map((x) => typeof x === "string" ? JSON.stringify(x) : x === null ? "null" : String(x));
+        return {
+            expression: `z.union([${schema.enum
+                .map((x) => `z.literal(${JSON.stringify(x)})`)
+                .join(", ")}])`,
+            type: `z.ZodUnion<[${literalTypes.map((t) => `z.ZodLiteral<${t}>`).join(", ")}]>`,
+        };
+    }
+};

package/dist/{esm/parsers → parsers}/parseIfThenElse.js

@@ -9,10 +9,10 @@ export const parseIfThenElse = (schema, refs) => {
         ...refs,
         path: [...refs.path, "else"],
     });
-    let result = `z.union([${$then}, ${$else}]).superRefine((value,ctx) => {
-  const result = ${$if}.safeParse(value).success
-    ? ${$then}.safeParse(value)
-    : ${$else}.safeParse(value);
+    let expression = `z.union([${$then.expression}, ${$else.expression}]).superRefine((value,ctx) => {
+  const result = ${$if.expression}.safeParse(value).success
+    ? ${$then.expression}.safeParse(value)
+    : ${$else.expression}.safeParse(value);
   if (!result.success) {
     const issues = result.error.issues;
     issues.forEach((issue) => ctx.addIssue({ ...issue }))
@@ -25,7 +25,11 @@ export const parseIfThenElse = (schema, refs) => {
             then: schema.then,
             else: schema.else,
         });
-        result += `.meta({ __jsonSchema: { conditional: ${conditionalMeta} } })`;
+        expression += `.meta({ __jsonSchema: { conditional: ${conditionalMeta} } })`;
     }
-    return result;
+    return {
+        expression,
+        // In Zod v4, .superRefine() doesn't change the type
+        type: `z.ZodUnion<[${$then.type}, ${$else.type}]>`,
+    };
 };

package/dist/parsers/parseMultipleType.js

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

package/dist/parsers/parseNot.js

@@ -0,0 +1,14 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseNot = (schema, refs) => {
+    const baseSchema = anyOrUnknown(refs);
+    const notSchema = parseSchema(schema.not, {
+        ...refs,
+        path: [...refs.path, "not"],
+    });
+    return {
+        expression: `${baseSchema.expression}.refine((value) => !${notSchema.expression}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`,
+        // In Zod v4, .refine() doesn't change the type
+        type: baseSchema.type,
+    };
+};

package/dist/parsers/parseNull.js

@@ -0,0 +1,4 @@
+export const parseNull = () => ({
+    expression: "z.null()",
+    type: "z.ZodNull",
+});

package/dist/parsers/parseNullable.js

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

package/dist/{esm/parsers → parsers}/parseNumber.js

@@ -108,5 +108,8 @@ export const parseNumber = (schema) => {
             messageCloser: " })",
         }));
     }
-    return r;
+    return {
+        expression: r,
+        type: "z.ZodNumber",
+    };
 };