elysia 1.4.28 → 2.0.0-beta.0

package/dist/handler/fetch.mjs

@@ -0,0 +1,367 @@
+import { 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 { origin } from "../adapter/origin.mjs";
+import { defaultAdapter } from "../adapter/constants.mjs";
+import { createContext } from "../context.mjs";
+import { createErrorHandler } from "./error.mjs";
+import decodeComponent from "deuri";
+
+//#region src/handler/fetch.ts
+function extractPath(url, context, pathStart) {
+	const s = url.indexOf("/", pathStart);
+	const q = context.qi = url.indexOf("?", s);
+	return context.path = q === -1 ? url.slice(s) : url.substring(s, q);
+}
+function notFound(context) {
+	const set = context.set;
+	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, {
+			status: 404,
+			headers: set.headers
+		});
+	}
+	return getNotFound();
+}
+function decodeParams(params) {
+	for (const key in params) {
+		const value = params[key];
+		if (value.indexOf("%") !== -1) params[key] = decodeComponent(value) ?? value;
+	}
+	return params;
+}
+const notFoundBody = Object.freeze({ code: "NOT_FOUND" });
+function finalizeError(context, handleError, afterResponse, error) {
+	if (error === notFoundBody) error = new NotFound();
+	let resp;
+	try {
+		resp = handleError(context, error);
+	} catch (errorPipelineThrow) {
+		if (!isProduction()) console.error(errorPipelineThrow);
+		resp = internalServerErrorResponse(error);
+	}
+	if (resp instanceof Promise) return resp.then((r) => {
+		afterResponse?.(context);
+		return r;
+	}, (errorPipelineThrow) => {
+		if (!isProduction()) console.error(errorPipelineThrow);
+		const r = internalServerErrorResponse(error);
+		afterResponse?.(context);
+		return r;
+	});
+	afterResponse?.(context);
+	return resp;
+}
+const catchError = (context, handleError, afterResponse) => (error) => finalizeError(context, handleError, afterResponse, error);
+function dispatchResult(result, context, handleError, afterResponse) {
+	if (result instanceof Promise) return result.catch(catchError(context, handleError, afterResponse));
+	if (typeof result?.then === "function") return Promise.resolve(result).catch(catchError(context, handleError, afterResponse));
+	return result;
+}
+function findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS) {
+	const path = context.path;
+	if (hasWS && request.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;
+				}
+				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;
+			}
+		}
+	}
+	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) {
+		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 found = router?.find(method, path) ?? router?.find("*", path);
+	if (found) {
+		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);
+	afterResponse?.(context, 404);
+	return notFound(context);
+}
+function createFetchHandler(app) {
+	const Context = createContext(app);
+	const map = app["~map"] ?? nullObject();
+	const router = app["~router"];
+	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;
+	/**
+	* Arm `context['~sig']` unless this request is provably the untouched
+	* `Request` the Bun adapter received, in which case materializing
+	* `request.signal` is deferred to the first suspension
+	* @see `../adapter/origin`
+	*
+	* Anything without provenance, `app.handle`, every non-Bun adapter, or a
+	* `.wrap()` HOC that substituted or delayed the request, falls back to
+	* today's eager behaviour
+	*/
+	const armEager = (request, context) => {
+		if (!abortSignal || request === origin.request) return false;
+		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.
+	*/
+	const armedAbort = (request, context) => abortSignal && (context["~sig"] ??= request.signal).aborted === true;
+	const baseMapResponse = (app["~config"]?.adapter ?? defaultAdapter).response.map;
+	const mapResponseHooks = hook?.mapResponse;
+	const mapResponse = mapResponseHooks?.length ? (response, set, context) => {
+		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);
+					return run(i + 1);
+				});
+				if (result !== void 0) return baseMapResponse(result, set, request, true);
+			}
+			return baseMapResponse(response, set, request, true);
+		};
+		return run(0);
+	} : (response, set, context) => baseMapResponse(response, set, context?.request, true);
+	const handleError = createErrorHandler(hook?.error, mapResponse, void 0, app["~config"]?.allowUnsafeValidationDetails);
+	const traceHandlers = hook?.trace;
+	const hasTrace = !!traceHandlers?.length;
+	const traceProvider = hasTrace ? app["~resolvedCapability"]("trace") : void 0;
+	const tracePhases = hasTrace ? traceProvider.unionTracePhases(traceHandlers) : null;
+	const traceRequestPhase = hasTrace && (tracePhases === null || tracePhases.has("request"));
+	const traceAfterResponsePhase = hasTrace && (tracePhases === null || tracePhases.has("afterResponse"));
+	const tracerFactories = hasTrace ? traceHandlers.map((fn) => traceProvider.createTracer(fn)) : void 0;
+	const afterResponses = hook?.afterResponse;
+	const afterResponse = (context, status) => {
+		if (context._arf) return;
+		const queue = context["~afterResponse"];
+		if (!afterResponses?.length && !traceAfterResponsePhase && !queue?.length) return;
+		context._arf = true;
+		if (status !== void 0) context.set.status = status;
+		queueMicrotask(async () => {
+			if (afterResponses?.length || queue?.length) materializeSetHeaders(context.set);
+			if (afterResponses) for (let i = 0; i < afterResponses.length; i++) try {
+				await afterResponses[i](context);
+			} catch (e) {
+				console.error(e);
+			}
+			if (queue) for (let i = 0; i < queue.length; i++) try {
+				await queue[i](context);
+			} catch (e) {
+				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();
+				}
+			}
+		});
+	};
+	app["~finalizeError"] = (context, error) => finalizeError(context, handleError, afterResponse, error);
+	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);
+			context.server = server ?? null;
+			context.rid = requestId();
+			const traceLength = tracerFactories.length;
+			const trace = new Array(traceLength);
+			for (let i = 0; i < traceLength; i++) trace[i] = tracerFactories[i](context);
+			context.trace = trace;
+			const requestReports = new Array(traceLength);
+			for (let i = 0; i < traceLength; i++) requestReports[i] = trace[i].b(0, onRequests.length) || trace[i].begin(0, {
+				id: context.rid,
+				event: "request",
+				name: "request",
+				begin: performance.now(),
+				total: onRequests.length
+			});
+			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?.()?.({
+						id: context.rid,
+						event: "request",
+						name: onRequests[i].name || "anonymous",
+						begin: performance.now()
+					});
+					const result = asyncIndexes?.[i] ? await onRequests[i](context) : onRequests[i](context);
+					for (let i = 0; i < traceLength; i++) endReports[i]?.();
+					if (armedAbort(request, context)) {
+						for (let j = 0; j < traceLength; j++) trace[j].r(requestReports[j]);
+						return emptyResponse.clone();
+					}
+					if (result !== void 0) {
+						for (let j = 0; j < traceLength; j++) trace[j].r(requestReports[j]);
+						const response = await mapResponse(result, context.set, context);
+						afterResponse?.(context);
+						return response;
+					}
+				}
+				for (let i = 0; i < traceLength; i++) trace[i].r(requestReports[i]);
+				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);
+			}
+		};
+	}
+	if (hook?.request) {
+		const onRequests = hook.request;
+		const asyncIndexes = getAsyncIndexes(onRequests);
+		if (asyncIndexes) return async (request, server) => {
+			const context = new Context(request);
+			materializeSetHeaders(context.set);
+			if (armEager(request, context)) return emptyResponse.clone();
+			extractPath(request.url, context, pathStart);
+			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();
+					if (result !== void 0) {
+						const response = await mapResponse(result, context.set, context);
+						afterResponse?.(context);
+						return response;
+					}
+				}
+				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+			} catch (error) {
+				return finalizeError(context, handleError, afterResponse, error);
+			}
+		};
+		return (request, server) => {
+			const context = new Context(request);
+			materializeSetHeaders(context.set);
+			if (armEager(request, context)) return emptyResponse.clone();
+			extractPath(request.url, context, pathStart);
+			context.server = server ?? null;
+			try {
+				for (let i = 0; i < onRequests.length; i++) {
+					const result = onRequests[i](context);
+					if (abortSignal && context["~sig"]?.aborted) return emptyResponse.clone();
+					if (result !== void 0) {
+						const response = mapResponse(result, context.set, context);
+						if (response instanceof Promise) return response.then((response) => {
+							afterResponse?.(context);
+							return response;
+						}, catchError(context, handleError, afterResponse));
+						afterResponse?.(context);
+						return response;
+					}
+				}
+				return findRoute(context, request, map, router, hasError, handleError, afterResponse, strictPath, hasWS, hasDynamicWS);
+			} catch (error) {
+				return finalizeError(context, handleError, afterResponse, error);
+			}
+		};
+	}
+	return (request, server) => {
+		const context = new Context(request);
+		const path = extractPath(request.url, context, pathStart);
+		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);
+			}
+		} catch (error) {
+			return finalizeError(context, handleError, afterResponse, error);
+		}
+		if (hasError) return finalizeError(context, handleError, afterResponse, notFoundBody);
+		afterResponse?.(context, 404);
+		return notFound(context);
+	};
+}
+function applyHoc(app, fetch) {
+	const hoc = app["~ext"]?.hoc;
+	if (!hoc?.length) return fetch;
+	let handler = fetch;
+	for (let i = hoc.length - 1; i >= 0; i--) handler = hoc[i](handler);
+	return handler;
+}
+
+//#endregion
+export { applyHoc, createFetchHandler };

