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

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,13 +9,13 @@ 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))
+    issues.forEach((issue) => ctx.addIssue({ ...issue }))
   }
 })`;
     // Store original if/then/else for JSON Schema round-trip
@@ -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",
+    };
 };

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

@@ -5,8 +5,36 @@ 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;
+    // 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);
+    // 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);
+    }
+    // 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 +54,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 +83,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 +98,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 +149,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 +166,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 +194,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 +237,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 +245,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 +256,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,10 +269,21 @@ 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 &&
@@ -224,11 +291,23 @@ export function parseObject(objectSchema, refs) {
                 (x.properties || x.additionalProperties || x.patternProperties)
                 ? { ...x, type: "object" }
                 : x),
-        }, refs)})`;
+        }, 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,13 +379,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;
+        }
+    }
+    // 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;
 };