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

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

@@ -5,8 +5,68 @@ import { parseAllOf } from "./parseAllOf.js";
 import { parseIfThenElse } from "./parseIfThenElse.js";
 import { addJsdocs } from "../utils/jsdocs.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { containsRecursiveRef, inferTypeFromExpression } from "../utils/schemaRepresentation.js";
 export function parseObject(objectSchema, refs) {
+    // Optimization: if we have composition keywords (allOf/anyOf/oneOf) but no direct properties,
+    // delegate entirely to the composition parser to avoid generating z.object({}).and(...)
+    const hasDirectProperties = objectSchema.properties && Object.keys(objectSchema.properties).length > 0;
+    const hasAdditionalProperties = objectSchema.additionalProperties !== undefined;
+    const hasPatternProperties = objectSchema.patternProperties !== undefined;
+    const hasNoDirectSchema = !hasDirectProperties && !hasAdditionalProperties && !hasPatternProperties;
+    const parentRequired = Array.isArray(objectSchema.required) ? objectSchema.required : [];
+    const allOfRequired = its.an.allOf(objectSchema)
+        ? objectSchema.allOf.flatMap((member) => {
+            if (typeof member !== "object" || member === null)
+                return [];
+            const req = member.required;
+            return Array.isArray(req) ? req : [];
+        })
+        : [];
+    const combinedAllOfRequired = [...new Set([...parentRequired, ...allOfRequired])];
+    // Helper to add type: "object" to composition members that have properties but no explicit type
+    const addObjectType = (members) => members.map((x) => typeof x === "object" &&
+        x !== null &&
+        !x.type &&
+        (x.properties || x.additionalProperties || x.patternProperties)
+        ? { ...x, type: "object" }
+        : x);
+    const addObjectTypeAndMergeRequired = (members) => members.map((x) => {
+        if (typeof x !== "object" || x === null)
+            return x;
+        let normalized = x;
+        const hasShape = normalized.properties || normalized.additionalProperties || normalized.patternProperties;
+        if (hasShape && !normalized.type) {
+            normalized = { ...normalized, type: "object" };
+        }
+        if (combinedAllOfRequired.length &&
+            normalized.properties &&
+            Object.keys(normalized.properties).length) {
+            const memberRequired = Array.isArray(normalized.required) ? normalized.required : [];
+            const mergedRequired = Array.from(new Set([
+                ...memberRequired,
+                ...combinedAllOfRequired.filter((key) => Object.prototype.hasOwnProperty.call(normalized.properties, key)),
+            ]));
+            if (mergedRequired.length) {
+                normalized = { ...normalized, required: mergedRequired };
+            }
+        }
+        return normalized;
+    });
+    // If only allOf, delegate to parseAllOf
+    if (hasNoDirectSchema && its.an.allOf(objectSchema) && !its.an.anyOf(objectSchema) && !its.a.oneOf(objectSchema) && !its.a.conditional(objectSchema)) {
+        return parseAllOf({ ...objectSchema, allOf: addObjectTypeAndMergeRequired(objectSchema.allOf) }, refs);
+    }
+    // If only anyOf, delegate to parseAnyOf
+    if (hasNoDirectSchema && its.an.anyOf(objectSchema) && !its.an.allOf(objectSchema) && !its.a.oneOf(objectSchema) && !its.a.conditional(objectSchema)) {
+        return parseAnyOf({ ...objectSchema, anyOf: addObjectType(objectSchema.anyOf) }, refs);
+    }
+    // If only oneOf, delegate to parseOneOf
+    if (hasNoDirectSchema && its.a.oneOf(objectSchema) && !its.an.allOf(objectSchema) && !its.an.anyOf(objectSchema) && !its.a.conditional(objectSchema)) {
+        return parseOneOf({ ...objectSchema, oneOf: addObjectType(objectSchema.oneOf) }, refs);
+    }
     let properties = undefined;
+    // Track property types for building proper object type annotations
+    const propertyTypes = [];
     if (objectSchema.properties) {
         if (!Object.keys(objectSchema.properties).length) {
             properties = "z.object({})";
@@ -26,10 +86,18 @@ export function parseObject(objectSchema, refs) {
                     : typeof propSchema === "object" && propSchema.required === true;
                 const optional = !hasDefault && !required;
                 const valueWithOptional = optional
-                    ? `${parsedProp}.optional()`
-                    : parsedProp;
-                let result = shouldUseGetter(valueWithOptional, refs)
-                    ? `get ${JSON.stringify(key)}(){ return ${valueWithOptional} }`
+                    ? `${parsedProp.expression}.optional()`
+                    : parsedProp.expression;
+                // Calculate the type for getters (needed for recursive type inference)
+                const valueType = optional
+                    ? `z.ZodOptional<${parsedProp.type}>`
+                    : parsedProp.type;
+                // Track the property type for building the object type
+                propertyTypes.push({ key, type: valueType });
+                const useGetter = shouldUseGetter(valueWithOptional, refs);
+                let result = useGetter
+                    // Type annotation on getter is required for recursive type inference in unions
+                    ? `get ${JSON.stringify(key)}(): ${valueType} { return ${valueWithOptional} }`
                     : `${JSON.stringify(key)}: ${valueWithOptional}`;
                 if (refs.withJsdocs && typeof propSchema === "object") {
                     result = addJsdocs(propSchema, result);
@@ -47,6 +115,10 @@ export function parseObject(objectSchema, refs) {
         })
         : undefined;
     const unevaluated = objectSchema.unevaluatedProperties;
+    const definedPropertyKeys = objectSchema.properties ? Object.keys(objectSchema.properties) : [];
+    const missingRequiredKeys = Array.isArray(objectSchema.required)
+        ? objectSchema.required.filter((key) => !definedPropertyKeys.includes(key))
+        : [];
     let patternProperties = undefined;
     if (objectSchema.patternProperties) {
         const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
@@ -58,33 +130,35 @@ export function parseObject(objectSchema, refs) {
                 }),
             ];
         }, {}));
