elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/adapter/types.d.ts

@@ -1,6 +1,6 @@
 import { ListenCallback, Serve } from "../universal/server.js";
-import { MaybePromise } from "../types.js";
 import { Context } from "../context.js";
+import { MaybePromise } from "../types.js";
 import { AnyElysia } from "../base.js";
 
 //#region src/adapter/types.d.ts
@@ -10,25 +10,6 @@ import { AnyElysia } from "../base.js";
  * @since 2.0.0
  */
 interface ElysiaAdapterOptions<App extends AnyElysia | void = void> {
-  /**
-   * Name of the adapter, preferably runtime
-   */
-  name: string;
-  /**
-   *
-   * @param app
-   */
-  runtime: 'node' | 'deno' | 'bun' | 'cloudflare-worker' | 'browser' | 'vercel' | 'netlify' | 'lambda' | 'fastly' | 'edge' | 'unknown' | (string & {});
-  /**
-   * Whether this adapter is web standard
-   */
-  isWebStandard: boolean;
-  /**
-   * Whether this adapter supports WebSocket.
-   *
-   * `.ws()` throws on non-Bun runtimes unless this is set.
-   */
-  websocket?: boolean;
   listen?(app: AnyElysia, options: string | number | Partial<Serve>, callback?: ListenCallback): void;
   parse: {
     json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
@@ -36,7 +17,7 @@ interface ElysiaAdapterOptions<App extends AnyElysia | void = void> {
     urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;
     arrayBuffer: (context: Context) => MaybePromise<ArrayBuffer>;
     formData: (context: Context) => MaybePromise<Record<string, unknown>>;
-    default: (context: Context, contentType: string, normalized?: boolean) => MaybePromise<any>;
+    default: (context: Context, contentType: string) => MaybePromise<any>;
   };
   response: {
     /**

package/dist/adapter/utils.d.ts

@@ -1,8 +1,8 @@
 import { BaseCookie } from "../cookie/types.js";
-import { ElysiaFile } from "../universal/file.js";
 import { StatusMap } from "../constants.js";
-import { HTTPHeaders } from "../types.js";
 import { Context } from "../context.js";
+import { ElysiaFile } from "../universal/file.js";
+import { HTTPHeaders } from "../types.js";
 //#region src/adapter/utils.d.ts
 declare function materializeSetHeaders(set: Context['set']): any;
 declare function normalizeContentType(contentType: string): string;
@@ -12,6 +12,7 @@ declare function responseToSetHeaders(response: Response, set?: Context['set']):
   headers: HTTPHeaders;
   status?: number | keyof StatusMap;
   cookie?: Record<string, BaseCookie>;
+  redirect?: never;
 } | {
   headers: any;
   status: number | "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required";
@@ -27,6 +28,16 @@ declare function createStreamHandler({
 declare function streamResponse(response: Response): AsyncGenerator<any, void, any>;
 declare function handleSet(set: Context['set']): void;
 declare function createResponseHandler(handler: CreateHandlerParameter): (response: Response, set?: Context["set"], request?: Request, owned?: boolean) => any;
+/**
+ * A returned `ReadableStream` is consumed after the handler returns, so
+ * afterResponse, `defer()` and derive dispose must wait for it the way a tee'd
+ * generator is waited on
+ *
+ * A returned `Response` is not observed, reading `.body` would move
+ * every Response on these routes off Bun's native send path; a `bytes()`
+ * stream keeps its exact-stream contract and releases early as before
+ */
+declare function observeStream(source: ReadableStream): [ReadableStream, AsyncIterable<unknown>, AsyncIterableIterator<unknown>] | undefined;
 /**
  * Split async source into `branches` independent iterators
  *
@@ -47,4 +58,4 @@ declare function createResponseHandler(handler: CreateHandlerParameter): (respon
  */
 declare function tee<T>(source: AsyncIterable<T>, branches?: number, cap?: number, capBytes?: number): AsyncIterableIterator<T>[];
 //#endregion
-export { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders, normalizeContentType, parseSetCookies, responseToSetHeaders, streamResponse, tee };
+export { createResponseHandler, createStreamHandler, handleFile, handleSet, materializeSetHeaders, normalizeContentType, observeStream, parseSetCookies, responseToSetHeaders, streamResponse, tee };

package/dist/adapter/utils.js

@@ -14,25 +14,19 @@ function materializeSetHeaders(set) {
 	if (headers["\0"] !== headers) return headers;
 	return set.headers = Object.assign(require_utils.nullObject(), headers);
 }
-const sseFormat = (data) => `data: ${data}\n\n`;
+const sseFormat = (data) => require_utils.sseData(data) + "\n";
 const identityFormat = (data) => data;
 const textEncoder = new TextEncoder();
-const encodeChunk = (s) => textEncoder.encode(s);
 function normalizeContentType(contentType) {
 	if (contentType === "application/json") return contentType;
 	const end = contentType.indexOf(";");
 	return (end === -1 ? contentType : contentType.slice(0, end)).trim().toLowerCase();
 }
 function handleFile(response, set, request, size = response.size) {
-	if (!require_universal_constants.isBun && response instanceof Promise) return response.then((res) => handleFile(res, set, request, size));
 	const rangeHeader = request?.headers.get("range");
 	if (rangeHeader) {
 		const match = /bytes=(\d*)-(\d*)/.exec(rangeHeader);
 		if (match) {
-			if (!match[1] && !match[2]) return new Response(null, {
-				status: 416,
-				headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? require_utils.nullObject())
-			});
 			let start;
 			let end;
 			if (!match[1] && match[2]) {
@@ -43,7 +37,7 @@ function handleFile(response, set, request, size = response.size) {
 				start = match[1] ? parseInt(match[1]) : 0;
 				end = match[2] ? Math.min(parseInt(match[2]), size - 1) : size - 1;
 			}
-			if (start >= size || start > end) return new Response(null, {
+			if (!match[1] && !match[2] || start >= size || start > end) return new Response(null, {
 				status: 416,
 				headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? require_utils.nullObject())
 			});
@@ -75,13 +69,9 @@ function handleFile(response, set, request, size = response.size) {
 		}
 		return new Response(body, set);
 	}
-	if (require_utils.isNotEmpty(set.headers)) return new Response(body, {
-		status: set.status,
-		headers: Object.assign(defaultHeader, set.headers)
-	});
 	return new Response(body, {
 		status: set.status,
-		headers: defaultHeader
+		headers: Object.assign(defaultHeader, set.headers)
 	});
 }
 function normalizeHeaders(set) {
@@ -124,27 +114,9 @@ function responseToSetHeaders(response, set) {
 	if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
-function enqueueBinaryChunk(controller, chunk) {
-	if (chunk instanceof Blob) return chunk.arrayBuffer().then((buffer) => {
-		controller.enqueue(new Uint8Array(buffer));
-		return true;
-	});
-	if (chunk instanceof Uint8Array) {
-		controller.enqueue(chunk);
-		return true;
-	}
-	if (chunk instanceof ArrayBuffer) {
-		controller.enqueue(new Uint8Array(chunk));
-		return true;
-	}
-	if (ArrayBuffer.isView(chunk)) {
-		controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-		return true;
-	}
-	return false;
-}
 function createStreamHandler({ mapResponse, mapCompactResponse }) {
 	return async (generator, set, request, skipFormat, owned = false) => {
+		if (request === null) return void 0;
 		if (require_utils.isByteStream(generator)) {
 			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
 			if (set) {
@@ -158,10 +130,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 +169,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,71 +203,93 @@ 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) => {
+		const enqueueValue = (controller, value) => {
 			if (value.toSSE) {
-				controller.enqueue(encodeChunk(value.toSSE()));
+				controller.enqueue(textEncoder.encode(value.toSSE()));
 				return;
 			}
-			const p = enqueueBinaryChunk(controller, value);
-			if (p !== false) return void await p;
+			let p;
+			if (value instanceof Blob) p = value.arrayBuffer().then((buffer) => {
+				controller.enqueue(new Uint8Array(buffer));
+			});
+			else if (value instanceof Uint8Array) {
+				controller.enqueue(value);
+				p = true;
+			} else if (value instanceof ArrayBuffer) {
+				controller.enqueue(new Uint8Array(value));
+				p = true;
+			} else if (ArrayBuffer.isView(value)) {
+				controller.enqueue(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+				p = true;
+			} else p = false;
+			if (p !== false) return p === true ? void 0 : p;
 			if (typeof value === "object") try {
-				controller.enqueue(encodeChunk(format(JSON.stringify(value))));
+				controller.enqueue(textEncoder.encode(format(JSON.stringify(value))));
 			} catch {
-				controller.enqueue(encodeChunk(format(value.toString())));
+				controller.enqueue(textEncoder.encode(format(value.toString())));
 			}
-			else controller.enqueue(encodeChunk(format(value.toString())));
+			else controller.enqueue(textEncoder.encode(format(value.toString())));
 		};
 		return new Response(new ReadableStream({
-			async start(controller) {
+			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);
-			},
-			async pull(controller) {
-				if (end) {
-					closeSafely(controller);
-					return;
-				}
+				const fail = (error) => {
+					finalize("error", controller, error);
+				};
 				try {
-					const { value: chunk, done } = await iterator.next();
-					if (done || end) {
-						closeSafely(controller);
-						return;
+					return enqueueValue(controller, init.value)?.catch(fail);
+				} catch (error) {
+					fail(error);
+				}
+			},
+			pull(controller) {
+				if (end) return;
+				const fail = (error) => {
+					finalize("error", controller, error);
+				};
+				const step = (result) => {
+					while (true) {
+						if (result.done || end) {
+							finalize("close", controller);
+							return;
+						}
+						const chunk = result.value;
+						if (chunk !== void 0 && chunk !== null) return enqueueValue(controller, chunk);
+						const next = iterator.next();
+						if (typeof next.then === "function") return Promise.resolve(next).then(step);
+						result = next;
 					}
-					if (chunk === void 0 || chunk === null) return;
-					await enqueueValue(controller, chunk);
+				};
+				try {
+					const next = iterator.next();
+					return (typeof next.then === "function" ? Promise.resolve(next).then(step) : step(next))?.catch(fail);
 				} catch (error) {
-					cleanupAbort();
-					controller.error(error);
+					fail(error);
 				}
 			},
 			cancel() {
-				end = true;
-				cleanupAbort();
-				safeReturn();
+				finalize("close");
 			}
 		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
 	};
@@ -284,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 && require_utils.isNotEmpty(set.cookie)) {
@@ -292,8 +312,11 @@ function handleSet(set) {
 		const cookie = require_cookie_serialize.serializeCookie(set.cookie);
 		if (cookie) {
 			const existing = set.headers[setCookie];
-			if (Array.isArray(existing)) set.headers[setCookie] = existing.concat(cookie);
-			else set.headers[setCookie] = cookie;
+			if (existing) {
+				const kept = typeof existing === "string" ? [existing] : existing;
+				const added = (typeof cookie === "string" ? [cookie] : cookie).filter((value) => !kept.includes(value));
+				set.headers[setCookie] = added.length ? kept.concat(added) : existing;
+			} else set.headers[setCookie] = cookie;
 		}
 	}
 	if (set.headers[setCookie] && Array.isArray(set.headers[setCookie])) set.headers = parseSetCookies(new Headers(set.headers), set.headers[setCookie]);
@@ -311,7 +334,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)) {
@@ -349,7 +372,6 @@ function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = fals
 		}
 	});
 }
-const warnedStreamBorrows = /* @__PURE__ */ new WeakSet();
 function createResponseHandler(handler) {
 	const handleStream = createStreamHandler(handler);
 	return (response, set, request, owned = false) => {
@@ -361,25 +383,21 @@ function createResponseHandler(handler) {
 		const borrowed = !owned || explicitlyBorrowed;
 		const mustClone = owned && explicitlyBorrowed;
 		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
+		let status;
 		if (set) {
-			const status = mergeStatus(response.status, set.status);
+			status = mergeStatus(response.status, set.status);
 			const statusUnchanged = status === void 0 || status === response.status;
 			if (!mustClone && statusUnchanged && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
 		} else if (!mustClone) return response;
 		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked");
 		let body = response.body;
 		if (borrowed) {
-			const bodyBefore = body;
 			const cloned = response.clone();
-			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
-				warnedStreamBorrows.add(response);
-				console.warn("[elysia] borrow() was called on a stream-backed Response");
-			}
 			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body, explicitlyBorrowed) : cloned.body;
 		}
 		const newResponse = new Response(body, set ? {
 			headers: mergeHeaders(response.headers, set.headers),
-			status: mergeStatus(response.status, set.status),
+			status,
 			statusText: response.statusText
 		} : {
 			headers: response.headers,
@@ -404,6 +422,46 @@ const doneResult = {
 	value: void 0
 };
 /**
+* A returned `ReadableStream` is consumed after the handler returns, so
+* afterResponse, `defer()` and derive dispose must wait for it the way a tee'd
+* generator is waited on
+*
+* A returned `Response` is not observed, reading `.body` would move
+* every Response on these routes off Bun's native send path; a `bytes()`
+* stream keeps its exact-stream contract and releases early as before
+*/
+function observeStream(source) {
+	if (source.locked || require_utils.isByteStream(source)) return;
+	const reader = source.getReader();
+	const [value, observer] = tee({ [Symbol.asyncIterator]: () => ({
+		next: () => reader.read(),
+		return: (reason) => reader.cancel(reason).then(() => ({
+			done: true,
+			value: void 0
+		}))
+	}) });
+	const body = new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await value.next();
+				if (result.done) controller.close();
+				else controller.enqueue(result.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		cancel(reason) {
+			return value.return?.(reason);
+		}
+	}, { highWaterMark: 0 });
+	if (source.sse === true) body.sse = true;
+	return [
+		body,
+		observer,
+		value
+	];
+}
+/**
 * Split async source into `branches` independent iterators
 *
 * A producer drains the source ahead of consumers
@@ -524,7 +582,7 @@ function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
 			wakeAll();
 		}
 	})();
-	const makeBranch = (me) => ({
+	const makeBranch = (me) => Object.assign(Object.create(null), {
 		[Symbol.asyncIterator]() {
 			return this;
 		},
@@ -564,6 +622,7 @@ exports.handleFile = handleFile;
 exports.handleSet = handleSet;
 exports.materializeSetHeaders = materializeSetHeaders;
 exports.normalizeContentType = normalizeContentType;
+exports.observeStream = observeStream;
 exports.parseSetCookies = parseSetCookies;
 exports.responseToSetHeaders = responseToSetHeaders;
 exports.streamResponse = streamResponse;