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

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @gabrielbryk/json-schema-to-zod
 
+## 2.11.1
+
+### Patch Changes
+
+- 466d672: Fix TS7056 error when generating declarations for schemas referencing recursive types
+
+  - Add explicit type annotations to any schema that references recursive schemas (not just unions)
+  - This prevents TypeScript from trying to serialize extremely large expanded types when generating .d.ts files
+  - Fix type narrowing in parseObject for allOf required array handling
+
 ## 2.11.0
 
 ### Minor Changes

package/dist/core/emitZod.js

@@ -196,14 +196,14 @@ export const emitZod = (analysis) => {
                 : undefined;
             const hasLazy = expression.includes("z.lazy(");
             const hasGetter = expression.includes("get ");
-            const isUnion = expression.startsWith("z.union(") || expression.startsWith("z.discriminatedUnion(");
-            // Check if this union references any cycle members (recursive schemas)
-            const referencesRecursiveSchema = isUnion && Array.from(cycleRefNames).some(cycleName => new RegExp(`\\b${cycleName}\\b`).test(expression));
+            // 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));
             // 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. Union types that reference recursive schemas (for proper type inference)
+            // 2. Any schema that references recursive schemas (to prevent TS7056)
             const needsTypeAnnotation = (hasLazy && !hasGetter) || referencesRecursiveSchema;
             const storedType = needsTypeAnnotation ? (hintedType ?? inferTypeFromExpression(expression)) : undefined;
             // Rule 2 from Zod v4: Don't chain methods on recursive types

package/dist/parsers/parseObject.js

@@ -13,6 +13,16 @@ export function parseObject(objectSchema, refs) {
     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 &&
@@ -20,9 +30,31 @@ export function parseObject(objectSchema, refs) {
         (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: addObjectType(objectSchema.allOf) }, refs);
+        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)) {
@@ -285,12 +317,7 @@ export function parseObject(objectSchema, refs) {
     if (its.an.allOf(objectSchema)) {
         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),
+            allOf: addObjectTypeAndMergeRequired(objectSchema.allOf),
         }, refs);
         output += `.and(${allOfResult.expression})`;
         intersectionTypes.push(allOfResult.type);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielbryk/json-schema-to-zod",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "description": "Converts JSON schema objects or files into Zod schemas",
   "type": "module",
   "types": "./dist/types/index.d.ts",