+        // Helper to get expressions from parsed pattern properties
+        const patternExprs = Object.values(parsedPatternProperties).map(r => r.expression);
         patternProperties = "";
         if (properties) {
             if (additionalProperties) {
                 patternProperties += `.catchall(z.union([${[
-                    ...Object.values(parsedPatternProperties),
-                    additionalProperties,
+                    ...patternExprs,
+                    additionalProperties.expression,
                 ].join(", ")}]))`;
             }
             else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+                patternProperties += `.catchall(z.union([${patternExprs.join(", ")}]))`;
             }
             else {
-                patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
+                patternProperties += `.catchall(${patternExprs.join("")})`;
             }
         }
         else {
             if (additionalProperties) {
                 patternProperties += `z.record(z.string(), z.union([${[
-                    ...Object.values(parsedPatternProperties),
-                    additionalProperties,
+                    ...patternExprs,
+                    additionalProperties.expression,
                 ].join(", ")}]))`;
             }
             else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `z.record(z.string(), z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+                patternProperties += `z.record(z.string(), z.union([${patternExprs.join(", ")}]))`;
             }
             else {
-                patternProperties += `z.record(z.string(), ${Object.values(parsedPatternProperties)})`;
+                patternProperties += `z.record(z.string(), ${patternExprs.join("")})`;
             }
         }
         patternProperties += ".superRefine((value, ctx) => {\n";
@@ -107,7 +181,7 @@ export function parseObject(objectSchema, refs) {
             }
             patternProperties +=
                 "const result = " +
-                    parsedPatternProperties[key] +
+                    parsedPatternProperties[key].expression +
                     ".safeParse(value[key])\n";
             patternProperties += "if (!result.success) {\n";
             patternProperties += `ctx.addIssue({
@@ -124,7 +198,7 @@ export function parseObject(objectSchema, refs) {
         if (additionalProperties) {
             patternProperties += "if (!evaluated) {\n";
             patternProperties +=
-                "const result = " + additionalProperties + ".safeParse(value[key])\n";
+                "const result = " + additionalProperties.expression + ".safeParse(value[key])\n";
             patternProperties += "if (!result.success) {\n";
             patternProperties += `ctx.addIssue({
           path: [...(ctx.path ?? []), key],
@@ -152,22 +226,32 @@ export function parseObject(objectSchema, refs) {
     // In that case, we should NOT use .strict() because it will reject the additional keys
     // before the union gets a chance to validate them.
     const hasCompositionKeywords = its.an.anyOf(objectSchema) || its.a.oneOf(objectSchema) || its.an.allOf(objectSchema) || its.a.conditional(objectSchema);
+    // When there are composition keywords (allOf, anyOf, oneOf, if-then-else) but no direct properties,
+    // we should NOT default to z.record(z.string(), z.any()) because that would allow any properties.
+    // Instead, use z.object({}) and let the .and() call add properties from the composition.
+    // This is especially important when unevaluatedProperties: false is set.
+    const fallback = anyOrUnknown(refs);
     let output = properties
         ? patternProperties
             ? properties + patternProperties
             : additionalProperties
-                ? additionalProperties === "z.never()"
+                ? additionalProperties.expression === "z.never()"
                     // Don't use .strict() if there are composition keywords that add properties
                     ? hasCompositionKeywords
                         ? properties
                         : properties + ".strict()"
-                    : properties + `.catchall(${additionalProperties})`
+                    : properties + `.catchall(${additionalProperties.expression})`
                 : properties
         : patternProperties
             ? patternProperties
             : additionalProperties
-                ? `z.record(z.string(), ${additionalProperties})`
-                : `z.record(z.string(), ${anyOrUnknown(refs)})`;
+                ? `z.record(z.string(), ${additionalProperties.expression})`
+                // If we have composition keywords, start with empty object instead of z.record()
+                // The composition will provide the actual schema via .and()
+                : hasCompositionKeywords
+                    ? "z.object({})"
+                    // No constraints = any object. Use z.record() which is cleaner than z.object({}).catchall()
+                    : `z.record(z.string(), ${fallback.expression})`;
     if (unevaluated === false && properties && !hasCompositionKeywords) {
         output += ".strict()";
     }
@@ -185,7 +269,7 @@ export function parseObject(objectSchema, refs) {
     const isKnown = ${JSON.stringify(knownKeys)}.includes(key);
     const matchesPattern = ${patterns.length ? "[" + patterns.map((r) => r.toString()).join(",") + "]" : "[]"}.some((r) => r.test(key));
     if (!isKnown && !matchesPattern) {
-      const result = ${unevaluatedSchema}.safeParse(value[key]);
+      const result = ${unevaluatedSchema.expression}.safeParse(value[key]);
       if (!result.success) {
         ctx.addIssue({ code: "custom", path: [key], message: "Invalid unevaluated property", params: { issues: result.error.issues } });
       }
@@ -193,8 +277,10 @@ export function parseObject(objectSchema, refs) {
   }
 })`;
     }
+    // Track intersection types added via .and() calls
+    const intersectionTypes = [];
     if (its.an.anyOf(objectSchema)) {
-        output += `.and(${parseAnyOf({
+        const anyOfResult = parseAnyOf({
             ...objectSchema,
             anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
                 x !== null &&
@@ -202,10 +288,12 @@ export function parseObject(objectSchema, refs) {
                 (x.properties || x.additionalProperties || x.patternProperties)
                 ? { ...x, type: "object" }
                 : x),
-        }, refs)})`;
+        }, refs);
+        output += `.and(${anyOfResult.expression})`;
+        intersectionTypes.push(anyOfResult.type);
     }
     if (its.a.oneOf(objectSchema)) {
-        output += `.and(${parseOneOf({
+        const oneOfResult = parseOneOf({
             ...objectSchema,
             oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
                 x !== null &&
@@ -213,22 +301,40 @@ export function parseObject(objectSchema, refs) {
                 (x.properties || x.additionalProperties || x.patternProperties)
                 ? { ...x, type: "object" }
                 : x),
-        }, refs)})`;
+        }, refs);
+        // Check if this is a refinement-only result (required fields validation)
+        // If so, apply superRefine directly instead of creating an intersection
+        const resultWithRefinement = oneOfResult;
+        if (resultWithRefinement.isRefinementOnly && resultWithRefinement.refinementBody) {
+            output += `.superRefine(${resultWithRefinement.refinementBody})`;
+            // No intersection type needed - superRefine doesn't change the type
+        }
+        else {
+            output += `.and(${oneOfResult.expression})`;
+            intersectionTypes.push(oneOfResult.type);
+        }
     }
     if (its.an.allOf(objectSchema)) {
-        output += `.and(${parseAllOf({
+        const allOfResult = parseAllOf({
             ...objectSchema,
-            allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
+            allOf: addObjectTypeAndMergeRequired(objectSchema.allOf),
+        }, refs);
+        output += `.and(${allOfResult.expression})`;
+        intersectionTypes.push(allOfResult.type);
     }
     // Handle if/then/else conditionals on object schemas
     if (its.a.conditional(objectSchema)) {
-        output += `.and(${parseIfThenElse(objectSchema, refs)})`;
+        const conditionalResult = parseIfThenElse(objectSchema, refs);
+        output += `.and(${conditionalResult.expression})`;
+        intersectionTypes.push(conditionalResult.type);
+    }
+    // Only add required validation for missing keys when there are no composition keywords
+    // When allOf/anyOf/oneOf exist, they should define the properties and handle required validation
+    if (missingRequiredKeys.length > 0 && !hasCompositionKeywords) {
+        const checks = missingRequiredKeys
+            .map((key) => `if (!Object.prototype.hasOwnProperty.call(value, ${JSON.stringify(key)})) { ctx.addIssue({ code: "custom", path: [${JSON.stringify(key)}], message: "Required property missing" }); }`)
+            .join(" ");
+        output += `.superRefine((value, ctx) => { if (value && typeof value === "object") { ${checks} } })`;
     }
     // propertyNames
     if (objectSchema.propertyNames) {
@@ -300,16 +406,73 @@ export function parseObject(objectSchema, refs) {
 })`;
         }
     }