package/dist/handler/index.d.ts

@@ -0,0 +1,2 @@
+import { applyHoc, createFetchHandler } from "./fetch.js";
+export { applyHoc, createFetchHandler };

package/dist/handler/index.js

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_handler_fetch = require('./fetch.js');
+
+exports.applyHoc = require_handler_fetch.applyHoc;
+exports.createFetchHandler = require_handler_fetch.createFetchHandler;

package/dist/handler/index.mjs

@@ -0,0 +1,3 @@
+import { applyHoc, createFetchHandler } from "./fetch.mjs";
+
+export { applyHoc, createFetchHandler };

package/dist/handler/utils.d.ts

@@ -0,0 +1,15 @@
+import { MaybePromise } from "../types.js";
+import { Context } from "../context.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 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;
+//#endregion
+export { NOT_FOUND_BODY, emptyResponse, finalizeRouteError, forwardError, getAsyncIndexes, getNotFound };

package/dist/handler/utils.js

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_universal_constants = require('../universal/constants.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 });
+function forwardError(value) {
+	if (value instanceof Error) throw value;
+	return value;
+}
+function finalizeRouteError(app, context, error) {
+	const finalize = app["~finalizeError"];
+	if (!finalize) throw error;
+	return finalize(context, error);
+}
+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;
+	}
+	return asyncIndexes;
+}
+
+//#endregion
+exports.NOT_FOUND_BODY = NOT_FOUND_BODY;
+exports.emptyResponse = emptyResponse;
+exports.finalizeRouteError = finalizeRouteError;
+exports.forwardError = forwardError;
+exports.getAsyncIndexes = getAsyncIndexes;
+exports.getNotFound = getNotFound;

package/dist/handler/utils.mjs

@@ -0,0 +1,42 @@
+import { isCloudflareWorker } from "../universal/constants.mjs";
+import { PROBLEM_JSON } 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 });
+function forwardError(value) {
+	if (value instanceof Error) throw value;
+	return value;
+}
+function finalizeRouteError(app, context, error) {
+	const finalize = app["~finalizeError"];
+	if (!finalize) throw error;
+	return finalize(context, error);
+}
+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;
+	}
+	return asyncIndexes;
+}
+
+//#endregion
+export { NOT_FOUND_BODY, emptyResponse, finalizeRouteError, forwardError, getAsyncIndexes, getNotFound };