🔧 fix: recursive macro with conflict value per status

Author: SaltyAom

CHANGELOG.md

@@ -1,4 +1,7 @@
 # 1.4.25 - 12 Feb 2025
+Feature:
+- export ElysiaStatus
+
 Bug fix:
 - macro with conflict literal value per status
 - recursive macro with conflict value per status

example/a.ts

@@ -1,77 +1,67 @@
-import { Elysia, t } from '../src'
-import { req } from '../test/utils'
+import { Elysia, ElysiaStatus, t, type UnwrapSchema } from '../src'
 
-const challengeModel = t.Object({
-	nonce: t.String(),
-	issued: t.Number(),
-	bits: t.Number()
-})
+const Models = {
+	'user.update': t.Object({
+		id: t.String(),
+		name: t.Optional(t.String())
+	})
+}
 
-const app = new Elysia({
-	cookie: {
-		secrets: ['a', null],
-		sign: 'challenge'
-	}
-})
-	.get(
-		'/set',
-		({ cookie: { challenge } }) => {
-			challenge.value = {
-				nonce: 'hello',
-				bits: 19,
-				issued: Date.now()
-			}
+type Models = {
+	[k in keyof typeof Models]: UnwrapSchema<(typeof Models)[k]>
+}
+
+const app = new Elysia()
+	.macro('isAuth', {
+		// headers: t.Object({
+		// 	authorization: t.TemplateLiteral('Authorization ${string}')
+		// }),
+		async resolve({ headers, status }) {
+			// Mock authentication logic
+			if (Math.random() > 0.5) return status(401, 'Not signed in')
+			if (Math.random() > 0.5) return status(401, 'Deactivated account')
 
-			return challenge.value
-		},
-		{
-			cookie: t.Cookie({
-				challenge: t.Optional(challengeModel)
-			})
-		}
-	)
-	.get(
-		'/get',
-		({ cookie: { challenge } }) => {
 			return {
-				type: typeof challenge,
-				value: challenge.value
+				user: 'saltyaom'
 			}
-		},
-		{
-			cookie: t.Cookie({
-				challenge: challengeModel
-			})
-		}
-	)
-
-const first = await app.handle(
-	req('/set', {
-		headers: {
-			cookie: `challenge=${JSON.stringify({
-				nonce: 'hello',
-				bits: 19,
-				issued: 1770750432990
-			})}`
 		}
 	})
-)
+	.model(Models)
+	.macro('isAdmin', {
+		isAuth: true,
+		async resolve({ headers, status }) {
+			// Mock admin check logic
+			if (Math.random() > 0.5) return status(403, 'Not allowed')
+
 
-console.log(first.status)
-console.log(await first.json())
 
-const cookie = first.headers.get('set-cookie')
-const challenge = cookie!.match(/challenge=([^;]*)/)![1]
+			headers.authorization
 
-console.log(challenge)
+			return {
+				admin: {
+					async updateUser({ id, ...rest }: Models['user.update']) {
+						if (Math.random() > 0.5) return status(404, 'No user')
 
-const second = await app
-	.handle(
-		req('/get', {
-			headers: {
-				cookie: `challenge=${challenge}`
+						return { id }
+					}
+				}
 			}
-		})
+		}
+	})
+	.post(
+		'/',
+		async ({ user, admin, body, headers }) => {
+			return 'ok'
+			// const updated = await admin.updateUser(body)
+
+			// if (updated instanceof ElysiaStatus) return updated
+
+			// return `User ${user} updated user ${updated.id}` as const
+		},
+		{
+			isAuth: true,
+			// body: 'user.update'
+		}
 	)
 
-console.log(second.status)
+type Result = (typeof app)['~Routes']['post']['response']

src/error.ts

@@ -105,6 +105,8 @@ export class ElysiaCustomStatusResponse<
 	}
 }
 
+export const ElysiaStatus = ElysiaCustomStatusResponse
+
 export const status = <
 	const Code extends number | keyof StatusMap,
 	const T = Code extends keyof InvertedStatusMap

src/index.ts

@@ -8235,6 +8235,7 @@ export {
 	InternalServerError,
 	InvalidCookieSignature,
 	ERROR_CODE,
+	ElysiaStatus,
 	ElysiaCustomStatusResponse,
 	type SelectiveStatus
 } from './error'

src/types.ts

@@ -967,26 +967,9 @@ type ExtractOnlyResponseFromMacro<A> =
 		? {}
 		: {} extends A
 			? {}
-			: Extract<A, AnyElysiaCustomStatusResponse> extends infer A
-				? IsNever<A> extends true
-					? {}
-					: {
-							return: UnionToIntersect<
-								A extends ElysiaCustomStatusResponse<
-									any,
-									infer Value,
-									infer Status
-								>
-									? {
-											[status in Status]: IsAny<Value> extends true
-												? // @ts-ignore status is always in Status Map
-													InvertedStatusMap[Status]
-												: Value
-										}
-									: {}
-							>
-						}
-				: {}
+			: {
+					return: MergeResponseStatus<A>
+				}
 
 type MergeResponseStatus<A> = {
 	[status in keyof UnionToIntersect<
@@ -1007,10 +990,11 @@ type MergeAllStatus<T> = {
 type ExtractAllResponseFromMacro<A> =
 	IsNever<A> extends true
 		? {}
-		: {
-				// Merge all status to single object first
-				return: Prettify<
-					MergeResponseStatus<A> &
+		: {} extends A
+			? {}
+			: {
+					// Merge all status to single object first
+					return: MergeResponseStatus<A> &
 						(Exclude<
 							A,
 							AnyElysiaCustomStatusResponse
@@ -1028,8 +1012,7 @@ type ExtractAllResponseFromMacro<A> =
 													200: A
 												}
 							: {})
-				>
-			}
+				}
 
 type FlattenMacroResponse<T> = T extends object
 	? '_' extends keyof T

test/types/lifecycle/soundness.ts

@@ -2305,7 +2305,7 @@ import { Prettify } from '../../../src/types'
 				}
 			},
 			b: {
-				resolve({ status }) {
+				beforeHandle({ status }) {
 					if (Math.random()) return status(401, 'b')
 				},
 				a: true
@@ -2315,7 +2315,6 @@ import { Prettify } from '../../../src/types'
 			b: true
 		})
 
-
 	type Routes = (typeof app)['~Routes']['get']['response']
 
 	expectTypeOf<Routes>().toEqualTypeOf<{
@@ -2325,6 +2324,43 @@ import { Prettify } from '../../../src/types'
 	}>
 }
 
+// Recursive macro with conflict value per status
+{
+	const app = new Elysia()
+		.macro({
+			a: {
+				resolve({ status }) {
+					if (Math.random()) return status(400, 'a')
+					if (Math.random()) return status(401, 'b')
+					if (Math.random()) return status(401, 'c')
+
+					return { a: 'a' }
+				}
+			},
+			b: {
+				resolve({ status }) {
+					if (Math.random()) return status(400, 'x')
+					if (Math.random()) return status(401, 'y')
+					if (Math.random()) return status(401, 'z')
+
+					return { b: 'b' }
+				},
+				a: true
+			}
+		})
+		.get('/', () => 'handler' as const, {
+			b: true
+		})
+
+	type Routes = (typeof app)['~Routes']['get']['response']
+
+	expectTypeOf<Routes>().toEqualTypeOf<{
+		200: 'handler'
+		400: 'a' | 'x'
+		401: 'b' | 'c' | 'y' | 'z'
+	}>
+}
+
 // Separate Box from literal status-like response in macro
 {
 	const app = new Elysia()