elysia 2.0.0-exp.62 → 2.0.0-exp.64

package/dist/adapter/bun/index.d.ts

@@ -1,7 +1,7 @@
 import { AnyElysia } from "../../base.js";
 import { ElysiaAdapterOptions } from "../types.js";
 //#region src/adapter/bun/index.d.ts
-declare function collectStaticRoutes(app: AnyElysia): readonly [Record<string, Record<string, Response>>, readonly []] | undefined;
+declare function collectStaticRoutes(app: AnyElysia): Record<string, Record<string, Response>> | undefined;
 declare const BunAdapter: ElysiaAdapterOptions<void>;
 //#endregion
 export { BunAdapter, collectStaticRoutes };

package/dist/adapter/bun/index.js

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_adapter_index = require('../index.js');
-const require_constants = require('../../constants.js');
 const require_utils = require('../../utils.js');
 const require_adapter_web_standard_index = require('../web-standard/index.js');
 const require_generation = require('../../generation.js');
@@ -9,6 +8,77 @@ const require_compile_handler_index = require('../../compile/handler/index.js');
 const require_route_table = require('../../route-table.js');
 
 //#region src/adapter/bun/index.ts
+function runLifecycle(epoch, callback, ...args) {
+	const invoking = epoch.invoking;
+	epoch.invoking = true;
+	try {
+		return callback(...args);
+	} finally {
+		epoch.invoking = invoking;
+	}
+}
+const unavailableFetch = () => new Response(null, {
+	headers: { connection: "close" },
+	status: 503
+});
+function reloadServer(server, serve) {
+	try {
+		server.reload(serve);
+	} catch (error) {
+		if (!serve.routes) throw error;
+		delete serve.routes;
+		console.warn("[Elysia] Native static promotion was skipped:", error);
+		try {
+			server.reload(serve);
+		} catch (fallbackError) {
+			console.error("[Elysia] Failed to reload Bun server:", fallbackError);
+			throw fallbackError;
+		}
+	}
+}
+function releaseLifecycle(app, ext, createdExt, stop, registerCleanup) {
+	if (ext.stop === stop) delete ext.stop;
+	if (ext.cleanupEpoch === registerCleanup) delete ext.cleanupEpoch;
+	if (createdExt && app["~ext"] === ext && !Object.keys(ext).length) app["~ext"] = void 0;
+}
+function clearAppServer(app, server) {
+	if (app.server === server) app.server = void 0;
+}
+async function waitForServerRequests(server, abandoned) {
+	while (server.pendingRequests && !abandoned()) await Bun.sleep(1);
+}
+async function settleServerWebSockets(lifecycle, errors) {
+	if (!lifecycle) return true;
+	lifecycle.closing = true;
+	let failed = false;
+	do {
+		for (const socket of lifecycle.sockets) if (socket.readyState < 3) try {
+			socket.terminate();
+		} catch (error) {
+			errors.push(error);
+			failed = true;
+		}
+		if (failed) return false;
+		await Bun.sleep(1);
+		const abandon = lifecycle.abandon === true;
+		for (const socket of lifecycle.sockets) if (abandon || require_utils.isSocketQuiet(socket)) {
+			delete socket.data["~lifecycleRun"];
+			lifecycle.sockets.delete(socket);
+		}
+	} while (lifecycle.sockets.size);
+	return true;
+}
+const closeServerIdle = (server, errors) => {
+	const close = server.closeIdleConnections;
+	if (!close) return true;
+	try {
+		close.call(server);
+		return true;
+	} catch (error) {
+		errors.push(error);
+		return false;
+	}
+};
 /**
 * ! This may looks like it would cause race condition, but it is not
 * Bun is single-threaded and synchronous, so the `finally` block will
@@ -26,15 +96,7 @@ const withOrigin = (fetch) => (request, server) => {
 		require_adapter_origin.origin.request = void 0;
 	}
 };
-const nativeStaticMethods = new Set([
-	"GET",
-	"POST",
-	"PUT",
-	"DELETE",
-	"PATCH",
-	"HEAD",
-	"OPTIONS"
-]);
+const isNativeStaticMethod = (method) => method === "GET" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "HEAD" || method === "OPTIONS";
 function collectStaticRoutes(app) {
 	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
@@ -44,59 +106,58 @@ function collectStaticRoutes(app) {
 	const table = app["~generation"]?.routeTable ?? app["~routeTable"];
 	const length = table?.length ?? 0;
 	if (!table || !length) return;
-	const methods = table.method;
-	const paths = table.path;
-	const handlers = table.handler;
+	const { method: methods, path: paths, handler: handlers, flags } = table;
 	let hasCandidate = false;
 	for (let i = 0; i < length; i++) {
+		if (!isNativeStaticMethod(methods[i]) || (flags[i] & require_route_table.RouteFlag.Dynamic) !== 0) continue;
 		const h = handlers[i];
-		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
-		if (!nativeStaticMethods.has(methods[i])) continue;
-		hasCandidate = true;
-		break;
+		if (typeof h !== "function" && !(h instanceof Error) && !(h instanceof Promise)) {
+			hasCandidate = true;
+			break;
+		}
 	}
 	if (!hasCandidate) return;
-	const ready = require_utils.nullObject();
 	const strictPath = frozenRoot["~config"]?.strictPath === true;
-	const seen = /* @__PURE__ */ new Map();
-	for (let i = 0; i < length; i++) seen.set(methods[i] + " " + paths[i], i);
-	let explicitPaths;
-	if (!strictPath) {
-		explicitPaths = /* @__PURE__ */ new Map();
-		for (let i = 0; i < length; i++) {
-			const method = methods[i];
-			const path = paths[i];
-			let set = explicitPaths.get(method);
-			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
-			set.add(path);
-			if (require_constants.needEncodeRegex.test(path)) {
-				const encoded = encodeURI(path);
-				if (encoded !== path) set.add(encoded);
-			}
+	const routeIndex = /* @__PURE__ */ new Map();
+	for (let i = 0; i < length; i++) {
+		const method = methods[i];
+		if (!isNativeStaticMethod(method) || (flags[i] & require_route_table.RouteFlag.Dynamic) !== 0) continue;
+		const path = paths[i];
+		let pathsByMethod = routeIndex.get(method);
+		if (!pathsByMethod) routeIndex.set(method, pathsByMethod = /* @__PURE__ */ new Map());
+		pathsByMethod.set(path, i);
+		if (!strictPath && (flags[i] & require_route_table.RouteFlag.Encode) !== 0) {
+			const encoded = encodeURI(path);
+			if (encoded !== path && !pathsByMethod.has(encoded)) pathsByMethod.set(encoded, -1);
 		}
 	}
-	const add = (method, path, value) => {
-		if (require_constants.needEncodeRegex.test(path)) path = encodeURI(path);
+	const ready = require_utils.nullObject();
+	let hasReady = false;
+	const add = (method, path, value, needsEncode) => {
+		if (needsEncode) path = encodeURI(path);
 		(ready[path] ??= require_utils.nullObject())[method] = value;
+		hasReady = true;
 	};
 	for (let i = 0; i < length; i++) {
 		const method = methods[i];
-		if (method === "WS") continue;
+		const routeFlags = flags[i];
+		if (!isNativeStaticMethod(method) || (routeFlags & require_route_table.RouteFlag.Dynamic) !== 0) continue;
+		const pathsByMethod = routeIndex.get(method);
 		const path = paths[i];
-		if (seen.get(method + " " + path) !== i) continue;
-		if (!nativeStaticMethods.has(method)) continue;
+		if (pathsByMethod.get(path) !== i) continue;
 		const h = handlers[i];
 		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
 		const value = require_compile_handler_index.buildNativeStaticResponse(require_route_table.routeRow(table, i), app);
 		if (!value) continue;
-		add(method, path, value);
-		if (!strictPath && !require_constants.isDynamicRegex.test(path)) {
+		const needsEncode = (routeFlags & require_route_table.RouteFlag.Encode) !== 0;
+		add(method, path, value, needsEncode);
+		if (!strictPath) {
 			const loose = require_utils.getLoosePath(path);
-			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
+			if (loose !== path && !pathsByMethod.has(loose)) add(method, loose, value, needsEncode);
 		}
 	}
-	if (!Object.keys(ready).length) return;
-	return [ready, []];
+	if (!hasReady) return;
+	return ready;
 }
 const BunAdapter = require_adapter_index.createAdapter({
 	name: "bun",
@@ -105,23 +166,41 @@ const BunAdapter = require_adapter_index.createAdapter({
 	parse: require_adapter_web_standard_index.WebStandardAdapter.parse,
 	response: require_adapter_web_standard_index.WebStandardAdapter.response,
 	listen(app, options, callback) {
-		const _config = app["~config"]?.serve;
+		if (app.server || app["~ext"]?.stop) throw new Error("[Elysia] Cannot call listen() while a server or teardown is active");
+		function gatedFetch(request, server) {
+			return live ? live(request, server) : Promise.resolve(ready).then(async () => {
+				if (!live) {
+					await startupShutdown;
+					throw new Error("[Elysia] Server was stopped before it was ready");
+				}
+				return live(request, server);
+			});
+		}
 		const optionsIsObject = typeof options === "object";
-		let live;
-		const gatedFetch = (request, server) => live ? live(request, server) : Promise.resolve(ready).then(() => {
-			if (!live) throw new Error("[Elysia] Server was stopped before it was ready");
-			return live(request, server);
-		});
 		const _options = optionsIsObject ? { ...options } : {
 			port: +options,
 			fetch: gatedFetch
 		};
 		if (optionsIsObject) _options.fetch = gatedFetch;
+		const _config = app["~config"]?.serve;
 		const serve = _config ? {
 			..._config,
 			..._options
 		} : _options;
+		const server = app.server = Bun.serve(serve.routes || serve.error ? {
+			...serve,
+			error: unavailableFetch,
+			routes: {}
+		} : serve);
+		let live;
+		let cancelled = false;
+		let startupShutdown;
+		let shutdownAttempt;
 		let ready;
+		let wsLifecycle;
+		let modulesReady;
+		let built;
+		let pendingSetups;
 		const build = () => {
 			const fetch = app.fetch;
 			let routes;
@@ -134,7 +213,17 @@ const BunAdapter = require_adapter_index.createAdapter({
 			if (app["~hasWS"]) {
 				const resolved = require_generation.resolvedWsOf(app);
 				if (!resolved) throw new Error("[Elysia] internal: WebSocket routes are present but no capability provider was resolved");
-				websocket = resolved.config ? Object.assign(resolved.provider.buildGlobalWSHandler(), resolved.config) : resolved.provider.buildGlobalWSHandler();
+				const handler = resolved.provider.buildGlobalWSHandler();
+				websocket = resolved.config ? Object.assign(handler, resolved.config) : handler;
+				const setter = Object.getOwnPropertyDescriptor(handler, "~lifecycle")?.set;
+				if (setter) {
+					wsLifecycle = {
+						closing: false,
+						sockets: /* @__PURE__ */ new Set(),
+						run: runLifecycle.bind(null, epoch)
+					};
+					setter.call(handler, wsLifecycle);
+				}
 			}
 			return {
 				fetch,
@@ -142,75 +231,243 @@ const BunAdapter = require_adapter_index.createAdapter({
 				websocket
 			};
 		};
-		let built;
-		const server = app.server = Bun.serve(serve);
-		const reload = () => {
+		let startupFailure;
+		let forceRequested = false;
+		let forceDone = false;
+		let nativeStopped = false;
+		let abandoned = false;
+		let published = false;
+		let cleanupCompleted = false;
+		let idleRequired = false;
+		let cleanupFailures;
+		let observedOutcome;
+		let persistentCleanup;
+		let persistentCleanupLength = -1;
+		const epochCleanup = [];
+		const createdExt = app["~ext"] === void 0;
+		const ext = app["~ext"] ??= require_utils.nullObject();
+		const epoch = {
+			setup: false,
+			invoking: false
+		};
+		const snapshotCleanup = () => {
+			if (persistentCleanupLength !== -1) return;
+			persistentCleanup = ext.cleanup;
+			persistentCleanupLength = persistentCleanup?.length ?? 0;
+		};
+		const registerCleanup = (handler) => {
+			if (ext.cleanupEpoch !== registerCleanup) return false;
+			if (!epoch.setup) throw new Error("[Elysia] .cleanup() called after its setup epoch settled");
+			if (Array.isArray(handler)) epochCleanup.push(...handler);
+			else epochCleanup.push(handler);
+			return true;
+		};
+		const gate = () => {
+			if (!published) return;
+			live = void 0;
+			if (wsLifecycle) wsLifecycle.closing = true;
 			try {
-				server.reload(serve);
+				server.reload({
+					...serve,
+					fetch: unavailableFetch,
+					error: unavailableFetch,
+					routes: {}
+				});
 			} catch (error) {
-				if (!serve.routes) throw error;
-				delete serve.routes;
-				console.warn("[Elysia] Native static promotion was skipped:", error);
-				try {
-					server.reload(serve);
-				} catch (fallbackError) {
-					console.error("[Elysia] Failed to reload Bun server:", fallbackError);
-					throw fallbackError;
+				return { error };
+			}
+		};
+		const nativeStop = async (closeActiveConnections, errors) => {
+			try {
+				await server.stop(closeActiveConnections);
+				nativeStopped = true;
+				if (closeActiveConnections) {
+					forceDone = true;
+					forceRequested = false;
+				}
+				return true;
+			} catch (error) {
+				if (closeActiveConnections) forceRequested = true;
+				errors.push(error);
+				return false;
+			}
+		};
+		const isAbandoned = () => abandoned;
+		const quiesce = async (force) => {
+			const errors = [];
+			if (!published) return {
+				errors,
+				releasable: await nativeStop(true, errors),
+				safe: true
+			};
+			if (force && !idleRequired && !wsLifecycle?.closing) {
+				const stopped = await nativeStop(true, errors);
+				return {
+					errors,
+					releasable: stopped,
+					safe: stopped
+				};
+			}
+			const gateFailure = gate();
+			if (gateFailure) errors.push(gateFailure.error);
+			let socketsSettled = await settleServerWebSockets(wsLifecycle, errors);
+			await Promise.resolve();
+			let close = forceRequested || gateFailure !== void 0 || !socketsSettled;
+			if (!close && nativeStopped) await waitForServerRequests(server, isAbandoned);
+			idleRequired = true;
+			let stopped = true;
+			while (!nativeStopped || forceRequested && !forceDone) {
+				if (nativeStopped) close = true;
+				stopped = await nativeStop(close, errors);
+				if (stopped) {
+					if (socketsSettled) socketsSettled = await settleServerWebSockets(wsLifecycle, errors);
+					continue;
 				}
+				if (close) break;
+				await waitForServerRequests(server, isAbandoned);
+				close = true;
 			}
+			let idleClosed = true;
+			if (idleRequired) {
+				idleClosed = closeServerIdle(server, errors);
+				if (idleClosed && !gateFailure) idleRequired = false;
+			}
+			const safe = socketsSettled && stopped && idleClosed && (!gateFailure || forceDone);
+			return {
+				errors,
+				releasable: safe,
+				safe
+			};
 		};
 		const setup = () => {
-			const onSetup = app["~ext"]?.setup;
+			snapshotCleanup();
+			const onSetup = ext.setup;
 			if (!onSetup) return;
-			let pendingSetups;
+			epoch.setup = true;
+			ext.cleanupEpoch = registerCleanup;
 			for (let i = 0; i < onSetup.length; i++) {
-				const result = onSetup[i](app);
-				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
+				if (cancelled) break;
+				try {
+					const result = runLifecycle(epoch, onSetup[i], app);
+					if (result && typeof result.then === "function") (pendingSetups ??= []).push(Promise.resolve(result));
+				} catch (error) {
+					if (!pendingSetups) epoch.setup = false;
+					stop(true, { error }).catch(() => {});
+					throw error;
+				}
 			}
-			if (pendingSetups) return Promise.all(pendingSetups);
+			if (pendingSetups) return Promise.all(pendingSetups).then(() => epoch.setup = false);
+			epoch.setup = false;
 		};
-		const rollback = (error) => {
-			if (app.server !== server) return;
-			try {
-				server.stop(true);
-			} catch (stopError) {
-				console.error(stopError);
-			} finally {
-				app.server = void 0;
+		const stop = (closeActiveConnections, failure) => {
+			const reentrant = epoch.invoking;
+			if (failure) startupFailure ??= failure;
+			if (closeActiveConnections === true && !forceDone) forceRequested = true;
+			cancelled = true;
+			clearAppServer(app, server);
+			let outcome;
+			if (shutdownAttempt) {
+				if (closeActiveConnections === true && !forceDone) {
+					abandoned = true;
+					if (wsLifecycle) wsLifecycle.abandon = true;
+				}
+				outcome = shutdownAttempt;
+			} else {
+				const { promise, resolve, reject } = Promise.withResolvers();
+				outcome = shutdownAttempt = promise;
+				const quiescence = quiesce(forceRequested || !published);
+				let releasable = false;
+				(async () => {
+					try {
+						await Promise.resolve();
+						if (modulesReady) try {
+							await modulesReady;
+						} catch (error) {
+							startupFailure ??= { error };
+						}
+						if (pendingSetups) {
+							const setupResults = await Promise.allSettled(pendingSetups);
+							if (!startupFailure) for (let i = 0; i < setupResults.length; i++) {
+								const result = setupResults[i];
+								if (result.status === "rejected") {
+									startupFailure = { error: result.reason };
+									break;
+								}
+							}
+						}
+						epoch.setup = false;
+						const errors = [];
+						const quiesced = await quiescence;
+						if (startupFailure) errors.push(startupFailure.error);
+						errors.push(...quiesced.errors);
+						releasable = quiesced.releasable;
+						if (!quiesced.safe) {
+							if (cleanupFailures) errors.push(...cleanupFailures);
+							require_utils.throwLifecycleErrors(errors);
+						}
+						if (!cleanupCompleted) {
+							snapshotCleanup();
+							if (ext.stop === stop) {
+								const length = persistentCleanupLength + epochCleanup.length;
+								for (let n = 0; n < length; n++) {
+									if (ext.stop !== stop) break;
+									const i = startupFailure ? length - 1 - n : n;
+									const handler = i < persistentCleanupLength ? persistentCleanup[i] : epochCleanup[i - persistentCleanupLength];
+									try {
+										await runLifecycle(epoch, handler, app);
+									} catch (error) {
+										(cleanupFailures ??= []).push(error);
+									}
+								}
+							}
+							cleanupCompleted = true;
+							epochCleanup.length = 0;
+						}
+						if (cleanupFailures) errors.push(...cleanupFailures);
+						if (releasable) releaseLifecycle(app, ext, createdExt, stop, registerCleanup);
+						require_utils.throwLifecycleErrors(errors);
+					} finally {
+						epoch.setup = false;
+						if (!releasable) shutdownAttempt = void 0;
+					}
+				})().then(resolve, reject);
 			}
-			const cleanup = app["~ext"]?.cleanup;
-			if (cleanup) for (let i = cleanup.length - 1; i >= 0; i--) try {
-				const result = cleanup[i](app);
-				if (result && typeof result.then === "function") Promise.resolve(result).catch(console.error);
-			} catch (cleanupError) {
-				console.error(cleanupError);
+			if (!published) startupShutdown ??= outcome;
+			if (!reentrant) return outcome;
+			if (observedOutcome !== outcome) {
+				observedOutcome = outcome;
+				outcome.catch((error) => {
+					console.error("[Elysia] stop() failed:", error);
+				});
 			}
-			return error;
+			return Promise.resolve();
 		};
+		ext.stop = stop;
 		const publish = () => {
-			if (app.server !== server) return;
+			if (cancelled || app.server !== server) return;
 			built ??= build();
 			live = serve.fetch = withOrigin(built.fetch);
+			published = true;
 			if (built.websocket) serve.websocket = built.websocket;
-			if (built.routes) serve.routes = built.routes[0];
-			reload();
+			if (built.routes) serve.routes = built.routes;
+			reloadServer(server, serve);
 			if (callback) callback(server);
 		};
 		const start = () => {
-			if (app.server !== server) return;
+			modulesReady = void 0;
+			if (cancelled || app.server !== server) return;
 			const setupReady = setup();
 			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
 			publish();
 		};
 		try {
-			if (app.pending) ready = app.modules.then(start);
-			else ready = Promise.resolve().then(start);
+			ready = (modulesReady = app.modules).then(start);
+			ready = ready.catch((error) => stop(true, { error }));
 			ready.catch((error) => {
 				console.error("[Elysia] listen() failed:", error);
-				return rollback(error);
 			});
 		} catch (error) {
-			rollback(error);
+			stop(true, { error }).catch(console.error);
 			throw error;
 		}
 	}