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

package/dist/adapter/utils.mjs

@@ -1,6 +1,6 @@
 import { hasHeaderShorthand, isBun } from "../universal/constants.mjs";
 import { StatusMap } from "../constants.mjs";
-import { isByteStream, isNotEmpty, nullObject } from "../utils.mjs";
+import { isByteStream, isNotEmpty, nullObject, sseData } from "../utils.mjs";
 import { skipClone } from "./skip-clone.mjs";
 import { serializeCookie } from "../cookie/serialize.mjs";
 import { isBorrowedResponse } from "./response-ownership.mjs";
@@ -13,7 +13,7 @@ function materializeSetHeaders(set) {
 	if (headers["\0"] !== headers) return headers;
 	return set.headers = Object.assign(nullObject(), headers);
 }
-const sseFormat = (data) => `data: ${data}\n\n`;
+const sseFormat = (data) => sseData(data) + "\n";
 const identityFormat = (data) => data;
 const textEncoder = new TextEncoder();
 const encodeChunk = (s) => textEncoder.encode(s);
@@ -157,10 +157,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);
@@ -194,8 +196,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 = () => {
@@ -204,17 +230,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) {
@@ -233,42 +263,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);
 	};
@@ -283,7 +304,7 @@ function handleSet(set) {
 	const proto = Object.getPrototypeOf(set.headers);
 	if (proto !== null && proto !== Object.prototype) {
 		const flat = Object.create(null);
-		for (const key in set.headers) flat[key] = set.headers[key];
+		for (const key of Object.keys(set.headers)) flat[key] = set.headers[key];
 		set.headers = flat;
 	}
 	if (set.cookie && isNotEmpty(set.cookie)) {
@@ -310,7 +331,7 @@ function applySetHeaders(target, setHeaders, present) {
 		for (const key of setHeaders.keys()) if (key !== setCookie && !present.has(key)) target.set(key, setHeaders.get(key) ?? "");
 	} else {
 		let cookies;
-		for (const key in setHeaders) if (key === setCookie) {
+		for (const key of Object.keys(setHeaders)) if (key === setCookie) {
 			const cookie = setHeaders[key];
 			cookies ??= target.getSetCookie();
 			if (!cookies.includes(cookie)) {

package/dist/adapter/web-standard/handler.js

@@ -5,6 +5,7 @@ const require_utils = require('../../utils.js');
 const require_error = require('../../error.js');
 const require_adapter_default_headers = require('../default-headers.js');
 const require_adapter_utils = require('../utils.js');
+const require_cookie_cookie = require('../../cookie/cookie.js');
 
 //#region src/adapter/web-standard/handler.ts
 const textPlainInit = { headers: { "content-type": "text/plain" } };
@@ -23,7 +24,9 @@ function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, r
 }
 function responseTag(response) {
 	if (response == null) return;
-	return Object.getPrototypeOf(response)?.constructor?.name;
+	const constructor = Object.getPrototypeOf(response)?.constructor;
+	if (typeof constructor !== "function") return typeof response.next === "function" ? "" : void 0;
+	return constructor.name;
 }
 function mapResponseWithSet(response, set, request, owned) {
 	require_adapter_utils.handleSet(set);
@@ -134,7 +137,7 @@ function mapFallback(response, set, request, owned = false) {
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
 	if (Array.isArray(response)) return Response.json(response);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (responseTag(response) === "Cookie") return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
+	if (responseTag(response) === "Cookie" && require_cookie_cookie.Cookie.isCookie(response)) return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);
 }
 const handleResponse = require_adapter_utils.createResponseHandler({

package/dist/adapter/web-standard/handler.mjs

@@ -4,6 +4,7 @@ import { formToFormData, isElysiaForm, isNotEmpty, nullObject } from "../../util
 import { ElysiaStatus, PROBLEM_JSON, internalServerErrorBody } from "../../error.mjs";
 import { defaultHeaders } from "../default-headers.mjs";
 import { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders } from "../utils.mjs";
+import { Cookie } from "../../cookie/cookie.mjs";
 
 //#region src/adapter/web-standard/handler.ts
 const textPlainInit = { headers: { "content-type": "text/plain" } };
@@ -22,7 +23,9 @@ function handleElysiaFile(file, set = { headers: nullObject() }, request) {
 }
 function responseTag(response) {
 	if (response == null) return;
-	return Object.getPrototypeOf(response)?.constructor?.name;
+	const constructor = Object.getPrototypeOf(response)?.constructor;
+	if (typeof constructor !== "function") return typeof response.next === "function" ? "" : void 0;
+	return constructor.name;
 }
 function mapResponseWithSet(response, set, request, owned) {
 	handleSet(set);
@@ -133,7 +136,7 @@ function mapFallback(response, set, request, owned = false) {
 	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
 	if (Array.isArray(response)) return Response.json(response);
 	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
-	if (responseTag(response) === "Cookie") return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
+	if (responseTag(response) === "Cookie" && Cookie.isCookie(response)) return set ? mapResponse(response.value, set, request, owned) : mapCompactResponse(response.value, request, owned);
 	return new Response(response, set);
 }
 const handleResponse = createResponseHandler({

package/dist/base.d.ts

@@ -39,6 +39,10 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     hoc?: WrapFn<any>[];
     setup?: GracefulHandler<any>[];
     cleanup?: GracefulHandler<any>[];
+    cleanupEpoch?: (handler: GracefulHandler<any> | GracefulHandler<any>[]) => boolean;
+    stop?: (closeActiveConnections?: boolean, failure?: {
+      error: unknown;
+    }) => Promise<void>;
     capability?: {
       trace?: {
         provider: TraceCapability;
@@ -66,7 +70,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~hasDynamicWS'?: boolean;
   '~hasTrace'?: boolean;
   '~finalizeError'?: (context: Context, error: Error) => MaybePromise<Response>;
-  '~programId': ProgramId;
+  get ['~programId'](): ProgramId;
   '~aotFingerprint'?: AotFingerprint;
   '~compilerSession'?: CompilerSession;
   '~generation'?: Generation;
@@ -864,7 +868,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    * on the config and triggers a fresh build of the fetch handler).
    */
   compile(): this;
-  handler(index: number, immediate?: boolean | undefined, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases, table?: RouteTable): CompiledHandler;
+  handler(index: number, immediate?: boolean, route?: InternalRoute, precomputedStatic?: Response, aliases?: StaticMapAliases, table?: RouteTable): CompiledHandler;
   ['~newGeneration'](): this;
   get fetch(): (request: Request, ...rest: any[]) => MaybePromise<Response>;
   get handle(): (url: string | Request, options?: RequestInit) => Promise<Response>;
@@ -900,12 +904,19 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    */
   cleanup(handler: MaybeArray<GracefulHandler<this>>): this;
   /**
-   * Stop the underlying server (if any), running every `cleanup` handler once
-   * it has stopped. Mirrors `Server.stop()`.
+   * Stop the underlying server (if any), then run every `cleanup` handler.
+   * Omitted and `false` are the same graceful stop: new requests are gated,
+   * tracked WebSockets are settled and active HTTP is drained, then cleanup
+   * runs and the epoch is released. `true` force-closes the transport
+   * instead of draining it, and escalates a graceful stop already in flight.
    *
-   * @param closeActiveConnections Pass `true` to terminate in-flight
-   *   requests and WebSocket connections immediately. Defaults to
-   *   draining gracefully.
+   * Awaiting `stop()` from inside a `setup`, `cleanup` or WebSocket lifecycle
+   * callback is only supported while that callback is still synchronous; the
+   * teardown is waiting on the callback, so after an `await` it can only be
+   * issued as `void app.stop()`.
+   *
+   * @param closeActiveConnections Pass `true` to terminate active
+   *   transports. Omit (or pass `false`) to drain safely.
    */
   stop(closeActiveConnections?: boolean): Promise<void> | void;
 }