🔧 fix: recursive macro with conflict value per status

Author: SaltyAom

src/types.ts

@@ -1069,7 +1069,7 @@ export type MacroToContext<
 		R
 	> extends infer A
 		? {
-				[K in Exclude<keyof A, 'return'>]: A[K]
+				[K in Exclude<keyof A, 'return'>]: UnionToIntersect<A[K]>
 			} & Prettify<{
 				// @ts-ignore
 				return: FlattenMacroResponse<A['return']>

test/types/index.ts

@@ -1223,41 +1223,29 @@ const a = app
 
 	const app = new Elysia().group('/api', (app) => app.use(testController))
 
-	expectTypeOf<(typeof app)['~Routes']>().toEqualTypeOf<{
-		api: {
-			test: {
-				'could-be-error': {
-					right: {
-						get: {
-							body: unknown
-							params: {}
-							query: unknown
-							headers: unknown
-							response: {
-								200: {
-									couldBeError: boolean
-								}
-							}
-						}
-					}
-				}
-			}
-		} & {
-			test: {
-				deep: {
-					ws: {
-						subscribe: {
-							body: unknown
-							params: {}
-							query: unknown
-							headers: unknown
-							response: {}
-						}
-					}
-				}
+	expectTypeOf<
+		(typeof app)['~Routes']['api']['test']['could-be-error']['right']['get']
+	>().toEqualTypeOf<{
+		body: unknown
+		params: {}
+		query: unknown
+		headers: unknown
+		response: {
+			200: {
+				couldBeError: boolean
 			}
 		}
 	}>()
+
+	expectTypeOf<
+		(typeof app)['~Routes']['api']['test']['deep']['ws']['subscribe']
+	>().toEqualTypeOf<{
+		body: {}
+		params: {}
+		query: {}
+		headers: {}
+		response: {}
+	}>()
 }
 
 // ? Handle error status
@@ -2512,27 +2500,42 @@ type a = keyof {}
 
 // onAfterHandle should have response
 {
-	new Elysia().onAfterHandle({ as: 'scoped' }, ({ response }) => response)
+	new Elysia().onAfterHandle(
+		{ as: 'scoped' },
+		({ responseValue }) => responseValue
+	)
 }
 
+/* Neither `a` or `b` exist at the type level, even though they do exist at runtime */
 {
 	new Elysia()
 		.macro({
 			a: {
+				body: t.Object({
+					a: t.String()
+				}),
 				resolve: () => ({ a: 'a' as const })
 			},
 			b: {
+				body: t.Object({
+					b: t.String()
+				}),
 				resolve: () => ({ b: 'b' as const })
 			}
 		})
 		.get(
 			'/test',
-			(
-				{
-					a,
-					b
-				} /* Neither `a` or `b` exist at the type level, even though they do exist at runtime */
-			) => ({ a, b }),
+			({ a, b, body }) => {
+				expectTypeOf<typeof body>().toEqualTypeOf<{
+					a: string
+					b: string
+				}>()
+
+				expectTypeOf<typeof a>().toEqualTypeOf<'a'>()
+				expectTypeOf<typeof b>().toEqualTypeOf<'b'>()
+
+				return { a, b }
+			},
 			{
 				a: true,
 				b: true

test/types/lifecycle/soundness.ts

@@ -2297,29 +2297,29 @@ import { Prettify } from '../../../src/types'
 	const app = new Elysia()
 		.macro({
 			a: {
-				resolve: () => ({ a: 'resolved' }) as const,
 				beforeHandle({ status }) {
 					if (Math.random()) return status(400, 'a')
 					if (Math.random()) return status(401, 'a')
 
-					return 'b'
+					return 'before handler' as const
 				}
 			},
 			b: {
-				a: true,
-				beforeHandle({ status }) {
+				resolve({ status }) {
 					if (Math.random()) return status(401, 'b')
-				}
+				},
+				a: true
 			}
 		})
-		.get('/', ({ a }) => a, {
+		.get('/', () => 'handler' as const, {
 			b: true
 		})
 
-	type Route = (typeof app)['~Routes']['get']['response']
 
-	expectTypeOf<Route>().toEqualTypeOf<{
-		200: 'b' | 'resolved'
+	type Routes = (typeof app)['~Routes']['get']['response']
+
+	expectTypeOf<Routes>().toEqualTypeOf<{
+		200: 'before handler' | 'handler'
 		400: 'a'
 		401: 'a' | 'b'
 	}>