elysia 2.0.0-beta.3 → 2.0.0-beta.4

package/dist/adapter/bun/index.mjs

@@ -1,6 +1,6 @@
 import { createAdapter } from "../index.mjs";
 import { isDynamicRegex, needEncodeRegex } from "../../constants.mjs";
-import { flattenChain, getLoosePath, nullObject } from "../../utils.mjs";
+import { flattenChain, getLoosePath, isSocketQuiet, nullObject, throwLifecycleErrors } from "../../utils.mjs";
 import { WebStandardAdapter } from "../web-standard/index.mjs";
 import { frozenRootOf, resolvedWsOf } from "../../generation.mjs";
 import { origin } from "../origin.mjs";
@@ -8,6 +8,77 @@ import { buildNativeStaticResponse } from "../../compile/handler/index.mjs";
 import { routeRow } from "../../route-table.mjs";
 
 //#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 || 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
@@ -25,15 +96,6 @@ const withOrigin = (fetch) => (request, server) => {
 		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;
@@ -43,9 +105,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];
@@ -84,18 +153,19 @@ function collectStaticRoutes(app) {
 		const path = paths[i];
 		if (seen.get(method + " " + path) !== i) continue;
 		if (!nativeStaticMethods.has(method)) continue;
+		if (isDynamicRegex.test(path)) continue;
 		const h = handlers[i];
 		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
 		const value = buildNativeStaticResponse(routeRow(table, i), app);
 		if (!value) continue;
 		add(method, path, value);
-		if (!strictPath && !isDynamicRegex.test(path)) {
+		if (!strictPath) {
 			const loose = 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 = createAdapter({
 	name: "bun",
@@ -104,11 +174,18 @@ const BunAdapter = createAdapter({
 	parse: WebStandardAdapter.parse,
 	response: 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 } : {
@@ -121,6 +198,8 @@ const BunAdapter = createAdapter({
 			..._options
 		} : _options;
 		let ready;
+		let wsLifecycle;
+		let modulesReady;
 		const build = () => {
 			const fetch = app.fetch;
 			let routes;
@@ -133,7 +212,17 @@ const BunAdapter = createAdapter({
 			if (app["~hasWS"]) {
 				const resolved = 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,74 +231,249 @@ const BunAdapter = 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"] ??= 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);
+							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);
+						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;
 		}
 	}

package/dist/adapter/utils.js

@@ -158,10 +158,12 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 			return new Response(generator, { headers: { "content-type": "application/octet-stream" } });
 		}
 		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
+		const sourceIterator = typeof generator.next === "function" ? generator : void 0;
 		let init = typedSSE ? void 0 : generator.next?.();
 		if (set) handleSet(set);
 		if (init instanceof Promise) init = await init;
-		if (init?.value instanceof ReadableStream) generator = init.value;
+		const yieldedStream = init?.value instanceof ReadableStream;
+		if (yieldedStream) generator = init.value;
 		else if (init && (typeof init?.done === "undefined" || init?.done)) {
 			if (set) return mapResponse(init.value, set, request, owned);
 			return mapCompactResponse(init.value, request, owned);
@@ -195,8 +197,32 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				connection: "keep-alive"
 			}
 		};
-		const iterator = typeof generator.next === "function" ? generator : generator[Symbol.asyncIterator]();
+		const sourceStream = generator instanceof ReadableStream ? generator : void 0;
+		let streamReader;
+		const iterator = sourceStream ? {
+			next: () => (streamReader ??= sourceStream.getReader()).read(),
+			async return() {
+				if (!streamReader) {
+					await sourceStream.cancel();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+				try {
+					await streamReader.cancel();
+				} finally {
+					streamReader.releaseLock();
+				}
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+		} : sourceIterator ?? generator[Symbol.asyncIterator]();
+		const outerIterator = yieldedStream && !init.done ? sourceIterator : void 0;
 		let end = false;
+		let finalizing;
 		const signal = request?.signal;
 		let onAbort;
 		const cleanupAbort = () => {
@@ -205,17 +231,21 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 				onAbort = void 0;
 			}
 		};
-		const safeReturn = () => {
+		const safeReturn = async (target) => {
 			try {
-				const r = iterator.return?.();
-				if (r && typeof r.then === "function") r.catch(() => {});
+				await target?.return?.();
 			} catch {}
 		};
-		const closeSafely = (controller) => {
+		const finalize = (mode, controller, error) => {
+			if (end) return finalizing;
+			end = true;
+			cleanupAbort();
+			finalizing = safeReturn(iterator).then(() => safeReturn(outerIterator));
+			if (!controller) return finalizing;
 			try {
-				controller.close();
+				if (mode === "error") controller.error(error);
+				else controller.close();
 			} catch {}
-			cleanupAbort();
 		};
 		const enqueueValue = async (controller, value) => {
 			if (value.toSSE) {
@@ -234,42 +264,33 @@ function createStreamHandler({ mapResponse, mapCompactResponse }) {
 		return new Response(new ReadableStream({
 			async start(controller) {
 				if (signal) {
-					onAbort = () => {
-						cleanupAbort();
-						end = true;
-						safeReturn();
-						try {
-							controller.close();
-						} catch {}
-					};
+					onAbort = () => finalize("close", controller);
 					if (signal.aborted) onAbort();
 					else signal.addEventListener("abort", onAbort, { once: true });
 				}
 				if (!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null) return;
-				await enqueueValue(controller, init.value);
+				try {
+					await enqueueValue(controller, init.value);
+				} catch (error) {
+					finalize("error", controller, error);
+				}
 			},
 			async pull(controller) {
-				if (end) {
-					closeSafely(controller);
-					return;
-				}
+				if (end) return;
 				try {
 					const { value: chunk, done } = await iterator.next();
 					if (done || end) {
-						closeSafely(controller);
+						finalize("close", controller);
 						return;
 					}
 					if (chunk === void 0 || chunk === null) return;
 					await enqueueValue(controller, chunk);
 				} catch (error) {
-					cleanupAbort();
-					controller.error(error);
+					finalize("error", controller, error);
 				}
 			},
 			cancel() {
-				end = true;
-				cleanupAbort();
-				safeReturn();
+				finalize("close");
 			}
 		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
 	};