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

package/dist/ws/route.mjs

@@ -1,18 +1,19 @@
 import { isBun } from "../universal/constants.mjs";
-import { deriveEntryFn, isNotEmpty, nullObject } from "../utils.mjs";
+import { assignOwn, deriveEntryFn, isNotEmpty, isSocketQuiet, nullObject } from "../utils.mjs";
 import { isBridgeLive } from "../type/bridge.mjs";
-import { isProduction } from "../universal/is-production.mjs";
 import { ElysiaError, ElysiaStatus, ValidationError, internalServerErrorBodyString, problemBody, problemResponse } from "../error.mjs";
 import { mapResponse } from "../adapter/web-standard/handler.mjs";
 import { parseQueryFromURL } from "../parse-query.mjs";
 import { frozenRootOf } from "../generation.mjs";
-import { createErrorHandler } from "../handler/error.mjs";
+import { compileCookieConfig } from "../cookie/config.mjs";
+import { buildCookieJar, parseCookieRaw } from "../cookie/utils.mjs";
+import { adoptErrorType, claimsProblemType, createErrorHandler, readAnnotation, resolveStatus, statusFallbackBody } from "../handler/error.mjs";
 import { deriveModes, getQueryParseChannels, replaceDeriveContext } from "../compile/handler/utils.mjs";
 import { StandardValidator } from "../validator/index.mjs";
 import { RouteValidator } from "../validator/route.mjs";
 import { buildFrozenRouteValidator, isBridgeNotInitialized } from "../compile/handler/frozen-validator.mjs";
 import { composeRouteHook, localMacroRoot, resolveWSLocalHook } from "../compile/handler/index.mjs";
-import { ElysiaWS, isGeneratorObject } from "./context.mjs";
+import { ElysiaWS, isGeneratorObject, trackWSSettling } from "./context.mjs";
 import { createMessageParser } from "./parser.mjs";
 
 //#region src/ws/route.ts
@@ -180,9 +181,45 @@ function wsErrorFrame(error) {
 	}
 	return wsErrorFrameFallback(error);
 }
