alepha 0.14.4 → 0.15.0

package/dist/server/core/index.js

@@ -1,7 +1,8 @@
-import { $env, $hook, $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive, isFileLike, isTypeFile, isUUID, t } from "alepha";
+import { $env, $hook, $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive, isFileLike, isTypeFile, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { Readable } from "node:stream";
 import { DateTimeProvider } from "alepha/datetime";
+import { randomUUID } from "node:crypto";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
 import { RouterProvider } from "alepha/router";
 import { $cache } from "alepha/cache";
@@ -256,7 +257,7 @@ var ServerTimingProvider = class {
 	onRequest = $hook({
 		priority: "first",
 		on: "server:onRequest",
-		handler: async ({ request }) => {
+		handler: ({ request }) => {
 			if (this.options.disabled) return;
 			request.metadata.timing = {};
 			request.metadata.timing[this.handlerName] = [Date.now()];
@@ -265,7 +266,7 @@ var ServerTimingProvider = class {
 	onResponse = $hook({
 		priority: "last",
 		on: "server:onResponse",
-		handler: async ({ request }) => {
+		handler: ({ request }) => {
 			if (this.options.disabled) return;
 			if (request.metadata.timing) {
 				this.setDuration(this.handlerName, request.metadata.timing);
@@ -317,11 +318,12 @@ var ServerTimingProvider = class {
 //#endregion
 //#region ../../src/server/core/providers/ServerRouterProvider.ts
 /**
-* Main router for all routes on the server side.
+* Main router for all routes server side.
 *
+* Reminder:
 * - $route => generic route
 * - $action => action route (for API calls)
-* - $page => React route (for SSR)
+* - $page => React route (for React SSR)
 */
 var ServerRouterProvider = class extends RouterProvider {
 	log = $logger();
@@ -329,6 +331,43 @@ var ServerRouterProvider = class extends RouterProvider {
 	routes = [];
 	serverTimingProvider = $inject(ServerTimingProvider);
 	serverRequestParser = $inject(ServerRequestParser);
+	compiledOnRequest;
+	compiledOnSend;
+	compiledOnResponse;
+	compiledOnError;
+	contextRunOptions = {
+		context: "",
+		_request: null,
+		_route: null,
+		_responseKind: "any"
+	};
+	processRequestBound = () => {
+		const opts = this.contextRunOptions;
+		return this.processRequest(opts._request, opts._route, opts._responseKind);
+	};
+	queryKeysCache = /* @__PURE__ */ new WeakMap();
+	/**
+	* Get cached keys for a query schema, computing them lazily on first access.
+	*/
+	getQuerySchemaKeys(schema) {
+		let keys = this.queryKeysCache.get(schema.properties);
+		if (!keys) {
+			keys = Object.keys(schema.properties);
+			this.queryKeysCache.set(schema.properties, keys);
+		}
+		return keys;
+	}
+	/**
+	* Compile event executors for optimal performance.
+	* Called lazily on first request after all hooks are registered.
+	*/
+	compileEvents() {
+		if (this.compiledOnRequest) return;
+		this.compiledOnRequest = this.alepha.events.compile("server:onRequest");
+		this.compiledOnSend = this.alepha.events.compile("server:onSend", { catch: true });
+		this.compiledOnResponse = this.alepha.events.compile("server:onResponse", { catch: true });
+		this.compiledOnError = this.alepha.events.compile("server:onError");
+	}
 	/**
 	* Get all registered routes, optionally filtered by a pattern.
 	*
@@ -342,6 +381,9 @@ var ServerRouterProvider = class extends RouterProvider {
 		} else return this.routes.filter((route) => route.path === pattern);
 		return this.routes;
 	}
+	/**
+	* Create a new server route.
+	*/
 	createRoute(route) {
 		route.method ??= "GET";
 		route.method = route.method.toUpperCase();
@@ -353,100 +395,135 @@ var ServerRouterProvider = class extends RouterProvider {
 			path,
 			handler: (rawRequest) => {
 				const request = this.serverRequestParser.createServerRequest(rawRequest);
-				return this.alepha.context.run(() => this.processRequest(request, route, responseKind), { context: this.getContextId(rawRequest.headers) });
+				const opts = this.contextRunOptions;
+				opts.context = this.getContextId(rawRequest.headers);
+				opts._request = request;
+				opts._route = route;
+				opts._responseKind = responseKind;
+				return this.alepha.context.run(this.processRequestBound, opts);
 			}
 		});
 	}
+	/**
+	* Get or generate a context ID from request headers.
+	*/
 	getContextId(headers) {
-		const contextId = headers["x-request-id"] || headers["x-correlation-id"];
-		if (isUUID(contextId)) return contextId;
-		return crypto.randomUUID();
+		const contextId = headers[HEADER_REQUEST_ID] || headers[HEADER_CORRELATION_ID];
+		if (contextId) return contextId;
+		return randomUUID();
 	}
+	/**
+	* Process an incoming request through the full lifecycle:
+	* - onRequest hooks
+	* - route handler
+	* - onSend hooks
+	* - response serialization
+	* - onResponse hooks
+	*/
 	async processRequest(request, route, responseKind) {
-		await this.runRouteHandler(route, request, responseKind).catch((error) => {
-			return this.errorHandler(route, request, error);
-		});
-		await this.alepha.events.emit("server:onSend", {
+		this.compileEvents();
+		try {
+			await this.runRouteHandler(route, request, responseKind);
+		} catch (error) {
+			await this.errorHandler(route, request, error);
+		}
+		const reply = request.reply;
+		const payload = {
 			request,
-			route
-		}, { catch: true });
+			route,
+			response: void 0
+		};
+		const onSendResult = this.compiledOnSend(payload);
+		if (onSendResult) await onSendResult;
 		const response = {
-			status: request.reply.status ?? (request.reply.body ? 200 : 204),
-			headers: request.reply.headers,
-			body: request.reply.body
+			status: reply.status ?? (reply.body ? 200 : 204),
+			headers: reply.headers,
+			body: reply.body
 		};
-		await this.alepha.events.emit("server:onResponse", {
-			request,
-			route,
-			response
-		}, { catch: true });
+		payload.response = response;
+		const onResponseResult = this.compiledOnResponse(payload);
+		if (onResponseResult) await onResponseResult;
 		return response;
 	}
+	/**
+	* Run the route handler with request validation and response serialization.
+	*/
 	async runRouteHandler(route, request, responseKind) {
-		await this.alepha.events.emit("server:onRequest", {
+		const timing = this.serverTimingProvider;
+		const payload = {
 			request,
 			route
-		}, { log: false });
-		if (request.reply.body || request.reply.status && request.reply.status >= 200) return;
-		this.alepha.context.set("request", request);
-		this.serverTimingProvider.beginTiming("validateRequest");
+		};
+		const onRequestResult = this.compiledOnRequest(payload);
+		if (onRequestResult) await onRequestResult;
+		const reply = request.reply;
+		if (reply.body || reply.status && reply.status >= 200) return;
+		this.alepha.context.set(CTX_REQUEST, request);
+		timing.beginTiming(TIMING_VALIDATE);
 		try {
 			this.validateRequest(route, request);
 		} finally {
-			this.serverTimingProvider.endTiming("validateRequest");
+			timing.endTiming(TIMING_VALIDATE);
 		}
-		this.serverTimingProvider.beginTiming("runHandler");
+		timing.beginTiming(TIMING_HANDLER);
 		try {
 			const result = await route.handler(request);
 			if (result) request.reply.body = result;
 		} finally {
-			this.serverTimingProvider.endTiming("runHandler");
+			timing.endTiming(TIMING_HANDLER);
 		}
-		this.serverTimingProvider.beginTiming("serializeResponse");
+		timing.beginTiming(TIMING_SERIALIZE);
 		try {
 			this.serializeResponse(route, request.reply, responseKind);
 		} finally {
-			this.serverTimingProvider.endTiming("serializeResponse");
+			timing.endTiming(TIMING_SERIALIZE);
 		}
 	}
+	/**
+	* Transform reply body based on response kind and route schema.
+	*/
 	serializeResponse(route, reply, responseKind) {
+		const headers = reply.headers;
 		if (responseKind === "json" && route.schema?.response) {
-			reply.headers["content-type"] = "application/json";
-			reply.body = this.alepha.codec.encode(route.schema.response, reply.body, { as: "string" });
+			headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_JSON;
+			reply.body = this.alepha.codec.encode(route.schema.response, reply.body, ENCODE_OPTIONS_STRING);
 			return;
 		}
 		if (responseKind === "file") {
 			if (!isFileLike(reply.body)) throw new HttpError({
 				status: 500,
-				message: "Invalid response body - not a file"
+				message: ERROR_NOT_FILE
 			});
-			reply.headers["content-type"] = reply.body.type;
-			reply.headers["content-disposition"] = `attachment; filename="${reply.body.name.replaceAll("\"", "")}"`;
+			headers[HEADER_CONTENT_TYPE] = reply.body.type;
+			headers[HEADER_CONTENT_DISPOSITION] = `attachment; filename="${reply.body.name.replaceAll("\"", "")}"`;
 			reply.body = reply.body.stream();
 			return;
 		}
 		if (responseKind === "text") {
 			reply.body = String(reply.body);
-			if (reply.body.startsWith("<!DOCTYPE html>")) reply.headers["content-type"] ??= "text/html; charset=UTF-8";
-			else reply.headers["content-type"] ??= "text/plain";
+			if (reply.body.length > 15 && reply.body.charCodeAt(0) === 60 && reply.body.startsWith("<!DOCTYPE html>")) headers[HEADER_CONTENT_TYPE] ??= CONTENT_TYPE_HTML;
+			else headers[HEADER_CONTENT_TYPE] ??= CONTENT_TYPE_TEXT;
 			return;
 		}
 		if (reply.body == null || responseKind === "void") {
-			delete reply.headers["content-type"];
+			delete headers[HEADER_CONTENT_TYPE];
 			reply.body = void 0;
 			return;
 		}
 		if (Buffer.isBuffer(reply.body)) {
-			reply.headers["content-type"] ??= "application/octet-stream";
+			headers[HEADER_CONTENT_TYPE] ??= CONTENT_TYPE_OCTET;
 			return;
 		}
 		if (reply.body instanceof ReadableStream$1 || reply.body instanceof Readable) {
-			reply.headers["content-type"] ??= "application/octet-stream";
+			headers[HEADER_CONTENT_TYPE] ??= CONTENT_TYPE_OCTET;
 			return;
 		}
-		reply.headers["content-type"] ??= "text/plain";
+		headers[HEADER_CONTENT_TYPE] ??= CONTENT_TYPE_TEXT;
 		reply.body = String(reply.body);
 	}
+	/**
+	* Determine response type based on route schema.
+	*/
 	getResponseType(schema) {
 		if (schema?.response) {
 			if (t.schema.isObject(schema.response) || t.schema.isRecord(schema.response) || t.schema.isArray(schema.response)) return "json";
@@ -456,42 +533,52 @@ var ServerRouterProvider = class extends RouterProvider {
 		}
 		return "any";
 	}
+	/**
+	* When an error occurs during request processing, this method is called.
+	*/
 	async errorHandler(route, request, error) {
-		request.reply.body = null;
-		await this.alepha.events.emit("server:onError", {
+		const reply = request.reply;
+		const headers = reply.headers;
+		const requestId = request.requestId;
+		reply.body = null;
+		const onErrorResult = this.compiledOnError({
 			request,
 			route,
 			error
-		}, { log: false });
-		if (!request.reply.body && !request.reply.status) if (error instanceof HttpError) {
-			request.reply.status = error.status;
-			request.reply.headers["content-type"] = "application/json";
-			request.reply.body = JSON.stringify({
-				...HttpError.toJSON(error),
-				requestId: request.requestId
-			});
+		});
+		if (onErrorResult) await onErrorResult;
+		if (!reply.body && !reply.status) if (error instanceof HttpError) {
+			reply.status = error.status;
+			headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_JSON;
+			const errorJson = HttpError.toJSON(error);
+			errorJson.requestId = requestId;
+			reply.body = JSON.stringify(errorJson);
 		} else {
 			if ("status" in error && typeof error.status === "number" && !!errorNameByStatus[error.status]) {
-				request.reply.status = error.status;
-				request.reply.headers["content-type"] = "application/json";
-				request.reply.body = JSON.stringify({
-					status: error.status,
-					error: errorNameByStatus[error.status],
+				const status = error.status;
+				reply.status = status;
+				headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_JSON;
+				reply.body = JSON.stringify({
+					status,
+					error: errorNameByStatus[status],
 					message: error.message,
-					requestId: request.requestId
+					requestId
 				});
 				return;
 			}
-			request.reply.status = 500;
-			request.reply.headers["content-type"] = "application/json";
-			request.reply.body = JSON.stringify({
+			reply.status = 500;
+			headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_JSON;
+			reply.body = JSON.stringify({
 				status: 500,
-				error: "InternalServerError",
+				error: ERROR_INTERNAL,
 				message: error.message,
-				requestId: request.requestId
+				requestId
 			});
 		}
 	}
+	/**
+	* Validate incoming request against route schema.
+	*/
 	validateRequest(route, request) {
 		if (route.schema?.params) try {
 			request.params = this.alepha.codec.validate(route.schema.params, request.params);
@@ -499,8 +586,13 @@ var ServerRouterProvider = class extends RouterProvider {
 			throw new ValidationError("Invalid request params", error);
 		}
 		if (route.schema?.query) try {
+			const schemaQuery = route.schema.query;
+			const keys = this.getQuerySchemaKeys(schemaQuery);
 			const query = {};
-			for (const key in route.schema.query.properties) if (request.query[key] != null) query[key] = this.alepha.codec.decode(route.schema.query.properties[key], request.query[key]);
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				if (request.query[key] != null) query[key] = this.alepha.codec.decode(schemaQuery.properties[key], request.query[key]);
+			}
 			request.query = query;
 		} catch (error) {
 			throw new ValidationError("Invalid request query", error);
@@ -519,9 +611,28 @@ var ServerRouterProvider = class extends RouterProvider {
 		}
 	}
 };
+const ENCODE_OPTIONS_STRING = Object.freeze({ as: "string" });
+const HEADER_CONTENT_TYPE = "content-type";
+const HEADER_CONTENT_DISPOSITION = "content-disposition";
+const HEADER_REQUEST_ID = "x-request-id";
+const HEADER_CORRELATION_ID = "x-correlation-id";
+const CONTENT_TYPE_JSON = "application/json";
+const CONTENT_TYPE_TEXT = "text/plain";
+const CONTENT_TYPE_HTML = "text/html; charset=UTF-8";
+const CONTENT_TYPE_OCTET = "application/octet-stream";
+const TIMING_VALIDATE = "validateRequest";
+const TIMING_HANDLER = "runHandler";
+const TIMING_SERIALIZE = "serializeResponse";
+const CTX_REQUEST = "request";
+const ERROR_INTERNAL = "InternalServerError";
+const ERROR_NOT_FILE = "Invalid response body - not a file";
 
 //#endregion
 //#region ../../src/server/core/providers/ServerProvider.ts
+const HEADER_X_FORWARDED_PROTO = "x-forwarded-proto";
+const HEADER_HOST = "host";
+const PROTO_HTTPS = "https://";
+const PROTO_HTTP = "http://";
 /**
 * Base server provider to handle incoming requests and route them.
 *
@@ -535,6 +646,71 @@ var ServerProvider = class {
 	dateTimeProvider = $inject(DateTimeProvider);
 	router = $inject(ServerRouterProvider);
 	internalServerErrorMessage = "Internal Server Error";
+	internalErrorResponse = Object.freeze({
+		status: 500,
+		headers: Object.freeze({ "content-type": "text/plain" }),
+		body: this.internalServerErrorMessage
+	});
+	handleInternalError = () => this.internalErrorResponse;
+	urlBaseCache = /* @__PURE__ */ new Map();
+	/**
+	* Get cached URL base (protocol + host) for a given host header.
+	* Caches the result to avoid repeated string concatenation.
+	*/
+	getUrlBase(headers) {
+		const host = headers[HEADER_HOST];
+		let base = this.urlBaseCache.get(host);
+		if (!base) {
+			base = (headers[HEADER_X_FORWARDED_PROTO] === "https" ? PROTO_HTTPS : PROTO_HTTP) + host;
+			if (this.urlBaseCache.size < 100) this.urlBaseCache.set(host, base);
+		}
+		return base;
+	}
+	/**
+	* Parse query string manually - faster than new URL() + URLSearchParams.
+	* Returns empty object if no query string.
+	*/
+	parseQueryString(rawUrl) {
+		const qIndex = rawUrl.indexOf("?");
+		if (qIndex === -1) return {};
+		const qs = rawUrl.slice(qIndex + 1);
+		if (!qs) return {};
+		const query = {};
+		let start = 0;
+		let eqIdx = -1;
+		for (let i = 0; i <= qs.length; i++) {
+			const char = i < qs.length ? qs.charCodeAt(i) : 38;
+			if (char === 61) eqIdx = i;
+			else if (char === 38) {
+				if (eqIdx !== -1 && eqIdx > start) {
+					const key = qs.slice(start, eqIdx);
+					const value = qs.slice(eqIdx + 1, i);
+					query[this.fastDecode(key)] = this.fastDecode(value);
+				}
+				start = i + 1;
+				eqIdx = -1;
+			}
+		}
+		return query;
+	}
+	/**
+	* Fast decode - only calls decodeURIComponent if needed.
+	*/
+	fastDecode(str) {
+		if (str.indexOf("%") === -1 && str.indexOf("+") === -1) return str;
+		try {
+			return decodeURIComponent(str.replace(/\+/g, " "));
+		} catch {
+			return str;
+		}
+	}
+	/**
+	* Extract pathname from URL without creating URL object.
+	*/
+	getPathname(rawUrl) {
+		const qIndex = rawUrl.indexOf("?");
+		return qIndex === -1 ? rawUrl : rawUrl.slice(0, qIndex);
+	}
 	get hostname() {
 		if (this.alepha.isViteDev()) return `http://localhost:${this.alepha.env.SERVER_PORT}`;
 		return "";
@@ -558,36 +734,31 @@ var ServerProvider = class {
 	/**
 	* Handle Node.js HTTP request event.
 	*
-	* Technically, we just convert Node.js request to Web Standard Request.
+	* Optimized to avoid expensive URL parsing when possible.
 	*/
 	async handleNodeRequest(nodeRequestEvent) {
 		const { req, res } = nodeRequestEvent;
-		const { route, params } = this.router.match(`/${req.method}${req.url}`);
-		if (this.isViteNotFound(req.url, route, params)) return;
+		const rawUrl = req.url;
+		const { route, params } = this.router.match(`/${req.method}${rawUrl}`);
+		if (this.isViteNotFound(rawUrl, route, params)) return;
 		if (!route) {
 			res.writeHead(404, { "content-type": "text/plain" });
 			res.end("Not Found");
 			return;
 		}
 		const headers = req.headers ?? {};
-		const proto = headers["x-forwarded-proto"] === "https" ? "https" : "http";
-		const url = new URL(`${proto}://${headers.host}${req.url}`);
-		const query = Object.fromEntries(url.searchParams.entries());
+		const method = req.method?.toUpperCase() ?? "GET";
+		const query = this.parseQueryString(rawUrl);
+		const urlBase = this.getUrlBase(headers);
 		const request = {
-			method: req.method?.toUpperCase() ?? "GET",
-			url,
+			method,
+			url: new URL(rawUrl, urlBase),
 			headers,
 			params: params ?? {},
 			query,
 			raw: { node: nodeRequestEvent }
 		};
-		const response = await route.handler(request).catch(() => {
-			return {
-				status: 500,
-				headers: { "content-type": "text/plain" },
-				body: this.internalServerErrorMessage
-			};
-		});
+		const response = await route.handler(request).catch(this.handleInternalError);
 		if (!response.body) {
 			res.writeHead(response.status, response.headers).end();
 			return;
@@ -637,7 +808,7 @@ var ServerProvider = class {
 		req.headers.forEach((value, key) => {
 			headers[key] = value;
 		});
-		const query = Object.fromEntries(url.searchParams.entries());
+		const query = url.search ? Object.fromEntries(url.searchParams.entries()) : {};
 		const request = {
 			method: req.method.toUpperCase() ?? "GET",
 			url,
@@ -646,13 +817,7 @@ var ServerProvider = class {
 			query,
 			raw: { web: ev }
 		};
-		const response = await route.handler(request).catch(() => {
-			return {
-				status: 500,
-				headers: { "content-type": "text/plain" },
-				body: this.internalServerErrorMessage
-			};
-		});
+		const response = await route.handler(request).catch(this.handleInternalError);
 		if (!response.body) {
 			ev.res = new Response(null, {
 				status: response.status,
@@ -1295,16 +1460,20 @@ var NodeHttpServerProvider = class extends ServerProvider {
 		}
 		return `http://${this.env.SERVER_HOST}:${this.env.SERVER_PORT}`;
 	}
+	handleRequestError = (res, err) => {
+		this.log.error("Error handling request", err);
+		res.statusCode = 500;
+		res.end("Internal Server Error");
+	};
+	nodeRequestEvent = {
+		req: null,
+		res: null
+	};
 	server = this.createHttpServer((req, res) => {
-		this.log.trace(`Incoming Node.js message -> ${req.url}`);
-		this.handleNodeRequest({
-			req,
-			res
-		}).catch((err) => {
-			this.log.error("Error handling request", err);
-			res.statusCode = 500;
-			res.end("Internal Server Error");
-		});
+		const ev = this.nodeRequestEvent;
+		ev.req = req;
+		ev.res = res;
+		this.handleNodeRequest(ev).catch((err) => this.handleRequestError(res, err));
 	});
 	start = $hook({
 		on: "start",
@@ -1370,22 +1539,21 @@ var ServerBodyParserProvider = class {
 	log = $logger();
 	onRequest = $hook({
 		on: "server:onRequest",
-		handler: async ({ route, request }) => {
+		handler: ({ route, request }) => {
 			if (request.body) return;
 			let stream;
 			if (request.raw.web?.req.body) stream = request.raw.web.req.body;
 			else if (request.raw.node?.req) stream = ReadableStream$1.from(request.raw.node.req);
 			if (!stream) return;
-			if (route.schema?.body) try {
-				const body = await this.parse(stream, request.headers, route.schema.body);
+			if (route.schema?.body) return this.parse(stream, request.headers, route.schema.body).then((body) => {
 				if (body) request.body = body;
-			} catch (error) {
+			}).catch((error) => {
 				if (error instanceof HttpError) throw error;
 				throw new HttpError({
 					status: 400,
 					message: "Failed to parse request body"
 				}, error);
-			}
+			});
 		}
 	});
 	async parse(stream, headers, schema) {
@@ -1475,19 +1643,18 @@ var ServerLoggerProvider = class {
 		on: "server:onRequest",
 		priority: "first",
 		handler: ({ route, request }) => {
-			if (!route.silent) {
-				request.metadata.now = Date.now();
-				const data = {
-					method: request.method,
-					path: request.url.pathname
-				};
-				if (this.alepha.isProduction()) {
-					data.agent = request.headers["user-agent"];
-					const ip = request.ip;
-					if (ip) data.ip = ip;
-				}
-				this.log.info("Incoming request", data);
+			if (route.silent) return;
+			request.metadata.now = Date.now();
+			const data = {
+				method: request.method,
+				path: request.url.pathname
+			};
+			if (this.alepha.isProduction()) {
+				data.agent = request.headers["user-agent"];
+				const ip = request.ip;
+				if (ip) data.ip = ip;
 			}
+			this.log.info("Incoming request", data);
 		}
 	});
 	onError = $hook({
@@ -1501,13 +1668,12 @@ var ServerLoggerProvider = class {
 		on: "server:onResponse",
 		priority: "last",
 		handler: ({ route, request, response }) => {
-			if (!route.silent) {
-				const ms = Date.now() - request.metadata.now;
-				this.log.info("Request completed", {
-					status: response.status,
-					ms
-				});
-			}
+			if (route.silent) return;
+			const ms = Date.now() - request.metadata.now;
+			this.log.info("Request completed", {
+				status: response.status,
+				ms
+			});
 		}
 	});
 };