wip

Author: macabeus

src/compose.ts

@@ -1,4 +1,4 @@
-import type { AnyElysia } from '.'
+import type { AnyElysia, Context } from '.'
 
 import { Value } from '@sinclair/typebox/value'
 import { TypeBoxError, type TAnySchema, type TSchema } from '@sinclair/typebox'
@@ -1515,7 +1515,7 @@ export const composeHandler = ({
 				mapResponseReporter.resolve()
 
 				fnLiteral += encodeCookie
-				fnLiteral += `return mapEarlyResponse(${saveResponse}be,c.set${
+				fnLiteral += `return mapEarlyResponse(handleErrors,${saveResponse}be,c.set${
 					mapResponseContext
 				})}\n`
 			}
@@ -1780,7 +1780,7 @@ export const composeHandler = ({
 			`c.code=error.code??error[ERROR_CODE]??"UNKNOWN"}` +
 			`let er\n`
 
-		for (let i = 0; i < hooks.error.length; i++) {
+		for (let i = 0; i < hooks.error.length; i++) { //
 			const endUnit = errorReporter.resolveChild(hooks.error[i].fn.name)
 
 			if (isAsync(hooks.error[i]))
@@ -1815,7 +1815,7 @@ export const composeHandler = ({
 
 			mapResponseReporter.resolve()
 
-			fnLiteral += `er=mapEarlyResponse(er,set${mapResponseContext})\n`
+			fnLiteral += `er=mapEarlyResponse(handleErrors,er,set${mapResponseContext})\n`
 			fnLiteral += `if(er){`
 
 			if (hasTrace) {
@@ -1919,6 +1919,8 @@ export const composeHandler = ({
 
 	init += fnLiteral + '}'
 
+	console.log(init)
+
 	try {
 		if (asManifest) return Function('hooks', init) as any
 
@@ -1934,7 +1936,16 @@ export const composeHandler = ({
 			utils: {
 				mapResponse: adapterHandler.mapResponse,
 				mapCompactResponse: adapterHandler.mapCompactResponse,
-				mapEarlyResponse: adapterHandler.mapEarlyResponse,
+				mapEarlyResponse: (handleErrors: any, response: unknown, set: Context['set'], ...params: unknown[]) => {
+					if (response instanceof ElysiaCustomStatusResponse) {
+						for (let i = 0; i < handleErrors.length; i++) {
+							const errorResponse = handleErrors[i]({ error: response })
+							if (errorResponse) return new Response(errorResponse)
+						}
+					}
+
+					return adapterHandler.mapEarlyResponse(response, set, ...params)
+				},
 				parseQuery,
 				parseQueryFromURL,
 				isNotEmpty
@@ -2137,7 +2148,7 @@ export const composeGeneralHandler = (
 
 			if (withReturn) {
 				fnLiteral +=
-					`re=mapEarlyResponse(` +
+					`re=mapEarlyResponse(handleErrors,` +
 					`${maybeAsync ? 'await ' : ''}onRequest[${i}](c),` +
 					`c.set)\n`
 

src/dynamic-handle.ts

@@ -3,6 +3,7 @@ import type { AnyElysia } from '.'
 import {
 	ElysiaCustomStatusResponse,
 	ElysiaErrors,
+	error,
 	NotFoundError,
 	ValidationError
 } from './error'
@@ -14,7 +15,7 @@ import { parseQuery } from './fast-querystring'
 import { redirect, signCookie, StatusMap } from './utils'
 import { parseCookie } from './cookies'
 
-import type { Handler, LifeCycleStore, SchemaValidator } from './types'
+import type { Handler, HookContainer, LifeCycleStore, SchemaValidator } from './types'
 import { TransformDecodeError } from '@sinclair/typebox/value'
 
 // JIT Handler
@@ -51,12 +52,25 @@ export const createDynamicHandler = (app: AnyElysia) => {
 				request,
 				path,
 				qi,
-				redirect
+				redirect,
+				error,
 			}
 		) as unknown as Context & {
 			response: unknown
 		}
 
+		const getLocalError = (response: unknown, hookError: HookContainer[]): Result | undefined => {
+			if (response instanceof ElysiaCustomStatusResponse) {
+				for (let i = 0; i < hookError.length; i++) {
+					const errorResponse = hookError[i].fn({ ...context, error: response })
+					if (errorResponse) return errorResponse
+				}
+			
+				const result = mapEarlyResponse(response, context.set)
+				if (result) return result as Result
+			}
+		}
+
 		try {
 			for (let i = 0; i < app.event.request.length; i++) {
 				const onRequest = app.event.request[i].fn
@@ -295,11 +309,10 @@ export const createDynamicHandler = (app: AnyElysia) => {
 				const hook = hooks.beforeHandle[i]
 				let response = hook.fn(context)
 
-				if (hook.subType === 'resolve') {
-					if (response instanceof ElysiaCustomStatusResponse) {
-						const result = mapEarlyResponse(response, context.set)
-						if (result) return (context.response = result) as Response
-					}
+				const localError = getLocalError(response, hooks.error)
+				if (localError) {
+					response = localError
+				} else if (hook.subType === 'resolve') {
 					if (response instanceof Promise)
 						Object.assign(context, await response)
 					else Object.assign(context, response)
@@ -337,6 +350,9 @@ export const createDynamicHandler = (app: AnyElysia) => {
 			let response = typeof handle === 'function' ? handle(context) : handle
 			if (response instanceof Promise) response = await response
 
+			const localError = getLocalError(response, hooks.error)
+			if (localError) response = localError
+
 			if (!hooks.afterHandle.length) {
 				const status =
 					response instanceof ElysiaCustomStatusResponse
@@ -374,23 +390,21 @@ export const createDynamicHandler = (app: AnyElysia) => {
 					if (newResponse instanceof Promise)
 						newResponse = await newResponse
 
-					const result = mapEarlyResponse(newResponse, context.set)
-					if (result !== undefined) {
+					const localError = getLocalError(newResponse, hooks.error)
+					if (localError !== undefined) {
 						const responseValidator =
 							// @ts-expect-error
 							validator?.response?.[result.status]
 
-						if (responseValidator?.Check(result) === false)
+						if (responseValidator?.Check(localError) === false)
 							throw new ValidationError(
 								'response',
 								responseValidator,
-								result
+								localError
 							)
 						else if (responseValidator?.Decode)
 							response = responseValidator.Decode(response)
-
-						// @ts-expect-error
-						return (context.response = result)
+						else response = localError
 					}
 				}
 			}

test/lifecycle/error.test.ts

@@ -272,4 +272,84 @@ describe('error', () => {
 			somePretty: 'json'
 		})
 	})
+
+	describe('handle scoped error', async () => {
+		await Bun.sleep(200)
+
+		describe('when calling "error" function from "beforeHandle"', () => {
+			const route = new Elysia()
+				.get("/", () => "it won't run", {
+					beforeHandle({ error }) {
+						return error(401)
+					},
+					error({ error }) {
+						return `scoped error: ${(error as any).code}`
+					},
+				}).onError(() => {
+					return "global error handler won't be used"
+				})
+
+			it('when aot is on', async () => {
+				const api = new Elysia().use(route)
+
+				const result = await api.handle(new Request('http://localhost/'))
+
+				expect(await result.text()).toBe('scoped error: 401')
+				expect(result.status).toBe(401)
+			})
+
+			it.only('when aot is off', async () => {
+				const api = new Elysia({ aot: false }).use(route)
+
+				const result = await api.handle(new Request('http://localhost/'))
+
+				expect(await result.text()).toBe('scoped error: 401')
+				expect(result.status).toBe(401)
+			})
+		})
+
+		describe('when calling "error" function from "afterHandle"', () => {
+			const route = new Elysia()
+				.get("/", () => "it runs", {
+					afterHandle({ error }) {
+						return error(401)
+					},
+					error({ error }) {
+						return `scoped error: ${(error as any).code}`
+					},
+				}).onError(() => {
+					return "global error handler won't be used"
+				})
+
+			it('when aot is off', async () => {
+				const api = new Elysia({ aot: false }).use(route)
+
+				const result = await api.handle(new Request('http://localhost/')).then((r) => r.text())
+
+				expect(result).toBe('scoped error: 401')
+			})
+		})
+
+		describe('when calling "error" function from the path handler', () => {
+			const route = new Elysia()
+				.get("/", ({ error }) => {
+					return error(401)
+				}, {
+					error({ error }) {
+						// @ts-expect-error
+						return `scoped error: ${error.code}`
+					},
+				}).onError(() => {
+					return "global error handler won't be used"
+				})
+
+			it('when aot is off', async () => {
+				const api = new Elysia({ aot: false }).use(route)
+
+				const result = await api.handle(new Request('http://localhost/')).then((r) => r.text())
+
+				expect(result).toBe('scoped error: 401')
+			})
+		})
+	})
 })