elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/handler/fetch.mjs

@@ -1,8 +1,8 @@
-import { flattenChain, isNotEmpty, nullObject, requestId } from "../utils.mjs";
+import { authorityEnd, flattenChain, isNotEmpty, nullObject, requestId } from "../utils.mjs";
 import { isProduction } from "../universal/is-production.mjs";
 import { NotFound, PROBLEM_JSON, internalServerErrorResponse } from "../error.mjs";
 import { handleSet, materializeSetHeaders } from "../adapter/utils.mjs";
-import { NOT_FOUND_BODY, emptyResponse, getAsyncIndexes, getNotFound } from "./utils.mjs";
+import { drainDisposables, emptyResponse, getNotFound, getNotFoundBody, hasAsync } from "./utils.mjs";
 import { createErrorHandler } from "./error.mjs";
 import { origin } from "../adapter/origin.mjs";
 import { defaultAdapter } from "../adapter/constants.mjs";
@@ -10,8 +10,8 @@ import { createContext } from "../context.mjs";
 import decodeComponent from "deuri";
 
 //#region src/handler/fetch.ts
-function extractPath(url, context, pathStart) {
-	const s = url.indexOf("/", pathStart);
+function extractPath(url, context) {
+	const s = url.indexOf("/", authorityEnd(url));
 	const q = context.qi = url.indexOf("?", s);
 	return context.path = q === -1 ? url.slice(s) : url.substring(s, q);
 }
@@ -20,7 +20,7 @@ function notFound(context) {
 	if (set.cookie || isNotEmpty(set.headers)) {
 		handleSet(set);
 		if (!set.headers["content-type"]) materializeSetHeaders(set)["content-type"] = PROBLEM_JSON;
-		return new Response(NOT_FOUND_BODY, {
+		return new Response(getNotFoundBody(), {
 			status: 404,
 			headers: set.headers
 		});
@@ -34,12 +34,16 @@ function decodeParams(params) {
 	}
 	return params;
 }
-const notFoundBody = Object.freeze({ code: "NOT_FOUND" });
-function finalizeError(context, handleError, afterResponse, error) {
-	if (error === notFoundBody) error = new NotFound();
+const warnedPathMutation = /* @__PURE__ */ new WeakSet();
+function warnPathMutation(app) {
+	if (warnedPathMutation.has(app)) return;
+	warnedPathMutation.add(app);
+	console.warn("[elysia] context.path is readonly; request-hook rerouting will stop working in a future release.");
+}
+function finalizeError(context, handleError, afterResponse, error, sign) {
 	let resp;
 	try {
-		resp = handleError(context, error);
+		resp = handleError(context, error, sign);
 	} catch (errorPipelineThrow) {
 		if (!isProduction()) console.error(errorPipelineThrow);
 		resp = internalServerErrorResponse(error);
@@ -64,23 +68,19 @@ function dispatchResult(result, context, handleError, afterResponse) {
 }
 function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS) {
 	const path = context.path;
-	if (hasWS && request.method === "GET") {
+	const method = request.method;
+	if (hasWS && method === "GET") {
 		const handler = map["WS"]?.[path];
 		const found = handler === void 0 && hasDynamicWS ? router?.find("WS", path) : void 0;
 		if (handler !== void 0 || found) {
 			const upgrade = request.headers.get("upgrade");
 			if (upgrade && upgrade.toLowerCase() === "websocket") {
-				if (handler) {
-					const r = handler(context);
-					return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
-				}
+				if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
 				context.params = path.indexOf("%") === -1 ? found.params : decodeParams(found.params);
-				const r = found.store(context);
-				return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
+				return dispatchResult(found.store(context), context, handleError, afterResponse);
 			}
 		}
 	}
-	const method = request.method;
 	const methodMap = map[method];
 	let handler = methodMap?.[path];
 	if (!handler) if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
@@ -97,7 +97,7 @@ function findRoute(context, request, map, router, hasError, handleError, afterRe
 		context.params = path.indexOf("%") === -1 ? found.params : decodeParams(found.params);
 		return dispatchResult(found.store(context), context, handleError, afterResponse);
 	}
-	if (hasError) return finalizeError(context, handleError, afterResponse, notFoundBody);
+	if (hasError) return finalizeError(context, handleError, afterResponse, new NotFound());
 	afterResponse?.(context, 404);
 	return notFound(context);
 }
@@ -108,10 +108,10 @@ function createFetchHandler(app) {
 	const hasWS = !!app["~hasWS"];
 	const hasDynamicWS = hasWS && !!app["~hasDynamicWS"];
 	const strictPath = !!app["~config"]?.strictPath;
-	const pathStart = app["~config"]?.handler?.standardHostname === false ? 7 : 11;
 	const hook = flattenChain(app["~hookChain"]);
 	const hasError = !!hook?.error;
 	const abortSignal = app["~config"]?.abortSignal !== false;
+	const watchPath = !isProduction();
 	/**
 	* Arm `context['~sig']` unless this request is provably the untouched
 	* `Request` the Bun adapter received, in which case materializing
@@ -127,31 +127,38 @@ function createFetchHandler(app) {
 		return (context["~sig"] = request.signal).aborted;
 	};
 	/**
-	* Post-suspension check: arm if nobody has yet, then read. Only emitted on
-	* lanes that actually awaited, so a deferred request that never suspends
-	* never reaches it.
+	* Peek after each callback. The actual await branch arms deferred requests;
+	* immediate callbacks must not materialize a signal just for this check.
 	*/
-	const armedAbort = (request, context) => abortSignal && (context["~sig"] ??= request.signal).aborted === true;
+	const armedAbort = (context) => abortSignal && context["~sig"]?.aborted === true;
 	const baseMapResponse = (app["~config"]?.adapter ?? defaultAdapter).response.map;
+	function finalMap(response, set, request, sign) {
+		if (!sign) return baseMapResponse(response, set, request, true);
+		let pending;
+		try {
+			pending = sign(set);
+		} catch {}
+		return pending ? pending.then(() => baseMapResponse(response, set, request, true), () => baseMapResponse(response, set, request, true)) : baseMapResponse(response, set, request, true);
+	}
 	const mapResponseHooks = hook?.mapResponse;
-	const mapResponse = mapResponseHooks?.length ? (response, set, context) => {
+	const mapResponse = mapResponseHooks?.length ? (response, set, context, sign) => {
 		if (!context) return baseMapResponse(response, set, void 0, true);
 		context.responseValue = response;
 		const request = context.request;
 		const run = (i) => {
 			for (; i < mapResponseHooks.length; i++) {
 				const result = mapResponseHooks[i](context);
-				if (result instanceof Promise) return result.then((resolved) => {
-					if (resolved !== void 0) return baseMapResponse(resolved, set, request, true);
+				if (typeof result?.then === "function") return Promise.resolve(result).then((resolved) => {
+					if (resolved !== void 0) return finalMap(resolved, set, request, sign);
 					return run(i + 1);
 				});
-				if (result !== void 0) return baseMapResponse(result, set, request, true);
+				if (result !== void 0) return finalMap(result, set, request, sign);
 			}
-			return baseMapResponse(response, set, request, true);
+			return finalMap(response, set, request, sign);
 		};
 		return run(0);
-	} : (response, set, context) => baseMapResponse(response, set, context?.request, true);
-	const handleError = createErrorHandler(hook?.error, mapResponse, void 0, app["~config"]?.allowUnsafeValidationDetails);
+	} : (response, set, context, sign) => finalMap(response, set, context?.request, sign);
+	const handleError = createErrorHandler(hook?.error, mapResponse, app["~config"]?.allowUnsafeValidationDetails);
 	const traceHandlers = hook?.trace;
 	const hasTrace = !!traceHandlers?.length;
 	const traceProvider = hasTrace ? app["~resolvedCapability"]("trace") : void 0;
@@ -163,11 +170,32 @@ function createFetchHandler(app) {
 	const afterResponse = (context, status) => {
 		if (context._arf) return;
 		const queue = context["~afterResponse"];
-		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length) return;
+		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length && !context["~dispose"]) return;
 		context._arf = true;
 		if (status !== void 0) context.set.status = status;
 		queueMicrotask(async () => {
 			if (afterResponses?.length || queue?.length) materializeSetHeaders(context.set);
+			let cache;
+			let reports;
+			if (traceAfterResponsePhase) {
+				cache = context.trace;
+				if (!cache && tracerFactories) {
+					context.rid ??= requestId();
+					cache = tracerFactories.map((f) => f(context));
+					context.trace = cache;
+				}
+				if (cache) {
+					const total = afterResponses?.length ?? 0;
+					reports = new Array(cache.length);
+					for (let i = 0; i < cache.length; i++) reports[i] = cache[i].b(7, total) || cache[i].begin(7, {
+						id: context.rid ?? "",
+						event: "afterResponse",
+						name: "afterResponse",
+						begin: performance.now(),
+						total
+					});
+				}
+			}
 			if (afterResponses) for (let i = 0; i < afterResponses.length; i++) try {
 				await afterResponses[i](context);
 			} catch (e) {
@@ -182,39 +210,19 @@ function createFetchHandler(app) {
 					console.error(e);
 				}
 			}
-			if (traceAfterResponsePhase) {
-				let cache = context.trace;
-				if (!cache && tracerFactories) {
-					context.rid ??= requestId();
-					cache = tracerFactories.map((f) => f(context));
-					context.trace = cache;
-				}
-				if (cache) for (let i = 0; i < cache.length; i++) {
-					const fast = cache[i].b(7, afterResponses?.length ?? 0);
-					if (fast) {
-						cache[i].r(fast);
-						continue;
-					}
-					cache[i].begin(7, {
-						id: context.rid ?? "",
-						event: "afterResponse",
-						name: "afterResponse",
-						begin: performance.now(),
-						total: afterResponses?.length ?? 0
-					}).resolve();
-				}
-			}
+			await drainDisposables(context);
+			if (reports) for (let i = 0; i < reports.length; i++) cache[i].r(reports[i]);
 		});
 	};
-	app["~finalizeError"] = (context, error) => finalizeError(context, handleError, afterResponse, error);
+	const fail = (context, error, sign) => finalizeError(context, handleError, afterResponse, error, sign);
+	app["~finalizeError"] = fail;
 	if (traceRequestPhase) {
 		const onRequests = hook?.request ?? [];
-		const asyncIndexes = onRequests.length ? getAsyncIndexes(onRequests) : void 0;
 		return async (request, server) => {
 			const context = new Context(request);
 			materializeSetHeaders(context.set);
 			if (armEager(request, context)) return emptyResponse.clone();
-			extractPath(request.url, context, pathStart);
+			const path = extractPath(request.url, context);
 			context.server = server ?? null;
 			context.rid = requestId();
 			const traceLength = tracerFactories.length;
@@ -232,15 +240,20 @@ function createFetchHandler(app) {
 			try {
 				const endReports = new Array(traceLength);
 				for (let i = 0; i < onRequests.length; i++) {
-					for (let j = 0; j < traceLength; j++) endReports[j] = requestReports[j].resolveChild?.shift?.()?.({
+					for (let j = 0; j < traceLength; j++) endReports[j] = requestReports[j].shift?.()?.({
 						id: context.rid,
 						event: "request",
 						name: onRequests[i].name || "anonymous",
 						begin: performance.now()
 					});
-					const result = asyncIndexes?.[i] ? await onRequests[i](context) : onRequests[i](context);
+					let result = onRequests[i](context);
+					if (typeof result?.then === "function") {
+						if (abortSignal) context["~sig"] ??= request.signal;
+						result = await result;
+					}
+					if (watchPath && context.path !== path) warnPathMutation(app);
 					for (let i = 0; i < traceLength; i++) endReports[i]?.();
-					if (armedAbort(request, context)) {
+					if (armedAbort(context)) {
 						for (let j = 0; j < traceLength; j++) trace[j].r(requestReports[j]);
 						return emptyResponse.clone();
 					}
@@ -255,24 +268,27 @@ function createFetchHandler(app) {
 				return await findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
 			} catch (error) {
 				for (let i = 0; i < traceLength; i++) trace[i].r(requestReports[i], error);
-				return finalizeError(context, handleError, afterResponse, error);
+				return fail(context, error);
 			}
 		};
 	}
 	if (hook?.request) {
 		const onRequests = hook.request;
-		const asyncIndexes = getAsyncIndexes(onRequests);
-		if (asyncIndexes) return async (request, server) => {
+		if (hasAsync(onRequests)) return async (request, server) => {
 			const context = new Context(request);
 			materializeSetHeaders(context.set);
 			if (armEager(request, context)) return emptyResponse.clone();
-			extractPath(request.url, context, pathStart);
+			const path = extractPath(request.url, context);
 			context.server = server ?? null;
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
-					let result = asyncIndexes?.[i] ? await onRequests[i](context) : onRequests[i](context);
-					if (result instanceof Promise) result = await result;
-					if (armedAbort(request, context)) return emptyResponse.clone();
+					let result = onRequests[i](context);
+					if (typeof result?.then === "function") {
+						if (abortSignal) context["~sig"] ??= request.signal;
+						result = await result;
+					}
+					if (watchPath && context.path !== path) warnPathMutation(app);
+					if (armedAbort(context)) return emptyResponse.clone();
 					if (result !== void 0) {
 						const response = await mapResponse(result, context.set, context);
 						afterResponse?.(context);
@@ -281,18 +297,19 @@ function createFetchHandler(app) {
 				}
 				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
 			} catch (error) {
-				return finalizeError(context, handleError, afterResponse, error);
+				return fail(context, error);
 			}
 		};
 		return (request, server) => {
 			const context = new Context(request);
 			materializeSetHeaders(context.set);
 			if (armEager(request, context)) return emptyResponse.clone();
-			extractPath(request.url, context, pathStart);
+			const path = extractPath(request.url, context);
 			context.server = server ?? null;
 			try {
 				for (let i = 0; i < onRequests.length; i++) {
 					const result = onRequests[i](context);
+					if (watchPath && context.path !== path) warnPathMutation(app);
 					if (abortSignal && context["~sig"]?.aborted) return emptyResponse.clone();
 					if (result !== void 0) {
 						const response = mapResponse(result, context.set, context);
@@ -306,57 +323,19 @@ function createFetchHandler(app) {
 				}
 				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
 			} catch (error) {
-				return finalizeError(context, handleError, afterResponse, error);
+				return fail(context, error);
 			}
 		};
 	}
 	return (request, server) => {
 		const context = new Context(request);
-		const path = extractPath(request.url, context, pathStart);
+		extractPath(request.url, context);
 		context.server = server ?? null;
-		const method = request.method;
-		if (hasWS && method === "GET") {
-			const handler = map["WS"]?.[path];
-			const found = handler === void 0 && hasDynamicWS ? router?.find("WS", path) : void 0;
-			if (handler !== void 0 || found) {
-				const upgrade = request.headers.get("upgrade");
-				if (upgrade && upgrade.toLowerCase() === "websocket") try {
-					if (handler) {
-						const r = handler(context);
-						return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
-					}
-					context.params = path.indexOf("%") === -1 ? found.params : decodeParams(found.params);
-					const r = found.store(context);
-					return r instanceof Promise ? r.catch(catchError(context, handleError, afterResponse)) : r;
-				} catch (error) {
-					return finalizeError(context, handleError, afterResponse, error);
-				}
-			}
-		}
 		try {
-			const methodMap = map[method];
-			let handler = methodMap?.[path];
-			if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
-			if (!strictPath && path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
-				const loose = path.slice(0, -1);
-				handler = methodMap?.[loose];
-				if (!handler) {
-					const anyMap = map["*"];
-					handler = anyMap?.[path] ?? anyMap?.[loose];
-				}
-			} else handler = map["*"]?.[path];
-			if (handler) return dispatchResult(handler(context), context, handleError, afterResponse);
-			const result = router?.find(method, path) ?? router?.find("*", path);
-			if (result) {
-				context.params = path.indexOf("%") === -1 ? result.params : decodeParams(result.params);
-				return dispatchResult(result.store(context), context, handleError, afterResponse);
-			}
+			return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
 		} catch (error) {
-			return finalizeError(context, handleError, afterResponse, error);
+			return fail(context, error);
 		}
-		if (hasError) return finalizeError(context, handleError, afterResponse, notFoundBody);
-		afterResponse?.(context, 404);
-		return notFound(context);
 	};
 }
 function applyHoc(app, fetch) {

package/dist/handler/utils.d.ts

@@ -1,15 +1,21 @@
-import { MaybePromise } from "../types.js";
 import { Context } from "../context.js";
+import { MaybePromise } from "../types.js";
 import { AnyElysia } from "../base.js";
 
 //#region src/handler/utils.d.ts
 declare const emptyResponse: Response | {
   clone: () => Response;
 };
-declare const NOT_FOUND_BODY: string;
-declare const getNotFound: () => Response;
+declare function getNotFoundBody(): string;
+declare function getNotFound(): Response;
 declare function forwardError<T>(value: T): T;
-declare function finalizeRouteError(app: AnyElysia, context: Partial<Context>, error: unknown): MaybePromise<Response>;
-declare function getAsyncIndexes(onRequests: Function[]): (true | undefined)[] | undefined;
+declare function returnedErrorClasses(hook: {
+  error?: unknown;
+} | undefined, root: AnyElysia): Function[] | undefined;
+declare const forwardErrorOf: (classes: Function[]) => <T>(value: T) => T;
+declare function finalizeRouteError(app: AnyElysia, context: Partial<Context>, error: unknown, sign?: (set: Context['set']) => unknown): MaybePromise<Response>;
+declare function registerDeriveDisposable(context: any, value: unknown, scan?: any): void;
+declare function drainDisposables(context: any): Promise<void>;
+declare const hasAsync: (fns: Function[]) => boolean;
 //#endregion
-export { NOT_FOUND_BODY, emptyResponse, finalizeRouteError, forwardError, getAsyncIndexes, getNotFound };
+export { drainDisposables, emptyResponse, finalizeRouteError, forwardError, forwardErrorOf, getNotFound, getNotFoundBody, hasAsync, registerDeriveDisposable, returnedErrorClasses };

package/dist/handler/utils.js

@@ -1,48 +1,104 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../universal/constants.js');
+const require_utils = require('../utils.js');
+const require_universal_env = require('../universal/env.js');
 const require_error = require('../error.js');
 const require_compile_utils = require('../compile/utils.js');
 
 //#region src/handler/utils.ts
-const emptyResponse = require_universal_constants.isCloudflareWorker ? { clone: () => new Response(null) } : new Response(null);
-function cachedResponse(body, status, headers) {
-	let cached;
-	return () => require_universal_constants.isCloudflareWorker ? new Response(body, {
-		status,
-		headers
-	}) : (cached ??= new Response(body, {
-		status,
-		headers
-	})).clone();
-}
-const NOT_FOUND_BODY = JSON.stringify({
-	type: "not-found",
-	title: "Not Found",
-	status: 404
-});
-const getNotFound = cachedResponse(NOT_FOUND_BODY, 404, { "content-type": require_error.PROBLEM_JSON });
+const isPreallocateResponseUnsafe = require_universal_constants.isCloudflareWorker || require_universal_constants.isFastly || require_universal_env.env.ELYSIA_PREALLOCATE_RESPONSE === "false";
+const emptyResponse = isPreallocateResponseUnsafe ? { clone: () => new Response(null) } : new Response(null);
+let notFoundBase;
+let notFoundBody;
+let notFoundResponse;
+function getNotFoundBody() {
+	const base = require_error.HTTPError.typeBase;
+	if (notFoundBody === void 0 || base !== notFoundBase) {
+		notFoundBase = base;
+		notFoundResponse = void 0;
+		notFoundBody = JSON.stringify({
+			type: require_error.problemTypeOf("not-found"),
+			code: "not-found",
+			status: 404,
+			title: "Not Found"
+		});
+	}
+	return notFoundBody;
+}
+const notFoundInit = {
+	status: 404,
+	headers: { "content-type": require_error.PROBLEM_JSON }
+};
+function getNotFound() {
+	const body = getNotFoundBody();
+	if (isPreallocateResponseUnsafe) return new Response(body, notFoundInit);
+	return (notFoundResponse ??= new Response(body, notFoundInit)).clone();
+}
 function forwardError(value) {
 	if (value instanceof Error) throw value;
 	return value;
 }
-function finalizeRouteError(app, context, error) {
+const chainErrorClasses = /* @__PURE__ */ new WeakMap();
+function collectErrorClasses(error, into) {
+	if (!error) return into;
+	const list = Array.isArray(error) ? error : [error];
+	for (let i = 0; i < list.length; i++) {
+		const C = list[i]?.["~errorClass"];
+		if (C && !into?.includes(C)) (into ??= []).push(C);
+	}
+	return into;
+}
+function returnedErrorClasses(hook, root) {
+	const head = root["~hookChain"];
+	let rootClasses = head && chainErrorClasses.get(head);
+	if (head && rootClasses === void 0) chainErrorClasses.set(head, rootClasses = collectErrorClasses(require_utils.flattenChain(head)?.error, void 0) ?? null);
+	return collectErrorClasses(hook?.error, rootClasses?.slice());
+}
+const forwardErrorOf = (classes) => (value) => {
+	if (value instanceof Error) throw value;
+	for (let i = 0; i < classes.length; i++) if (value instanceof classes[i]) throw value;
+	return value;
+};
+function finalizeRouteError(app, context, error, sign) {
 	const finalize = app["~finalizeError"];
 	if (!finalize) throw error;
-	return finalize(context, error);
+	return finalize(context, error, sign);
+}
+function registerDeriveDisposable(context, value, scan = context) {
+	if (!require_utils.isDisposable(value)) return;
+	if (require_utils.isSingleton(value)) return;
+	for (const key in scan) if (scan[key] === value) return;
+	const disposable = value;
+	const asyncDispose = disposable[Symbol.asyncDispose];
+	const dispose = typeof asyncDispose === "function" ? asyncDispose : disposable[Symbol.dispose];
+	(context["~dispose"] ??= []).push(() => dispose.call(value));
 }
-function getAsyncIndexes(onRequests) {
-	let asyncIndexes;
-	for (let i = 0; i < onRequests.length; i++) if (require_compile_utils.isAsyncFunction(onRequests[i]) || require_compile_utils.mayReturnPromise(onRequests[i])) {
-		asyncIndexes ??= new Array(onRequests.length);
-		asyncIndexes[i] = true;
+async function drainDisposables(context) {
+	const stack = context["~dispose"];
+	if (!stack) return;
+	try {
+		if (!Array.isArray(stack)) throw new TypeError("Invalid disposable stack");
+		const errors = [];
+		while (stack.length) try {
+			await stack.pop()();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length) throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Multiple disposers failed");
+	} catch (error) {
+		console.error(error);
 	}
-	return asyncIndexes;
 }
+const hasAsync = (fns) => fns.some((fn) => require_compile_utils.isAsyncFunction(fn) || require_compile_utils.mayReturnPromise(fn));
 
 //#endregion
-exports.NOT_FOUND_BODY = NOT_FOUND_BODY;
+exports.drainDisposables = drainDisposables;
 exports.emptyResponse = emptyResponse;
 exports.finalizeRouteError = finalizeRouteError;
 exports.forwardError = forwardError;
-exports.getAsyncIndexes = getAsyncIndexes;
-exports.getNotFound = getNotFound;
+exports.forwardErrorOf = forwardErrorOf;
+exports.getNotFound = getNotFound;
+exports.getNotFoundBody = getNotFoundBody;
+exports.hasAsync = hasAsync;
+exports.registerDeriveDisposable = registerDeriveDisposable;
+exports.returnedErrorClasses = returnedErrorClasses;

package/dist/handler/utils.mjs

@@ -1,42 +1,94 @@
-import { isCloudflareWorker } from "../universal/constants.mjs";
-import { PROBLEM_JSON } from "../error.mjs";
+import { isCloudflareWorker, isFastly } from "../universal/constants.mjs";
+import { flattenChain, isDisposable, isSingleton } from "../utils.mjs";
+import { env } from "../universal/env.mjs";
+import { HTTPError, PROBLEM_JSON, problemTypeOf } from "../error.mjs";
 import { isAsyncFunction, mayReturnPromise } from "../compile/utils.mjs";
 
 //#region src/handler/utils.ts
-const emptyResponse = isCloudflareWorker ? { clone: () => new Response(null) } : new Response(null);
-function cachedResponse(body, status, headers) {
-	let cached;
-	return () => isCloudflareWorker ? new Response(body, {
-		status,
-		headers
-	}) : (cached ??= new Response(body, {
-		status,
-		headers
-	})).clone();
-}
-const NOT_FOUND_BODY = JSON.stringify({
-	type: "not-found",
-	title: "Not Found",
-	status: 404
-});
-const getNotFound = cachedResponse(NOT_FOUND_BODY, 404, { "content-type": PROBLEM_JSON });
+const isPreallocateResponseUnsafe = isCloudflareWorker || isFastly || env.ELYSIA_PREALLOCATE_RESPONSE === "false";
+const emptyResponse = isPreallocateResponseUnsafe ? { clone: () => new Response(null) } : new Response(null);
+let notFoundBase;
+let notFoundBody;
+let notFoundResponse;
+function getNotFoundBody() {
+	const base = HTTPError.typeBase;
+	if (notFoundBody === void 0 || base !== notFoundBase) {
+		notFoundBase = base;
+		notFoundResponse = void 0;
+		notFoundBody = JSON.stringify({
+			type: problemTypeOf("not-found"),
+			code: "not-found",
+			status: 404,
+			title: "Not Found"
+		});
+	}
+	return notFoundBody;
+}
+const notFoundInit = {
+	status: 404,
+	headers: { "content-type": PROBLEM_JSON }
+};
+function getNotFound() {
+	const body = getNotFoundBody();
+	if (isPreallocateResponseUnsafe) return new Response(body, notFoundInit);
+	return (notFoundResponse ??= new Response(body, notFoundInit)).clone();
+}
 function forwardError(value) {
 	if (value instanceof Error) throw value;
 	return value;
 }
-function finalizeRouteError(app, context, error) {
+const chainErrorClasses = /* @__PURE__ */ new WeakMap();
+function collectErrorClasses(error, into) {
+	if (!error) return into;
+	const list = Array.isArray(error) ? error : [error];
+	for (let i = 0; i < list.length; i++) {
+		const C = list[i]?.["~errorClass"];
+		if (C && !into?.includes(C)) (into ??= []).push(C);
+	}
+	return into;
+}
+function returnedErrorClasses(hook, root) {
+	const head = root["~hookChain"];
+	let rootClasses = head && chainErrorClasses.get(head);
+	if (head && rootClasses === void 0) chainErrorClasses.set(head, rootClasses = collectErrorClasses(flattenChain(head)?.error, void 0) ?? null);
+	return collectErrorClasses(hook?.error, rootClasses?.slice());
+}
+const forwardErrorOf = (classes) => (value) => {
+	if (value instanceof Error) throw value;
+	for (let i = 0; i < classes.length; i++) if (value instanceof classes[i]) throw value;
+	return value;
+};
+function finalizeRouteError(app, context, error, sign) {
 	const finalize = app["~finalizeError"];
 	if (!finalize) throw error;
-	return finalize(context, error);
+	return finalize(context, error, sign);
+}
+function registerDeriveDisposable(context, value, scan = context) {
+	if (!isDisposable(value)) return;
+	if (isSingleton(value)) return;
+	for (const key in scan) if (scan[key] === value) return;
+	const disposable = value;
+	const asyncDispose = disposable[Symbol.asyncDispose];
+	const dispose = typeof asyncDispose === "function" ? asyncDispose : disposable[Symbol.dispose];
+	(context["~dispose"] ??= []).push(() => dispose.call(value));
 }
-function getAsyncIndexes(onRequests) {
-	let asyncIndexes;
-	for (let i = 0; i < onRequests.length; i++) if (isAsyncFunction(onRequests[i]) || mayReturnPromise(onRequests[i])) {
-		asyncIndexes ??= new Array(onRequests.length);
-		asyncIndexes[i] = true;
+async function drainDisposables(context) {
+	const stack = context["~dispose"];
+	if (!stack) return;
+	try {
+		if (!Array.isArray(stack)) throw new TypeError("Invalid disposable stack");
+		const errors = [];
+		while (stack.length) try {
+			await stack.pop()();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length) throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Multiple disposers failed");
+	} catch (error) {
+		console.error(error);
 	}
-	return asyncIndexes;
 }
+const hasAsync = (fns) => fns.some((fn) => isAsyncFunction(fn) || mayReturnPromise(fn));
 
 //#endregion
-export { NOT_FOUND_BODY, emptyResponse, finalizeRouteError, forwardError, getAsyncIndexes, getNotFound };
+export { drainDisposables, emptyResponse, finalizeRouteError, forwardError, forwardErrorOf, getNotFound, getNotFoundBody, hasAsync, registerDeriveDisposable, returnedErrorClasses };