feat: enhance generic step to support recursive structures and improve factory function handling

Author: DevilTea

packages/internal/src/steps/generic/generic.test.ts

@@ -63,6 +63,36 @@ describe('generic plugin', () => {
 			const result = schema.execute('world')
 			expect(result).toEqual({ value: 'world' })
 		})
+
+		it('should handle recursive structures using generic', () => {
+			interface MyNode {
+				id: number
+				children?: MyNode[]
+			}
+
+			const nodeSchema = v.object({
+				id: v.number(),
+				// Required to use a factory function with specifying return type `any` to avoid circular type reference.
+				children: [v.array(v.generic<{ output: MyNode }>((): any => nodeSchema))],
+			})
+
+			const result = nodeSchema.execute({
+				id: 1,
+				children: [
+					{ id: 2 },
+					{ id: 3, children: [{ id: 4 }] },
+				],
+			})
+			expect(result).toEqual({
+				value: {
+					id: 1,
+					children: [
+						{ id: 2 },
+						{ id: 3, children: [{ id: 4 }] },
+					],
+				},
+			})
+		})
 	})
 
 	describe('integration with other steps', () => {

packages/internal/src/steps/generic/generic.ts

@@ -61,9 +61,41 @@ export const generic = implStepPlugin<PluginDef>({
 		utils: { addStep },
 		params: [stepOrFactory],
 	}) => {
-		const step = typeof stepOrFactory === 'function' ? stepOrFactory() : stepOrFactory
-		for (const s of step['~core'].runtimeSteps) {
-			addStep(s)
+		// Handle factory function
+		if (typeof stepOrFactory === 'function') {
+			addStep((lastResult) => {
+				const runtimeSteps = stepOrFactory()['~core'].runtimeSteps
+				const len = runtimeSteps.length
+				let result: any = lastResult
+				let isAsync = false
+
+				for (let i = 0; i < len; i++) {
+					if (isAsync) {
+					// Already in async mode, skip synchronous execution
+						continue
+					}
+					// Execute step synchronously
+					result = runtimeSteps[i]!(result)
+					// Check if current result is a promise
+					if (result instanceof Promise) {
+						isAsync = true
+						// Once we hit async, chain all remaining steps
+						for (let j = i + 1; j < len; j++) {
+							result = result.then(runtimeSteps[j]!)
+						}
+						return result
+					}
+				}
+				return result
+			})
+		}
+		// Handle direct step
+		else {
+			const runtimeSteps = stepOrFactory['~core'].runtimeSteps
+			const len = runtimeSteps.length
+			for (let i = 0; i < len; i++) {
+				addStep(runtimeSteps[i]!)
+			}
 		}
 	},
 })