elysia 2.0.0-beta.2 → 2.0.0-beta.4

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

@@ -9,6 +9,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 +97,6 @@ const withOrigin = (fetch) => (request, server) => {
 		require_adapter_origin.origin.request = void 0;
 	}
 };
-const nativeStaticMethods = new Set([
-	"GET",
-	"POST",
-	"PUT",
-	"DELETE",
-	"PATCH",
-	"HEAD",
-	"OPTIONS"
-]);
 function collectStaticRoutes(app) {
 	if (app["~config"]?.nativeStaticResponse === false) return;
 	app.fetch;
@@ -44,9 +106,16 @@ 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 } = table;
+	const nativeStaticMethods = new Set([
+		"GET",
+		"POST",
+		"PUT",
+		"DELETE",
+		"PATCH",
+		"HEAD",
+		"OPTIONS"
+	]);
 	let hasCandidate = false;
 	for (let i = 0; i < length; i++) {
 		const h = handlers[i];
@@ -85,18 +154,19 @@ function collectStaticRoutes(app) {
 		const path = paths[i];
 		if (seen.get(method + " " + path) !== i) continue;
 		if (!nativeStaticMethods.has(method)) continue;
+		if (require_constants.isDynamicRegex.test(path)) 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)) {
+		if (!strictPath) {
 			const loose = require_utils.getLoosePath(path);
 			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
 		}
 	}
 	if (!Object.keys(ready).length) return;
-	return [ready, []];
+	return ready;
 }
 const BunAdapter = require_adapter_index.createAdapter({
 	name: "bun",
@@ -105,11 +175,18 @@ 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) {
+		if (app.server || app["~ext"]?.stop) throw new Error("[Elysia] Cannot call listen() while a server or teardown is active");
 		const _config = app["~config"]?.serve;
 		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");
+		let cancelled = false;
+		let startupShutdown;
+		let shutdownAttempt;
+		const gatedFetch = (request, server) => 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 _options = optionsIsObject ? { ...options } : {
@@ -122,6 +199,8 @@ const BunAdapter = require_adapter_index.createAdapter({
 			..._options
 		} : _options;
 		let ready;
+		let wsLifecycle;
+		let modulesReady;
 		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,
@@ -143,74 +232,249 @@ const BunAdapter = require_adapter_index.createAdapter({
 			};
 		};
 		let built;
-		const server = app.server = Bun.serve(serve);
-		const reload = () => {
+		let pendingSetups;
+		const server = app.server = Bun.serve(serve.routes || serve.error ? {
+			...serve,
+			error: unavailableFetch,
+			routes: {}
+		} : serve);
+		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;
 		}
 	}