-    return output;
+    // Build the type representation from tracked property types
+    let type;
+    if (propertyTypes.length > 0) {
+        // Build proper object type with actual property types
+        const typeShape = propertyTypes
+            .map(({ key, type: propType }) => `${JSON.stringify(key)}: ${propType}`)
+            .join("; ");
+        type = `z.ZodObject<{ ${typeShape} }>`;
+    }
+    else if (properties === "z.object({})") {
+        // Empty object
+        type = "z.ZodObject<{}>";
+    }
+    else {
+        // Fallback for complex cases (patternProperties, record, etc.)
+        type = inferTypeFromExpression(output);
+    }
+    // Wrap in intersection types if .and() calls were added
+    for (const intersectionType of intersectionTypes) {
+        type = `z.ZodIntersection<${type}, ${intersectionType}>`;
+    }
+    return {
+        expression: output,
+        type,
+    };
 }
+/**
+ * Determines if a property should use getter syntax for recursive references.
+ * Getters defer evaluation until access time, which is the Zod v4 recommended
+ * approach for handling recursive schemas in object properties.
+ */
 const shouldUseGetter = (parsed, refs) => {
     if (!parsed)
         return false;
-    if (refs.currentSchemaName && parsed.includes(refs.currentSchemaName)) {
+    // Check for z.lazy() - these should use getters
+    if (parsed.includes("z.lazy("))
         return true;
+    // Check for direct self-recursion (expression contains the current schema name)
+    // This handles cases like generateSchemaBundle where the schema name is different
+    // from the def name (e.g., NodeSchema vs node)
+    if (refs.currentSchemaName) {
+        const selfRefPattern = new RegExp(`\\b${refs.currentSchemaName}\\b`);
+        if (selfRefPattern.test(parsed)) {
+            return true;
+        }
     }
-    if (refs.cycleRefNames?.has(parsed)) {
-        return true;
+    // Check for direct recursive references in the same SCC
+    if (refs.currentSchemaName && refs.cycleRefNames && refs.cycleComponentByName) {
+        const cycleRefNames = refs.cycleRefNames;
+        const cycleComponentByName = refs.cycleComponentByName;
+        const refNameArray = Array.from(cycleRefNames);
+        // Check if expression contains a reference to a cycle member in the same component
+        if (containsRecursiveRef(parsed, cycleRefNames)) {
+            const currentComponent = cycleComponentByName.get(refs.currentSchemaName);
+            if (currentComponent !== undefined) {
+                for (let i = 0; i < refNameArray.length; i++) {
+                    const refName = refNameArray[i];
+                    const pattern = new RegExp(`\\b${refName}\\b`);
+                    if (pattern.test(parsed)) {
+                        const refComponent = cycleComponentByName.get(refName);
+                        if (refComponent === currentComponent) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
     }
-    return Boolean(refs.inProgress && refs.inProgress.has(parsed));
+    return false;
 };