fixup

Author: edmundhung

packages/conform-zod/v4/coercion.ts

@@ -177,16 +177,13 @@ export function enableTypeCoercion<Schema extends $ZodType>(
 ): $ZodType {
 	const result = options.cache.get(type);
 
-	// Return the cached schema if it's already processed
-	// This is to prevent infinite recursion caused by z.lazy() or getter-based recursive schemas
 	if (result) {
 		return result;
 	}
 
-	// Pre-cache the schema to handle recursive references
-	// This prevents infinite recursion when processing getter-based recursive schemas
-	// The cache will be updated with the final coerced schema after processing
-	options.cache.set(type, type);
+	// Pre-cache a lazy wrapper so recursive references resolve to the coerced schema
+	const lazyCoerced = lazy(() => options.cache.get(type) ?? type);
+	options.cache.set(type, lazyCoerced);
 
 	let schema: $ZodType = type;
 	const zod = (type as unknown as $ZodTypes)._zod;
@@ -303,16 +300,15 @@ export function enableTypeCoercion<Schema extends $ZodType>(
 						return object;
 					};
 
-					// Check if item is already in cache to prevent infinite recursion
-					// This handles recursive discriminated unions with getter-based schemas
+					// Handle recursive references by wrapping the cached lazy to preserve propValues
 					const cachedItem = options.cache.get(item);
-					if (cachedItem) {
-						// If the cached item is the same as the original, it already has the correct propValues
-						// Don't try to modify read-only properties
-						if (cachedItem === item) {
-							return item;
-						}
-						return setOriginalPropValues(cachedItem);
+					if (cachedItem && cachedItem !== item) {
+						return setOriginalPropValues(
+							pipe(
+								transform((value) => value),
+								cachedItem,
+							),
+						);
 					}
 
 					if (objectDef.type !== 'object') {
@@ -361,9 +357,7 @@ export function enableTypeCoercion<Schema extends $ZodType>(
 		schema = lazy(() => enableTypeCoercion(inner, options));
 	}
 
-	if (type !== schema) {
-		options.cache.set(type, schema);
-	}
+	options.cache.set(type, schema);
 
 	return schema;
 }

packages/conform-zod/v4/tests/coercion/schema/lazy.test.ts

@@ -99,17 +99,16 @@ describe('coercion', () => {
 		});
 
 		test('should handle getter-based recursive schemas', () => {
-			// Test case from issue: https://github.com/edmundhung/conform/issues/1127
-			// Zod v4 recommended getter pattern: https://zod.dev/api#recursive-objects
+			// https://github.com/edmundhung/conform/issues/1127
 			const ConditionNodeSchema = z.object({
 				type: z.literal('condition'),
 				value: z.string(),
+				priority: z.number(),
 			});
 
 			const LogicalGroupNodeSchema = z.object({
 				type: z.literal('group'),
 				operator: z.enum(['AND', 'OR']),
-				// Getter pattern recommended by Zod v4
 				get children(): z.ZodArray<
 					z.ZodDiscriminatedUnion<
 						[typeof LogicalGroupNodeSchema, typeof ConditionNodeSchema]
@@ -124,14 +123,12 @@ describe('coercion', () => {
 				},
 			});
 
-			// This should not throw "Maximum call stack size exceeded"
 			const schema = coerceFormValue(
 				z.object({
 					filter: LogicalGroupNodeSchema,
 				}),
 			);
 
-			// Test parsing with valid data
 			expect(
 				getResult(
 					schema.safeParse({
@@ -142,6 +139,7 @@ describe('coercion', () => {
 								{
 									type: 'condition',
 									value: 'test',
+									priority: '1',
 								},
 							],
 						},
@@ -157,13 +155,13 @@ describe('coercion', () => {
 							{
 								type: 'condition',
 								value: 'test',
+								priority: 1,
 							},
 						],
 					},
 				},
 			});
 
-			// Test parsing with nested recursive structure
 			expect(
 				getResult(
 					schema.safeParse({
@@ -178,6 +176,7 @@ describe('coercion', () => {
 										{
 											type: 'condition',
 											value: 'nested',
+											priority: '99',
 										},
 									],
 								},
@@ -199,6 +198,7 @@ describe('coercion', () => {
 									{
 										type: 'condition',
 										value: 'nested',
+										priority: 99,
 									},
 								],
 							},
@@ -207,7 +207,6 @@ describe('coercion', () => {
 				},
 			});
 
-			// Test validation errors
 			const errorResult = getResult(
 				schema.safeParse({
 					filter: {
@@ -216,7 +215,6 @@ describe('coercion', () => {
 						children: [
 							{
 								type: 'condition',
-								// missing 'value'
 							},
 						],
 					},
@@ -225,6 +223,7 @@ describe('coercion', () => {
 			expect(errorResult.success).toEqual(false);
 			if (!errorResult.success) {
 				expect(errorResult.error['filter.children[0].value']).toBeDefined();
+				expect(errorResult.error['filter.children[0].priority']).toBeDefined();
 			}
 		});
 	});