elysia 1.4.28 → 2.0.0-beta.0

package/dist/ws/route.mjs

@@ -0,0 +1,554 @@
+import { isBun } from "../universal/constants.mjs";
+import { deriveEntryFn, isNotEmpty, 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 { 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 { createErrorHandler } from "../handler/error.mjs";
+import { ElysiaWS, isGeneratorObject } from "./context.mjs";
+import { createMessageParser } from "./parser.mjs";
+
+//#region src/ws/route.ts
+const EMPTY_HOOKS = Object.freeze([]);
+/**
+* Build-time (route-registration-time) analysis of a WS `message` handler to
+* decide whether the per-frame `ws.body` view must be assigned.
+*/
+function handlerMayTouchBody(fn) {
+	if (!fn) return false;
+	let source;
+	try {
+		source = Function.prototype.toString.call(fn);
+	} catch {
+		return true;
+	}
+	if (source.indexOf("[native code]") !== -1) return true;
+	if (/\bbody\b/.test(source)) return true;
+	if (/\barguments\b/.test(source)) return true;
+	if (source.indexOf("[") !== -1) return true;
+	if (source.indexOf("...") !== -1) return true;
+	const parsed = firstParamIdentifier(source);
+	if (parsed === void 0) return true;
+	const { name: wsName, bodyStart, paramsEnd } = parsed;
+	if (source.slice(0, paramsEnd).indexOf("(", 1) !== -1) return true;
+	const body = source.slice(bodyStart);
+	const safeName = wsName.replace(/[$]/g, "\\$&");
+	if (new RegExp(`(?<![\\w$.])${safeName}(?![\\w$]|\\s*\\.)`).test(body)) return true;
+	return false;
+}
+function firstParamIdentifier(source) {
+	const open = source.indexOf("(");
+	if (open === -1) {
+		const m = /^\s*(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(source);
+		if (!m) return void 0;
+		const end = m.index + m[0].length;
+		return {
+			name: m[1],
+			bodyStart: end,
+			paramsEnd: end
+		};
+	}
+	let depth = 0;
+	let close = -1;
+	for (let i = open; i < source.length; i++) {
+		const c = source[i];
+		if (c === "(") depth++;
+		else if (c === ")") {
+			depth--;
+			if (depth === 0) {
+				close = i;
+				break;
+			}
+		}
+	}
+	if (close === -1) return void 0;
+	const params = source.slice(open + 1, close).trim();
+	if (params.length === 0) return void 0;
+	let first = params;
+	const comma = params.indexOf(",");
+	if (comma !== -1) first = params.slice(0, comma).trim();
+	if (first[0] === "{" || first[0] === "[") return void 0;
+	const m = /^([A-Za-z_$][\w$]*)/.exec(first);
+	if (!m) return void 0;
+	return {
+		name: m[1],
+		bodyStart: close + 1,
+		paramsEnd: close + 1
+	};
+}
+function concatHooks(...sources) {
+	let result;
+	for (let i = 0; i < sources.length; i++) {
+		const s = sources[i];
+		if (s == null) continue;
+		const arr = Array.isArray(s) ? s : [s];
+		if (arr.length === 0) continue;
+		result = result ? result.concat(arr) : arr;
+	}
+	return result ?? EMPTY_HOOKS;
+}
+async function applyMapResponse(ws, value, mapResponses) {
+	for (let i = 0; i < mapResponses.length; i++) {
+		ws.responseValue = value;
+		const r = mapResponses[i](ws);
+		const result = r instanceof Promise ? await r : r;
+		if (result !== void 0) value = result;
+	}
+	return value;
+}
+const isBackpressured = (status) => typeof status === "number" && status <= 0;
+const isEmptyPayload = (payload) => {
+	if (payload === "" || payload == null) return true;
+	if (typeof payload === "string") return false;
+	if (payload instanceof ArrayBuffer || ArrayBuffer.isView(payload)) return payload.byteLength === 0;
+	return false;
+};
+function waitForDrain(ws) {
+	const data = ws.raw.data;
+	return new Promise((resolve) => {
+		(data.resumeWaiters ??= /* @__PURE__ */ new Set()).add(resolve);
+	});
+}
+function drainWaiters(ws) {
+	const waiters = ws.raw.data.resumeWaiters;
+	if (!waiters || waiters.size === 0) return;
+	ws.raw.data.resumeWaiters = void 0;
+	for (const fn of waiters) fn();
+}
+async function handleWSResponse(ws, value, mapResponses) {
+	if (value === void 0) return;
+	if (isGeneratorObject(value)) {
+		const iter = value;
+		try {
+			while (true) {
+				const step = iter.next();
+				const { value: yielded, done } = step instanceof Promise ? await step : step;
+				if (done) return;
+				if (yielded === void 0) continue;
+				const mapped = mapResponses.length ? await applyMapResponse(ws, yielded, mapResponses) : yielded;
+				let status = ws.send(mapped);
+				const canBackpressure = !isEmptyPayload(mapped);
+				while (canBackpressure && isBackpressured(status)) {
+					if (ws.readyState >= 2) return;
+					await waitForDrain(ws);
+					if (ws.readyState >= 2) return;
+					if (status === -1) break;
+					status = ws.send(mapped);
+				}
+			}
+		} finally {
+			if (typeof iter.return === "function") try {
+				const r = iter.return();
+				if (r instanceof Promise) await r;
+			} catch {}
+		}
+		return;
+	}
+	const mapped = mapResponses.length ? await applyMapResponse(ws, value, mapResponses) : value;
+	ws.send(mapped);
+}
+function wsErrorFrame(error) {
+	if (error instanceof ValidationError) try {
+		return JSON.stringify(error.payload);
+	} catch {}
+	if (error instanceof ElysiaStatus) try {
+		return JSON.stringify({
+			status: error.status,
+			error: error.response
+		});
+	} catch {}
+	if (typeof error?.toResponse === "function") {
+		if (error instanceof ElysiaError && error.toResponse === ElysiaError.prototype.toResponse) try {
+			return JSON.stringify(problemBody({
+				type: error.problemType,
+				title: error.problemTitle,
+				status: error.status ?? 500,
+				detail: error.response !== void 0 && error.response !== error.problemTitle ? error.response : void 0
+			}));
+		} catch {}
+		try {
+			const r = error.toResponse();
+			return Promise.resolve(r).then((resolved) => resolved instanceof Response ? resolved.text() : wsErrorFrameFallback(error));
+		} catch {}
+	}
+	return wsErrorFrameFallback(error);
+}
+function wsErrorFrameFallback(error) {
+	if (error?.status) {
+		const body = error.response !== void 0 ? error.response : isProduction() ? error.status >= 500 ? "Internal Server Error" : "" : error.message ?? "";
+		return typeof body === "object" ? JSON.stringify(body) : String(body);
+	}
+	return internalServerErrorBodyString(error);
+}
+function sendErrorFrame(ws, error) {
+	const frame = wsErrorFrame(error);
+	if (typeof frame === "string") {
+		try {
+			ws.raw.send(frame);
+		} catch {}
+		return;
+	}
+	return frame.then((f) => {
+		try {
+			ws.raw.send(f);
+		} catch {}
+	}, () => {});
+}
+function validateUpgradeChannel(validator, value, type) {
+	if (validator instanceof StandardValidator) return validator.From(value, type);
+	if (validator.hasCodec) return validator.From(value, type);
+	return validator.EncodeFrom(value, type);
+}
+const wsOptions = [
+	"maxPayloadLength",
+	"backpressureLimit",
+	"closeOnBackpressureLimit",
+	"idleTimeout",
+	"publishToSelf",
+	"sendPings",
+	"perMessageDeflate"
+];
+function buildWSRoute(route, app) {
+	const hook = resolveWSLocalHook(localMacroRoot(route[7] ?? route[3] ?? app, app), route[4], app) ?? nullObject();
+	let validators;
+	const frozenEager = isBridgeLive() ? void 0 : buildFrozenRouteValidator(hook, app, "WS", route[1]);
+	if (frozenEager) validators = frozenEager;
+	else try {
+		validators = new RouteValidator(hook, {
+			models: frozenRootOf(app)["~ext"]?.models,
+			app,
+			aot: {
+				method: "WS",
+				path: route[1]
+			},
+			eager: frozenRootOf(app)["~config"]?.precompile
+		});
+	} catch (error) {
+		if (!isBridgeNotInitialized(error)) throw error;
+		const frozen = buildFrozenRouteValidator(hook, 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 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);
+	const allBeforeHandles = concatHooks(flatAppHook.beforeHandle, hook.beforeHandle);
+	const deriveEntries = [...flatAppHook["~deriveEntries"] ?? [], ...hook["~deriveEntries"] ?? []];
+	const deriveSet = deriveEntries.length ? new Set(deriveEntries.map(deriveEntryFn)) : void 0;
+	const upgradeDeriveModes = deriveModes(allBeforeHandles, deriveEntries);
+	const messageBeforeHandles = allBeforeHandles.filter((fn) => !deriveSet?.has(fn));
+	const afterHandles = concatHooks(flatAppHook.afterHandle, hook.afterHandle);
+	const mapResponses = concatHooks(flatAppHook.mapResponse, hook.mapResponse);
+	const afterResponses = concatHooks(flatAppHook.afterResponse, hook.afterResponse);
+	const errorHandlers = concatHooks(hook.error, flatAppHook.error);
+	const parseMessage = createMessageParser(parseHooks);
+	const handleUpgradeError = createErrorHandler(errorHandlers.length ? errorHandlers : void 0, ((response, set, context) => mapResponse(response, set, context?.request)), void 0, frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails);
+	async function handleError(ws, error) {
+		const errCtx = Object.create(ws);
+		errCtx.error = error;
+		if (frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails && error instanceof ValidationError) error.allowUnsafeValidationDetails = true;
+		for (let i = 0; i < errorHandlers.length; i++) {
+			let r;
+			try {
+				r = errorHandlers[i](errCtx);
+				if (r instanceof Promise) r = await r;
+			} catch {
+				break;
+			}
+			if (r !== void 0) {
+				try {
+					await handleWSResponse(ws, r, mapResponses);
+				} catch {}
+				return;
+			}
+		}
+		sendErrorFrame(ws, error);
+	}
+	const bodyValidator = validators.body;
+	function validateMessageBody(message) {
+		if (!bodyValidator) return message;
+		if (bodyValidator.hasCodec) return bodyValidator.From(message, "body");
+		if (bodyValidator instanceof StandardValidator) return bodyValidator.From(message, "body");
+		return bodyValidator.EncodeFrom(message, "body");
+	}
+	function onMessageValidationError(ws, error) {
+		if (errorHandlers.length === 0) {
+			if (frozenRootOf(app)["~config"]?.allowUnsafeValidationDetails && error instanceof ValidationError) error.allowUnsafeValidationDetails = true;
+			return sendErrorFrame(ws, error);
+		}
+		return handleError(ws, error);
+	}
+	const messageHandlerTouchesBody = !!bodyValidator || handlerMayTouchBody(hook.message) || errorHandlers.some(handlerMayTouchBody);
+	const syncDispatchEligible = transforms.length === 0 && messageBeforeHandles.length === 0 && afterHandles.length === 0 && afterResponses.length === 0 && mapResponses.length === 0;
+	function finishMessageResult(ws, value) {
+		if (value === void 0) return;
+		if (isGeneratorObject(value)) return handleWSResponse(ws, value, mapResponses).catch((error) => handleError(ws, error));
+		try {
+			ws.send(value);
+		} catch (error) {
+			return handleError(ws, error);
+		}
+	}
+	function dispatchParsedSync(ws, message) {
+		if (bodyValidator) {
+			let decoded;
+			try {
+				decoded = validateMessageBody(message);
+			} catch (error) {
+				return onMessageValidationError(ws, error);
+			}
+			if (decoded instanceof Promise) return decoded.then((m) => runMessage(ws, m), (error) => onMessageValidationError(ws, error));
+			message = decoded;
+		}
+		return runMessage(ws, message);
+	}
+	function runMessageSync(ws, message) {
+		try {
+			if (messageHandlerTouchesBody) ws.body = message;
+			const result = hook.message(ws, message);
+			if (result instanceof Promise) return result.then((resolved) => finishMessageResult(ws, resolved), (error) => handleError(ws, error));
+			return finishMessageResult(ws, result);
+		} catch (error) {
+			return handleError(ws, error);
+		}
+	}
+	async function runMessageFull(ws, message) {
+		try {
+			ws.body = message;
+			for (let i = 0; i < transforms.length; i++) {
+				const r = transforms[i](ws);
+				if (r instanceof Promise) await r;
+			}
+			for (let i = 0; i < messageBeforeHandles.length; i++) {
+				let r = messageBeforeHandles[i](ws);
+				if (r instanceof Promise) r = await r;
+				if (r !== void 0) {
+					await handleWSResponse(ws, r, mapResponses);
+					return;
+				}
+			}
+			const result = hook.message(ws, message);
+			const resolved = result instanceof Promise ? await result : result;
+			if (resolved !== void 0) await handleWSResponse(ws, resolved, mapResponses);
+			for (let i = 0; i < afterHandles.length; i++) {
+				const r = afterHandles[i](ws);
+				if (r instanceof Promise) await r;
+			}
+			for (let i = 0; i < afterResponses.length; i++) try {
+				const r = afterResponses[i](ws);
+				if (r instanceof Promise) await r;
+			} catch {}
+		} catch (error) {
+			await handleError(ws, error);
+		}
+	}
+	const runMessage = syncDispatchEligible ? runMessageSync : runMessageFull;
+	function dispatchMessageSync(connection, rawMessage) {
+		const ws = Object.create(connection);
+		try {
+			const p = parseMessage(ws, rawMessage);
+			if (p instanceof Promise) return p.then((message) => dispatchParsedSync(ws, message), (error) => handleError(ws, error));
+			return dispatchParsedSync(ws, p);
+		} catch (error) {
+			return handleError(ws, error);
+		}
+	}
+	function wrapLifecycle(fn, withBody) {
+		if (!fn) return;
+		return async (connection, bodyArg) => {
+			const ws = Object.create(connection);
+			try {
+				if (withBody) ws.body = bodyArg;
+				const result = withBody ? fn(ws, bodyArg) : fn(ws);
+				await handleWSResponse(ws, result instanceof Promise ? await result : result, mapResponses);
+			} catch (error) {
+				await handleError(ws, error);
+			}
+		};
+	}
+	const onOpen = wrapLifecycle(hook.open, false);
+	const onDrain = wrapLifecycle(hook.drain, false);
+	const onPing = wrapLifecycle(hook.ping, true);
+	const onPong = wrapLifecycle(hook.pong, true);
+	const onClose = hook.close ? async (connection, code, reason) => {
+		const ws = Object.create(connection);
+		try {
+			ws.code = code;
+			ws.reason = reason;
+			const fn = hook.close;
+			const result = fn(ws, code, reason);
+			await handleWSResponse(ws, result instanceof Promise ? await result : result, mapResponses);
+		} catch (error) {
+			await handleError(ws, error);
+		}
+	} : void 0;
+	const fetchHandler = async (context) => {
+		const request = context.request;
+		try {
+			if (validators.params) {
+				let r = validateUpgradeChannel(validators.params, context.params ?? nullObject(), "params");
+				if (r instanceof Promise) r = await r;
+				context.params = r;
+			}
+			if (validators.query) {
+				const url = request.url;
+				const query = parseQueryFromURL(url, context.qi ?? url.indexOf("?"), queryArray, queryObject);
+				let r = validateUpgradeChannel(validators.query, query, "query");
+				if (r instanceof Promise) r = await r;
+				context.query = r;
+			}
+			if (validators.headers) {
+				const headers = isBun ? request.headers.toJSON() : Object.fromEntries(request.headers);
+				let r = validateUpgradeChannel(validators.headers, headers, "headers");
+				if (r instanceof Promise) r = await r;
+				context.headers = r;
+			}
+			for (let i = 0; i < transforms.length; i++) {
+				const r = transforms[i](context);
+				if (r instanceof Promise) await r;
+			}
+			for (let i = 0; i < allBeforeHandles.length; i++) {
+				const fn = allBeforeHandles[i];
+				let r = fn(context);
+				if (r instanceof Promise) r = await r;
+				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 if (r !== void 0) {
+					if (r instanceof Response) return r;
+					return mapResponse(r, context.set, context.request);
+				}
+			}
+			let upgradeHeaders;
+			if (hook.upgrade != null) {
+				const r = typeof hook.upgrade === "function" ? hook.upgrade(context) : hook.upgrade;
+				const resolved = r instanceof Promise ? await r : r;
+				if (resolved && typeof resolved === "object") upgradeHeaders = resolved;
+			}
+			const server = app.server;
+			if (!server) return problemResponse({
+				status: 500,
+				type: "internal-server-error",
+				title: "Internal Server Error",
+				detail: "WebSocket upgrade requires a running server. Call .listen() first."
+			});
+			if (!server.upgrade(request, {
+				headers: upgradeHeaders,
+				data: {
+					id: void 0,
+					context,
+					validator: responseValidator,
+					defaultValidator: defaultResponseValidator,
+					open: onOpen,
+					message: hook.message ? dispatchMessageSync : void 0,
+					drain: onDrain,
+					close: onClose,
+					ping: onPing,
+					pong: onPong
+				}
+			})) return new Response("Expected a websocket connection", { status: 400 });
+		} catch (error) {
+			return handleUpgradeError(context, error);
+		}
+	};
+	const options = nullObject();
+	for (const k of wsOptions) if (hook[k] !== void 0) options[k] = hook[k];
+	return [fetchHandler, options];
+}
+function resolveWSOptions(entries) {
+	if (!entries || entries.length === 0) return void 0;
+	if (entries.length === 1) return { ...entries[0].value };
+	const ordered = entries.map((entry, index) => ({
+		entry,
+		index
+	})).sort((a, b) => b.entry.depth - a.entry.depth || a.index - b.index);
+	const result = {};
+	let warned;
+	for (const { entry } of ordered) for (const key in entry.value) {
+		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.`);
+		}
+		result[key] = incoming;
+	}
+	return result;
+}
+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);
+		}
+	}
+	Object.assign(target, routeOptions);
+}
+function buildGlobalWSHandler() {
+	function getElysia(ws) {
+		let elysia = ws.data.elysia;
+		if (!elysia) {
+			elysia = new ElysiaWS(ws, ws.data.context);
+			ws.data.elysia = elysia;
+			ws.data.context = void 0;
+		}
+		return elysia;
+	}
+	const sendErrMsg = (ws, error) => {
+		try {
+			ws.send(typeof error?.message === "string" ? error.message : "Internal Server Error");
+		} catch {}
+	};
+	return {
+		message(ws, message) {
+			let result;
+			try {
+				result = ws.data.message?.(getElysia(ws), message);
+			} catch (error) {
+				sendErrMsg(ws, error);
+				return;
+			}
+			if (result instanceof Promise) result.catch((error) => sendErrMsg(ws, error));
+		},
+		open(ws) {
+			ws.data.open?.(getElysia(ws));
+		},
+		drain(ws) {
+			const elyWs = getElysia(ws);
+			drainWaiters(elyWs);
+			ws.data.drain?.(elyWs);
+		},
+		close(ws, code, reason) {
+			const elyWs = getElysia(ws);
+			drainWaiters(elyWs);
+			if (ws.data.closeHandlerInvoked) return;
+			ws.data.closeHandlerInvoked = true;
+			ws.data.close?.(elyWs, code, reason);
+		},
+		ping(ws, data) {
+			ws.data.ping?.(getElysia(ws), data);
+		},
+		pong(ws, data) {
+			ws.data.pong?.(getElysia(ws), data);
+		}
+	};
+}
+
+//#endregion
+export { accumulateWSOptions, buildGlobalWSHandler, buildWSRoute, drainWaiters, handleWSResponse, resolveWSOptions };