@gabrielbryk/json-schema-to-zod 2.14.1 → 2.15.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @gabrielbryk/json-schema-to-zod
 
+## 2.15.0
+
+### Minor Changes
+
+- e25f255: Add configurable strategy for recursive oneOf handling, defaulting to union for recursive catchall cases to avoid Zod xor+lazy validation bugs. Also add serverless workflow e2e validation coverage.
+
+## 2.14.2
+
+### Patch Changes
+
+- b4460e4: Restore getter-based recursion for named properties to preserve inferred types in recursive schemas.
+
 ## 2.14.1
 
 ### Patch Changes

package/dist/core/emitZod.js

@@ -1,86 +1,63 @@
 import { parseSchema } from "../parsers/parseSchema.js";
 import { expandJsdocs } from "../utils/jsdocs.js";
-import { inferTypeFromExpression } from "../utils/schemaRepresentation.js";
+import { collectRefNames, emitExpression, emitType, nodeHasGetter, nodeHasLazy, } from "../utils/schemaRepresentation.js";
 import { EsmEmitter } from "../utils/esmEmitter.js";
 import { resolveTypeName } from "../utils/schemaNaming.js";
-/**
- * Split a z.object({...}).method1().method2() expression into base and method chain.
- * This is needed for Rule 2: Don't chain methods on recursive types.
- *
- * Only splits if the TOP-LEVEL z.object() contains a getter (not nested ones in .and() etc.)
- */
-const splitObjectMethodChain = (expr) => {
-    if (!expr.startsWith("z.object(")) {
-        return { base: expr, methodChain: null };
-    }
-    // Find the matching closing brace for z.object({
-    let depth = 1;
-    let i = 9; // length of "z.object("
-    // Find the opening { of the object literal
-    while (i < expr.length && expr[i] !== "{") {
-        i++;
-    }
-    if (i >= expr.length) {
-        return { base: expr, methodChain: null };
-    }
-    const objectLiteralStart = i;
-    i++; // move past the {
-    // Find the matching }
-    while (i < expr.length && depth > 0) {
-        const char = expr[i];
-        if (char === "{" || char === "(" || char === "[") {
-            depth++;
-        }
-        else if (char === "}" || char === ")" || char === "]") {
-            depth--;
-        }
-        i++;
-    }
-    const objectLiteralEnd = i - 1; // position of closing }
-    // Extract just the top-level object literal content
-    const objectLiteralContent = expr.substring(objectLiteralStart, objectLiteralEnd + 1);
-    // Check if the TOP-LEVEL object has a getter (not nested ones)
-    // A getter in the top-level object would appear as "get " at depth 1
-    if (!hasTopLevelGetter(objectLiteralContent)) {
-        return { base: expr, methodChain: null };
-    }
-    // Now find the closing ) for z.object(
-    while (i < expr.length && expr[i] !== ")") {
-        i++;
-    }
-    if (i >= expr.length) {
-        return { base: expr, methodChain: null };
-    }
-    i++; // move past the )
-    // Everything after is the method chain
-    const base = expr.substring(0, i);
-    const methodChain = expr.substring(i);
-    // Only return a method chain if there actually is one (like .strict() or .meta())
-    // Don't split if the method chain is .and() since that's adding more schema, not metadata
-    if (!methodChain || methodChain.length === 0 || methodChain.startsWith(".and(")) {
-        return { base: expr, methodChain: null };
-    }
-    return { base, methodChain };
-};
-/**
- * Check if an object literal has a getter at its top level (not nested).
- */
-const hasTopLevelGetter = (objectLiteral) => {
-    let depth = 0;
-    for (let i = 0; i < objectLiteral.length - 4; i++) {
-        const char = objectLiteral[i];
-        if (char === "{" || char === "(" || char === "[") {
-            depth++;
-        }
-        else if (char === "}" || char === ")" || char === "]") {
-            depth--;
-        }
-        else if (depth === 1 && objectLiteral.substring(i, i + 4) === "get ") {
-            // Found "get " at depth 1 (inside the top-level object, not nested)
-            return true;
+const splitObjectMethodChain = (node) => {
+    const chain = [];
+    let current = node;
+    while (current) {
+        switch (current.kind) {
+            case "object":
+                return {
+                    base: current,
+                    methodChain: chain.length ? chain.reverse().join("") : null,
+                };
+            case "readonly":
+                chain.push(".readonly()");
+                current = current.inner;
+                break;
+            case "describe":
+                chain.push(`.describe(${JSON.stringify(current.description)})`);
+                current = current.inner;
+                break;
+            case "meta":
+                chain.push(`.meta(${current.meta})`);
+                current = current.inner;
+                break;
+            case "default":
+                chain.push(`.default(${JSON.stringify(current.value)})`);
+                current = current.inner;
+                break;
+            case "catchall":
+                chain.push(`.catchall(${emitExpression(current.catchall)})`);
+                current = current.base;
+                break;
+            case "superRefine":
+                chain.push(`.superRefine(${current.refine})`);
+                current = current.base;
+                break;
+            case "refine":
+                chain.push(`.refine(${current.refine})`);
+                current = current.base;
+                break;
+            case "transform":
+                chain.push(`.transform(${current.transform})`);
+                current = current.base;
+                break;
+            case "pipe":
+                chain.push(`.pipe(${emitExpression(current.second)}${current.params ?? ""})`);
+                current = current.first;
+                break;
+            case "chain":
+                chain.push(`.${current.method}`);
+                current = current.base;
+                break;
+            default:
+                return { base: node, methodChain: null };
         }
     }
-    return false;
+    return { base: node, methodChain: null };
 };
 const orderDeclarations = (entries, dependencies) => {
     const repByName = new Map(entries);
@@ -101,16 +78,18 @@ const orderDeclarations = (entries, dependencies) => {
         onlyKnown.forEach((d) => current.add(d));
         depGraph.set(from, current);
     }
-    // Add regex-detected dependencies from expressions
+    // Add dependencies from IR
     const names = Array.from(repByName.keys());
     for (const [name, rep] 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(rep.expression)) {
-                deps.add(candidate);
+        if (!rep.node) {
+            throw new Error(`Missing IR node for ${name} (no-fallback mode).`);
+        }
+        const node = rep.node;
+        const refs = collectRefNames(node);
+        for (const refName of refs) {
+            if (refName !== name && repByName.has(refName)) {
+                deps.add(refName);
             }
         }
         depGraph.set(name, deps);
@@ -196,44 +175,45 @@ export const emitZod = (analysis) => {
     }
     if (declarations.size) {
         for (const [refName, rep] of orderDeclarations(Array.from(declarations.entries()), dependencies)) {
-            const expression = typeof rep === "string" ? rep : rep.expression;
-            if (typeof expression !== "string") {
-                throw new Error(`Expected declaration expression for ${refName}`);
+            if (!rep.node) {
+                throw new Error(`Missing IR node for ${refName} (no-fallback mode).`);
             }
-            const hintedType = typeof rep === "object" &&
-                rep &&
-                "type" in rep &&
-                typeof rep.type === "string"
-                ? rep.type
-                : undefined;
+            const node = rep.node;
+            const expression = emitExpression(node);
+            const hintedType = rep.type;
             const effectiveHint = hintedType === "z.ZodTypeAny" ? undefined : hintedType;
-            const hasLazy = expression.includes("z.lazy(");
-            const hasGetter = expression.includes("get ");
+            const hasLazy = nodeHasLazy(node);
+            const hasGetter = nodeHasGetter(node);
             // Check if this schema references any cycle members (recursive schemas)
             // This can cause TS7056 when TypeScript tries to serialize the expanded type
-            const referencesRecursiveSchema = Array.from(cycleRefNames).some((cycleName) => new RegExp(`\\b${cycleName}\\b`).test(expression));
+            let referencesRecursiveSchema = false;
+            const refs = collectRefNames(node);
+            for (const refName of refs) {
+                if (cycleRefNames.has(refName)) {
+                    referencesRecursiveSchema = true;
+                    break;
+                }
+            }
             // Per Zod v4 docs: type annotations should be on GETTERS for recursive types, not on const declarations.
             // TypeScript can infer the type of const declarations.
             // Exceptions that need explicit type annotation:
             // 1. z.lazy() without getters
             // 2. Any schema that references recursive schemas (to prevent TS7056)
             const needsTypeAnnotation = (hasLazy && !hasGetter) || referencesRecursiveSchema;
-            const storedType = needsTypeAnnotation
-                ? (effectiveHint ?? inferTypeFromExpression(expression))
-                : undefined;
+            const storedType = needsTypeAnnotation ? (effectiveHint ?? emitType(node)) : undefined;
             // Rule 2 from Zod v4: Don't chain methods on recursive types
             // If the schema has getters (recursive), we need to split it:
             // 1. Emit base schema as _RefName
             // 2. Emit decorated schema as RefName = _RefName.methods()
-            if (hasGetter && expression.startsWith("z.object(")) {
-                const { base, methodChain } = splitObjectMethodChain(expression);
+            if (hasGetter) {
+                const { base, methodChain } = splitObjectMethodChain(node);
                 if (methodChain) {
                     // Emit base schema (internal, not exported)
                     // No type annotation needed - type is on getters, TypeScript infers the rest
                     const baseName = `_${refName}`;
                     emitter.addConst({
                         name: baseName,
-                        expression: base,
+                        expression: emitExpression(base),
                         exported: false,
                     });
                     // Emit decorated schema (exported)

package/dist/generators/generateBundle.js

@@ -1,6 +1,8 @@
 import { analyzeSchema } from "../core/analyzeSchema.js";
 import { emitZod } from "../core/emitZod.js";
 import { liftInlineObjects } from "../utils/liftInlineObjects.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { zodLazy, zodRef } from "../utils/schemaRepresentation.js";
 export const generateSchemaBundle = (schema, options = {}) => {
     if (!schema || typeof schema !== "object") {
         throw new Error("generateSchemaBundle requires an object schema");
@@ -137,16 +139,20 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                         path: refs.path,
                         isCycle,
                     });
-                    if (resolved)
+                    if (resolved) {
+                        if (!resolved.node) {
+                            throw new Error("refResolution.onRef must return SchemaRepresentation with node (no-fallback mode).");
+                        }
                         return resolved;
+                    }
                     // Self-recursion ALWAYS needs z.lazy if not using getters
                     if (refName === currentDefName) {
-                        return `z.lazy(() => ${refInfo.schemaName})`;
+                        return zodLazy(refInfo.schemaName);
                     }
                     if (isCycle && useLazyCrossRefs) {
-                        return `z.lazy(() => ${refInfo.schemaName})`;
+                        return zodLazy(refInfo.schemaName);
                     }
-                    return refInfo.schemaName;
+                    return zodRef(refInfo.schemaName);
                 }
                 // If it's NOT exactly a top-level definition, it could be:
                 // 1. A path into a top-level definition (e.g. #/$defs/alpha/properties/foo)
@@ -159,9 +165,13 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                 ref: refPath,
                 currentDef: currentDefName,
             });
-            if (unknown)
+            if (unknown) {
+                if (!unknown.node) {
+                    throw new Error("refResolution.onUnknownRef must return SchemaRepresentation with node (no-fallback mode).");
+                }
                 return unknown;
-            return options.useUnknown ? "z.unknown()" : "z.any()";
+            }
+            return anyOrUnknown(refs);
         }
         return undefined;
     };

package/dist/index.js

@@ -39,6 +39,7 @@ export * from "./utils/resolveUri.js";
 export * from "./utils/schemaNaming.js";
 export * from "./utils/schemaRepresentation.js";
 export * from "./utils/withMessage.js";
+export * from "./utils/wrapRecursiveUnion.js";
 export * from "./zodToJsonSchema.js";
 import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
 export default jsonSchemaToZod;

package/dist/parsers/parseAllOf.js

@@ -1,5 +1,6 @@
 import { parseSchema } from "./parseSchema.js";
 import { half } from "../utils/half.js";
+import { shouldUseGetter, zodExactOptional, zodIntersection, zodLooseObject, zodNever, } from "../utils/schemaRepresentation.js";
 const originalIndexKey = "__originalIndex";
 /**
  * Check if a schema defines object properties (inline object shape) without any refs.
@@ -22,7 +23,6 @@ const isInlineObjectOnly = (schema) => {
  */
 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, {
@@ -34,12 +34,11 @@ const parseObjectShape = (schema, refs, pathPrefix) => {
             ? schema.required.includes(key)
             : typeof propSchema === "object" && propSchema.required === true;
         const optional = !hasDefault && !required;
-        const valueExpr = optional ? `${parsedProp.expression}.exactOptional()` : parsedProp.expression;
-        const valueType = optional ? `z.ZodExactOptional<${parsedProp.type}>` : parsedProp.type;
-        shapeEntries.push(`${JSON.stringify(key)}: ${valueExpr}`);
-        shapeTypes.push(`${JSON.stringify(key)}: ${valueType}`);
+        const valueRep = optional ? zodExactOptional(parsedProp) : parsedProp;
+        const isGetter = shouldUseGetter(valueRep, refs.currentSchemaName, refs.cycleRefNames, refs.cycleComponentByName);
+        shapeEntries.push({ key, rep: valueRep, isGetter });
     }
-    return { shapeEntries, shapeTypes };
+    return { shapeEntries };
 };
 /**
  * Check if all allOf members can be combined using spread syntax.
@@ -48,7 +47,6 @@ const parseObjectShape = (schema, refs, pathPrefix) => {
  */
 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;
@@ -57,20 +55,12 @@ const trySpreadPattern = (allOfMembers, refs) => {
             return undefined;
         }
         // Extract shape entries from inline object
-        const { shapeEntries: entries, shapeTypes: types } = parseObjectShape(member, refs, [
-            ...refs.path,
-            "allOf",
-            idx,
-        ]);
+        const { shapeEntries: entries } = parseObjectShape(member, refs, [...refs.path, "allOf", idx]);
         shapeEntries.push(...entries);
-        shapeTypes.push(...types);
     }
     if (shapeEntries.length === 0)
         return undefined;
-    return {
-        expression: `z.looseObject({ ${shapeEntries.join(", ")} })`,
-        type: `z.ZodObject<{ ${shapeTypes.join(", ")} }>`,
-    };
+    return zodLooseObject(shapeEntries);
 };
 const ensureOriginalIndex = (arr) => {
     const newArr = [];
@@ -90,7 +80,7 @@ const ensureOriginalIndex = (arr) => {
 };
 export function parseAllOf(schema, refs) {
     if (schema.allOf.length === 0) {
-        return { expression: "z.never()", type: "z.ZodNever" };
+        return zodNever();
     }
     else if (schema.allOf.length === 1) {
         const item = schema.allOf[0];
@@ -116,9 +106,6 @@ export function parseAllOf(schema, refs) {
         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}>`,
-        };
+        return zodIntersection(leftResult, rightResult);
     }
 }

package/dist/parsers/parseAnyOf.js

@@ -2,6 +2,8 @@ import { parseSchema } from "./parseSchema.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
 import { extractInlineObject } from "../utils/extractInlineObject.js";
 import { normalizeUnionMembers } from "../utils/normalizeUnion.js";
+import { wrapRecursiveUnion } from "../utils/wrapRecursiveUnion.js";
+import { zodRef, zodUnion } from "../utils/schemaRepresentation.js";
 export const parseAnyOf = (schema, refs) => {
     if (!schema.anyOf.length) {
         return anyOrUnknown(refs);
@@ -16,7 +18,7 @@ export const parseAnyOf = (schema, refs) => {
     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 zodRef(extracted);
         }
         return parseSchema(memberSchema, { ...refs, path: [...refs.path, "anyOf", i] });
     });
@@ -27,10 +29,6 @@ export const parseAnyOf = (schema, refs) => {
     if (normalized.length === 1) {
         return normalized[0];
     }
-    const expressions = normalized.map((m) => m.expression).join(", ");
-    const types = normalized.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 };
+    const union = zodUnion(normalized, { readonlyType: true });
+    return wrapRecursiveUnion(refs, union);
 };

package/dist/parsers/parseArray.js

@@ -1,6 +1,7 @@
 import { withMessage } from "../utils/withMessage.js";
 import { parseSchema } from "./parseSchema.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { zodArray, zodChain, zodSuperRefine, zodTuple } from "../utils/schemaRepresentation.js";
 export const parseArray = (schema, refs) => {
     // JSON Schema 2020-12 uses `prefixItems` for tuples.
     // Older drafts used `items` as an array.
@@ -8,33 +9,29 @@ export const parseArray = (schema, refs) => {
     if (prefixItems) {
         // Tuple case
         const itemResults = prefixItems.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "prefixItems", i] }));
-        let tuple = `z.tuple([${itemResults.map((r) => r.expression).join(", ")}])`;
-        // We construct the type manually for the tuple part
-        let tupleTypes = itemResults.map((r) => r.type).join(", ");
-        let tupleType = `z.ZodTuple<[${tupleTypes}], null>`; // Default null rest
         // Handle "additionalItems" (older drafts) or "items" (2020-12 when prefixItems is used)
         // If prefixItems is present, `items` acts as the schema for additional items.
         // If prefixItems came from `items` (array form), then `additionalItems` controls the rest.
         const additionalSchema = schema.prefixItems ? schema.items : schema.additionalItems;
+        let rest;
         if (additionalSchema === false) {
             // Closed tuple
+            rest = null;
         }
         else if (additionalSchema) {
-            const restSchema = additionalSchema === true
-                ? anyOrUnknown(refs)
-                : parseSchema(additionalSchema, {
-                    ...refs,
-                    path: [...refs.path, "items"],
-                });
-            tuple += `.rest(${restSchema.expression})`;
-            tupleType = `z.ZodTuple<[${tupleTypes}], ${restSchema.type}>`;
+            rest =
+                additionalSchema === true
+                    ? anyOrUnknown(refs)
+                    : parseSchema(additionalSchema, {
+                        ...refs,
+                        path: [...refs.path, "items"],
+                    });
         }
         else {
             // Open by default
-            const anyRes = anyOrUnknown(refs);
-            tuple += `.rest(${anyRes.expression})`;
-            tupleType = `z.ZodTuple<[${tupleTypes}], ${anyRes.type}>`;
+            rest = anyOrUnknown(refs);
         }
+        let result = zodTuple(itemResults, rest);
         if (schema.contains) {
             const containsResult = parseSchema(schema.contains, {
                 ...refs,
@@ -42,7 +39,7 @@ export const parseArray = (schema, refs) => {
             });
             const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
             const maxContains = schema.maxContains;
-            tuple += `.superRefine((arr, ctx) => {
+            result = zodSuperRefine(result, `(arr, ctx) => {
   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" });
@@ -50,12 +47,9 @@ export const parseArray = (schema, refs) => {
   if (${maxContains ?? "undefined"} !== undefined && matches > ${maxContains ?? "undefined"}) {
     ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
   }
-})`;
+}`);
         }
-        return {
-            expression: tuple,
-            type: tupleType,
-        };
+        return result;
     }
     // Regular Array case
     const itemsSchema = schema.items;
@@ -66,22 +60,27 @@ export const parseArray = (schema, refs) => {
             ...refs,
             path: [...refs.path, "items"],
         });
-    let r = `z.array(${itemResult.expression})`;
-    let arrayType = `z.ZodArray<${itemResult.type}>`;
-    r += withMessage(schema, "minItems", ({ json }) => ({
+    let result = zodArray(itemResult);
+    const minItems = withMessage(schema, "minItems", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
         messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
-    r += withMessage(schema, "maxItems", ({ json }) => ({
+    if (minItems) {
+        result = zodChain(result, minItems.slice(1));
+    }
+    const maxItems = withMessage(schema, "maxItems", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
         messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
+    if (maxItems) {
+        result = zodChain(result, maxItems.slice(1));
+    }
     if (schema.uniqueItems === true) {
-        r += `.superRefine((arr, ctx) => {
+        result = zodSuperRefine(result, `(arr, ctx) => {
   const seen = new Set();
   for (const [index, value] of arr.entries()) {
     let key;
@@ -102,7 +101,7 @@ export const parseArray = (schema, refs) => {
 
     seen.add(key);
   }
-})`;
+}`);
     }
     if (schema.contains) {
         const containsResult = parseSchema(schema.contains, {
@@ -111,7 +110,7 @@ export const parseArray = (schema, refs) => {
         });
         const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
         const maxContains = schema.maxContains;
-        r += `.superRefine((arr, ctx) => {
+        result = zodSuperRefine(result, `(arr, ctx) => {
   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" });
@@ -119,10 +118,7 @@ export const parseArray = (schema, refs) => {
   if (${maxContains ?? "undefined"} !== undefined && matches > ${maxContains ?? "undefined"}) {
     ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
   }
-})`;
+}`);
     }
-    return {
-        expression: r,
-        type: arrayType,
-    };
+    return result;
 };

package/dist/parsers/parseBoolean.js

@@ -1,4 +1,2 @@
-export const parseBoolean = () => ({
-    expression: "z.boolean()",
-    type: "z.ZodBoolean",
-});
+import { zodBoolean } from "../utils/schemaRepresentation.js";
+export const parseBoolean = () => zodBoolean();

package/dist/parsers/parseConst.js

@@ -1,22 +1,4 @@
+import { zodLiteral } from "../utils/schemaRepresentation.js";
 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 };
+    return zodLiteral(schema.const);
 };

package/dist/parsers/parseEnum.js

@@ -1,35 +1,20 @@
+import { zodEnum, zodLiteral, zodNever, zodUnion } from "../utils/schemaRepresentation.js";
 export const parseEnum = (schema) => {
     if (schema.enum.length === 0) {
-        return {
-            expression: "z.never()",
-            type: "z.ZodNever",
-        };
+        return 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}>`,
-        };
+        return zodLiteral(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} }>`,
-        };
+        return zodEnum(values, { typeStyle: "object" });
     }
     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(", ")}]>`,
-        };
+        return zodUnion(schema.enum.map((value) => zodLiteral(value)));
     }
 };