+/**
+* Frame served by an error that claims an RFC 9457 problem document, mirroring
+* the HTTP tiers in `handler/error.ts`: `value` replaces the whole frame,
+* `detail` fills the `detail` member, the message is the last resort.
+*
+* A frame carries no headers, so a `headers` annotation is ignored outright
+* rather than half-applied
+*/
+function wsProblemFrame(error) {
+	const status = resolveStatus(error.status);
+	const served = typeof status === "number" && status >= 100 ? status : 500;
+	const stringify = (value) => typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+	const problemFrame = (detail) => JSON.stringify(problemBody({
+		type: error.type ?? "about:blank",
+		detail,
+		status: served
+	}));
+	const serveMessage = () => problemFrame(statusFallbackBody(error, served));
+	const serveDetail = () => {
+		const detail = readAnnotation(error, "detail", true);
+		if (detail === void 0) return serveMessage();
+		if (detail instanceof Promise) return detail.then((resolved) => resolved === void 0 ? serveMessage() : problemFrame(resolved)).catch(() => wsLegacyFrame(error));
+		return problemFrame(detail);
+	};
+	const value = readAnnotation(error, "value", true);
+	if (value === void 0) return serveDetail();
+	if (value instanceof Promise) return value.then((resolved) => resolved === void 0 ? serveDetail() : stringify(resolved)).catch(() => wsLegacyFrame(error));
+	return stringify(value);
+}
 function wsErrorFrameFallback(error) {
+	if (claimsProblemType(error)) try {
+		return wsProblemFrame(error);
+	} catch {}
+	return wsLegacyFrame(error);
+}
+/** Frame an error that never self-described has always served */
+function wsLegacyFrame(error) {
 	if (error?.status) {
-		const body = error.response !== void 0 ? error.response : isProduction() ? error.status >= 500 ? "Internal Server Error" : "" : error.message ?? "";
+		const body = statusFallbackBody(error, error.status);
 		return typeof body === "object" ? JSON.stringify(body) : String(body);
 	}
 	return internalServerErrorBodyString(error);
@@ -217,13 +254,20 @@ const wsOptions = [
 ];
 function buildWSRoute(route, app) {
 	const hook = resolveWSLocalHook(localMacroRoot(route[7] ?? route[3] ?? app, app), route[4], app) ?? nullObject();
+	const instance = route[3] ?? app;
+	const appHookChain = route[5];
+	const inheritedChain = route[6];
+	const composed = composeRouteHook(instance, route[4], appHookChain, inheritedChain, app, route[7]) ?? hook;
 	let validators;
-	const frozenEager = isBridgeLive() ? void 0 : buildFrozenRouteValidator(hook, app, "WS", route[1]);
+	const frozenEager = isBridgeLive() ? void 0 : buildFrozenRouteValidator(composed, app, "WS", route[1]);
 	if (frozenEager) validators = frozenEager;
 	else try {
-		validators = new RouteValidator(hook, {
+		validators = new RouteValidator(composed, {
 			models: frozenRootOf(app)["~ext"]?.models,
 			app,
+			normalize: frozenRootOf(app)["~config"]?.normalize,
+			sanitize: frozenRootOf(app)["~config"]?.sanitize,
+			schemas: composed.schemas,
 			aot: {
 				method: "WS",
 				path: route[1]
@@ -232,18 +276,17 @@ function buildWSRoute(route, app) {
 		});
 	} catch (error) {
 		if (!isBridgeNotInitialized(error)) throw error;
-		const frozen = buildFrozenRouteValidator(hook, app, "WS", route[1]);
+		const frozen = buildFrozenRouteValidator(composed, app, "WS", route[1]);
 		if (!frozen) throw error;
 		validators = frozen;
 	}
 	const responseValidator = validators.response;
 	const defaultResponseValidator = responseValidator ? responseValidator[200] ?? responseValidator[Object.keys(responseValidator)[0]] : void 0;
+	const cookieConfig = validators.cookie ? compileCookieConfig(composed.cookie, frozenRootOf(app)["~config"]?.cookie) : void 0;
+	const cookieIsOptional = !!composed.cookie?.["~optional"];
 	const queryChannels = getQueryParseChannels(validators.query?.schema);
 	const queryArray = queryChannels?.array;
 	const queryObject = queryChannels?.object;
-	const instance = route[3] ?? app;
-	const appHookChain = route[5];
-	const inheritedChain = route[6];
 	const flatAppHook = composeRouteHook(instance, void 0, appHookChain, inheritedChain, app, route[7]) ?? {};
 	const parseHooks = hook.parse == null ? [] : Array.isArray(hook.parse) ? hook.parse : [hook.parse];
 	const transforms = concatHooks(flatAppHook.transform, hook.transform);
@@ -271,6 +314,7 @@ function buildWSRoute(route, app) {
 				break;
 			}
 			if (r !== void 0) {
+				r = adoptErrorType(r, error);
 				try {
 					await handleWSResponse(ws, r, mapResponses);
 				} catch {}
@@ -418,6 +462,15 @@ function buildWSRoute(route, app) {
 				if (r instanceof Promise) r = await r;
 				context.headers = r;
 			}
+			if (cookieConfig) {
+				const raw = await parseCookieRaw(request.headers.get("cookie"), cookieConfig);
+				let r = raw;
+				if (!cookieIsOptional || Object.keys(raw).length) {
+					r = validateUpgradeChannel(validators.cookie, raw, "cookie");
+					if (r instanceof Promise) r = await r;
+				}
+				context.cookie = buildCookieJar(context.set, r, cookieConfig);
+			}
 			for (let i = 0; i < transforms.length; i++) {
 				const r = transforms[i](context);
 				if (r instanceof Promise) await r;
@@ -429,7 +482,7 @@ function buildWSRoute(route, app) {
 				const deriveMode = upgradeDeriveModes?.[i];
 				if (deriveMode !== void 0 && !(r instanceof ElysiaStatus)) {
 					if (r && typeof r === "object") if (deriveMode) context = replaceDeriveContext(context, r);
-					else Object.assign(context, r);
+					else assignOwn(context, r);
 				} else if (r !== void 0) {
 					if (r instanceof Response) return r;
 					return mapResponse(r, context.set, context.request);
@@ -484,23 +537,40 @@ function resolveWSOptions(entries) {
 		const incoming = entry.value[key];
 		if (key in result && result[key] !== incoming && !warned?.has(key)) {
 			(warned ??= /* @__PURE__ */ new Set()).add(key);
-			console.warn(`[Elysia] Conflicting WebSocket option '${key}' across .use(websocket()) registrations; the shallowest (nearest-root) registration wins.`);
+			console.warn(`[Elysia] Conflicting WebSocket option '${key}' across .use(websocket()). Using nearest-root registration.`);
 		}
 		result[key] = incoming;
 	}
 	return result;
 }
+const wsLimits = [
+	"maxPayloadLength",
+	"backpressureLimit",
+	"idleTimeout"
+];
+const routeOwnedKeys = /* @__PURE__ */ new WeakMap();
 function accumulateWSOptions(target, routeOptions, _path) {
 	if (!isNotEmpty(routeOptions)) return;
-	if (isBun) {
-		for (const key in routeOptions) if (key in target && target[key] !== routeOptions[key]) {
-			console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, per-route values are not enforced (the last-registered route wins).`);
-			console.warn((/* @__PURE__ */ new Error()).stack);
+	let owned = routeOwnedKeys.get(target);
+	if (!owned) routeOwnedKeys.set(target, owned = /* @__PURE__ */ new Set());
+	for (const key in routeOptions) {
+		const incoming = routeOptions[key];
+		const current = target[key];
+		if (key in target && current !== incoming) {
+			if (isBun) {
+				console.warn(`[Elysia] Conflicting per-route WebSocket option '${key}'\nBun uses one global WebSocket config per server, per-route values are not enforced (for limits the strictest route wins, otherwise the last-registered route).`);
+				console.warn((/* @__PURE__ */ new Error()).stack);
+			}
+			if (owned.has(key) && typeof current === "number" && typeof incoming === "number" && current < incoming && wsLimits.includes(key)) continue;
 		}
+		owned.add(key);
+		target[key] = incoming;
 	}
-	Object.assign(target, routeOptions);
 }
+const MAX_INFLIGHT_MESSAGES = 256;
 function buildGlobalWSHandler() {
+	let lifecycle;
+	const runLifecycle = (callback, ...args) => lifecycle ? lifecycle.run(callback, ...args) : callback(...args);
 	function getElysia(ws) {
 		let elysia = ws.data.elysia;
 		if (!elysia) {
@@ -515,39 +585,117 @@ function buildGlobalWSHandler() {
 			ws.send(typeof error?.message === "string" ? error.message : "Internal Server Error");
 		} catch {}
 	};
-	return {
+	const releaseLifecycle = (ws) => {
+		if (!lifecycle?.closing && isSocketQuiet(ws)) {
+			delete ws.data["~lifecycleRun"];
+			lifecycle?.sockets.delete(ws);
+		}
+	};
+	const release = (ws) => {
+		const data = ws.data;
+		const inflight = data.inflight;
+		if (inflight) {
+			data.inflight = inflight - 1;
+			if (inflight === 1 && data.closeHandlerInvoked) releaseLifecycle(ws);
+		}
+	};
+	function dispatch(ws, message) {
+		let result;
+		try {
+			result = ws.data.message(getElysia(ws), message);
+		} catch (error) {
+			release(ws);
+			sendErrMsg(ws, error);
+			return;
+		}
+		if (result instanceof Promise) result.then(() => release(ws), (error) => {
+			release(ws);
+			sendErrMsg(ws, error);
+		});
+		else release(ws);
+	}
+	const handler = {
 		message(ws, message) {
-			let result;
-			try {
-				result = ws.data.message?.(getElysia(ws), message);
-			} catch (error) {
-				sendErrMsg(ws, error);
+			if (lifecycle?.closing) return;
+			const data = ws.data;
+			if (!data.message) return;
+			const inflight = (data.inflight ?? 0) + 1;
+			if (inflight > MAX_INFLIGHT_MESSAGES) {
+				try {
+					ws.close(1013, "Too many in-flight messages");
+				} catch {}
 				return;
 			}
-			if (result instanceof Promise) result.catch((error) => sendErrMsg(ws, error));
+			data.inflight = inflight;
+			const opening = data.opening;
+			if (opening) return void opening.then(() => {
+				if (lifecycle?.closing || ws.readyState > 1) return release(ws);
+				dispatch(ws, message);
+			});
+			dispatch(ws, message);
 		},
 		open(ws) {
-			ws.data.open?.(getElysia(ws));
+			if (lifecycle) Object.defineProperty(ws.data, "~lifecycleRun", {
+				configurable: true,
+				value: lifecycle.run
+			});
+			lifecycle?.sockets.add(ws);
+			if (lifecycle?.closing) {
+				ws.data.closeHandlerInvoked = true;
+				try {
+					ws.terminate();
+				} catch {}
+				return;
+			}
+			const open = ws.data.open;
+			const result = open && runLifecycle(open, getElysia(ws));
+			if (result instanceof Promise) {
+				const clear = () => {
+					ws.data.opening = void 0;
+					releaseLifecycle(ws);
+				};
+				ws.data.opening = result.then(clear, clear);
+			}
 		},
 		drain(ws) {
+			if (lifecycle?.closing) return;
 			const elyWs = getElysia(ws);
 			drainWaiters(elyWs);
-			ws.data.drain?.(elyWs);
+			const drain = ws.data.drain;
+			trackWSSettling(ws.data, drain && runLifecycle(drain, elyWs), () => releaseLifecycle(ws));
 		},
 		close(ws, code, reason) {
 			const elyWs = getElysia(ws);
 			drainWaiters(elyWs);
-			if (ws.data.closeHandlerInvoked) return;
+			if (ws.data.closeHandlerInvoked) return releaseLifecycle(ws);
 			ws.data.closeHandlerInvoked = true;
-			ws.data.close?.(elyWs, code, reason);
+			let result;
+			try {
+				const close = ws.data.close;
+				result = close && runLifecycle(close, elyWs, code, reason);
+			} finally {
+				if (!(result instanceof Promise)) releaseLifecycle(ws);
+			}
+			if (result instanceof Promise) {
+				const closing = result.catch(() => {});
+				trackWSSettling(ws.data, closing, () => releaseLifecycle(ws));
+			}
 		},
 		ping(ws, data) {
-			ws.data.ping?.(getElysia(ws), data);
+			if (lifecycle?.closing) return;
+			const ping = ws.data.ping;
+			trackWSSettling(ws.data, ping && runLifecycle(ping, getElysia(ws), data), () => releaseLifecycle(ws));
 		},
 		pong(ws, data) {
-			ws.data.pong?.(getElysia(ws), data);
+			if (lifecycle?.closing) return;
+			const pong = ws.data.pong;
+			trackWSSettling(ws.data, pong && runLifecycle(pong, getElysia(ws), data), () => releaseLifecycle(ws));
 		}
 	};
+	Object.defineProperty(handler, "~lifecycle", { set(value) {
+		lifecycle = value;
+	} });
+	return handler;
 }
 
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "2.0.0-beta.2",
+	"version": "2.0.0-beta.4",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",
@@ -238,11 +238,13 @@
 		"./dist/type/exports.mjs",
 		"./dist/type/exports.js",
 		"./dist/type/bridge-live.mjs",
-		"./dist/type/bridge-live.js"
+		"./dist/type/bridge-live.js",
+		"./dist/type/typebox-value-live.mjs",
+		"./dist/type/typebox-value-live.js"
 	],
 	"dependencies": {
 		"deuri": "^3.0.0",
-		"memoirist": "1.2.1"
+		"memoirist": "1.2.2"
 	},
 	"devDependencies": {
 		"@eslint/eslintrc": "^3.3.5",