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

package/dist/handler/fetch.js

@@ -13,8 +13,8 @@ let deuri = require("deuri");
 deuri = require_runtime.__toESM(deuri);
 
 //#region src/handler/fetch.ts
-function extractPath(url, context, pathStart) {
-	const s = url.indexOf("/", pathStart);
+function extractPath(url, context) {
+	const s = url.indexOf("/", require_utils.authorityEnd(url));
 	const q = context.qi = url.indexOf("?", s);
 	return context.path = q === -1 ? url.slice(s) : url.substring(s, q);
 }
@@ -23,7 +23,7 @@ function notFound(context) {
 	if (set.cookie || require_utils.isNotEmpty(set.headers)) {
 		require_adapter_utils.handleSet(set);
 		if (!set.headers["content-type"]) require_adapter_utils.materializeSetHeaders(set)["content-type"] = require_error.PROBLEM_JSON;
-		return new Response(require_handler_utils.NOT_FOUND_BODY, {
+		return new Response(require_handler_utils.getNotFoundBody(), {
 			status: 404,
 			headers: set.headers
 		});
@@ -37,12 +37,16 @@ function decodeParams(params) {
 	}
 	return params;
 }
-const notFoundBody = Object.freeze({ code: "NOT_FOUND" });
-function finalizeError(context, handleError, afterResponse, error) {
-	if (error === notFoundBody) error = new require_error.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 (!require_universal_is_production.isProduction()) console.error(errorPipelineThrow);
 		resp = require_error.internalServerErrorResponse(error);
@@ -67,23 +71,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) {
@@ -100,7 +100,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 require_error.NotFound());
 	afterResponse?.(context, 404);
 	return notFound(context);
 }
@@ -111,10 +111,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 = require_utils.flattenChain(app["~hookChain"]);
 	const hasError = !!hook?.error;
 	const abortSignal = app["~config"]?.abortSignal !== false;
+	const watchPath = !require_universal_is_production.isProduction();
 	/**
 	* Arm `context['~sig']` unless this request is provably the untouched
 	* `Request` the Bun adapter received, in which case materializing
@@ -130,31 +130,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 ?? require_adapter_constants.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 = require_handler_error.createErrorHandler(hook?.error, mapResponse, void 0, app["~config"]?.allowUnsafeValidationDetails);
+	} : (response, set, context, sign) => finalMap(response, set, context?.request, sign);
+	const handleError = require_handler_error.createErrorHandler(hook?.error, mapResponse, app["~config"]?.allowUnsafeValidationDetails);
 	const traceHandlers = hook?.trace;
 	const hasTrace = !!traceHandlers?.length;
 	const traceProvider = hasTrace ? app["~resolvedCapability"]("trace") : void 0;
@@ -166,11 +173,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) require_adapter_utils.materializeSetHeaders(context.set);
+			let cache;
+			let reports;
+			if (traceAfterResponsePhase) {
+				cache = context.trace;
+				if (!cache && tracerFactories) {
+					context.rid ??= require_utils.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) {
@@ -185,39 +213,19 @@ function createFetchHandler(app) {
 					console.error(e);
 				}
 			}
-			if (traceAfterResponsePhase) {
-				let cache = context.trace;
-				if (!cache && tracerFactories) {
-					context.rid ??= require_utils.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 require_handler_utils.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 ? require_handler_utils.getAsyncIndexes(onRequests) : void 0;
 		return async (request, server) => {
 			const context = new Context(request);
 			require_adapter_utils.materializeSetHeaders(context.set);
 			if (armEager(request, context)) return require_handler_utils.emptyResponse.clone();
-			extractPath(request.url, context, pathStart);
+			const path = extractPath(request.url, context);
 			context.server = server ?? null;
 			context.rid = require_utils.requestId();
 			const traceLength = tracerFactories.length;
@@ -235,15 +243,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 require_handler_utils.emptyResponse.clone();
 					}
@@ -258,24 +271,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 = require_handler_utils.getAsyncIndexes(onRequests);
-		if (asyncIndexes) return async (request, server) => {
+		if (require_handler_utils.hasAsync(onRequests)) return async (request, server) => {
 			const context = new Context(request);
 			require_adapter_utils.materializeSetHeaders(context.set);
 			if (armEager(request, context)) return require_handler_utils.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 require_handler_utils.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 require_handler_utils.emptyResponse.clone();
 					if (result !== void 0) {
 						const response = await mapResponse(result, context.set, context);
 						afterResponse?.(context);
@@ -284,18 +300,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);
 			require_adapter_utils.materializeSetHeaders(context.set);
 			if (armEager(request, context)) return require_handler_utils.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 require_handler_utils.emptyResponse.clone();
 					if (result !== void 0) {
 						const response = mapResponse(result, context.set, context);
@@ -309,57 +326,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) {