alepha 0.12.1 → 0.13.1

package/dist/server/index.cjs

@@ -1,1680 +0,0 @@
-let alepha = require("alepha");
-let alepha_logger = require("alepha/logger");
-let node_stream = require("node:stream");
-let alepha_datetime = require("alepha/datetime");
-let node_stream_web = require("node:stream/web");
-let alepha_router = require("alepha/router");
-let alepha_cache = require("alepha/cache");
-let node_http = require("node:http");
-let node_zlib = require("node:zlib");
-
-//#region src/server/helpers/isMultipart.ts
-/**
-* Checks if the route has multipart/form-data request body.
-*/
-const isMultipart = (options) => {
-	if (options.requestBodyType === "multipart/form-data") return true;
-	if (options.schema?.body && "properties" in options.schema.body) {
-		const properties = options.schema.body.properties;
-		for (const key in properties) if (properties[key].format === "binary") return true;
-	}
-	return false;
-};
-
-//#endregion
-//#region src/server/helpers/ServerReply.ts
-/**
-* Helper for building server replies.
-*/
-var ServerReply = class {
-	headers = {};
-	status;
-	body;
-	/**
-	* Redirect to a given URL with optional status code (default 302).
-	*/
-	redirect(url, status = 302) {
-		this.status = status;
-		this.headers.location = url;
-	}
-	/**
-	* Set the response status code.
-	*/
-	setStatus(status) {
-		this.status = status;
-		return this;
-	}
-	/**
-	* Set a response header.
-	*/
-	setHeader(name, value) {
-		this.headers[name.toLowerCase()] = value;
-		return this;
-	}
-	/**
-	* Set the response body.
-	*/
-	setBody(body) {
-		this.body = body;
-		return this;
-	}
-};
-
-//#endregion
-//#region src/server/errors/HttpError.ts
-const isHttpError = (error, status) => {
-	if (!(!!error && typeof error === "object" && "message" in error && typeof error.message === "string" && "status" in error && typeof error.status === "number")) return false;
-	if (status) return error.status === status;
-	return true;
-};
-var HttpError = class extends alepha.AlephaError {
-	name = "HttpError";
-	static is = isHttpError;
-	static toJSON(error) {
-		const json = {
-			error: error.error,
-			status: error.status,
-			message: error.message
-		};
-		if (error.details) json.details = error.details;
-		if (error.requestId) json.requestId = error.requestId;
-		if (error.reason) json.cause = error.reason;
-		return json;
-	}
-	error;
-	status;
-	requestId;
-	details;
-	reason;
-	constructor(options, cause) {
-		super(options.message, { cause });
-		this.status = options.status ?? 500;
-		this.details = options.details;
-		this.requestId = options.requestId;
-		if (typeof options.cause === "object") this.reason = {
-			name: options.cause.name,
-			message: options.cause.message
-		};
-		else if (cause instanceof Error) this.reason = {
-			name: cause.name,
-			message: cause.message
-		};
-		if (this.constructor.name === "HttpError") this.error = options.error ?? errorNameByStatus[this.status] ?? "HttpError";
-		else this.error = this.constructor.name;
-	}
-};
-const errorNameByStatus = {
-	400: "BadRequestError",
-	401: "UnauthorizedError",
-	403: "ForbiddenError",
-	404: "NotFoundError",
-	405: "MethodNotAllowedError",
-	409: "ConflictError",
-	410: "GoneError",
-	413: "PayloadTooLargeError",
-	415: "UnsupportedMediaTypeError",
-	429: "TooManyRequestsError",
-	500: "InternalServerError",
-	501: "NotImplementedError",
-	502: "BadGatewayError",
-	503: "ServiceUnavailableError",
-	504: "GatewayTimeoutError"
-};
-
-//#endregion
-//#region src/server/errors/ValidationError.ts
-var ValidationError = class extends HttpError {
-	constructor(message = "Validation has failed", cause) {
-		super({
-			message,
-			status: 400
-		}, cause);
-	}
-};
-
-//#endregion
-//#region src/server/services/UserAgentParser.ts
-/**
-* Simple User-Agent parser to detect OS, browser, and device type.
-* This parser is not exhaustive and may not cover all edge cases.
-*
-* Use result for non
-*/
-var UserAgentParser = class {
-	parse(userAgent = "") {
-		const ua = userAgent.toLowerCase();
-		let os = "Windows";
-		let browser = "Chrome";
-		let device = "DESKTOP";
-		if (ua.includes("windows phone")) os = "Windows Phone";
-		else if (ua.includes("windows")) os = "Windows";
-		else if (ua.includes("android")) os = "Android";
-		else if (ua.includes("iphone") || ua.includes("ipad") || ua.includes("ipod") || ua.includes("ios") && !ua.includes("android")) os = "iOS";
-		else if (ua.includes("mac os") || ua.includes("macos") || ua.includes("macintosh")) os = "MacOS";
-		else if (ua.includes("cros") || ua.includes("chromeos")) os = "ChromeOS";
-		else if (ua.includes("ubuntu")) os = "Ubuntu";
-		else if (ua.includes("freebsd")) os = "FreeBSD";
-		else if (ua.includes("openbsd")) os = "OpenBSD";
-		else if (ua.includes("blackberry") || ua.includes("bb10")) os = "BlackBerry";
-		else if (ua.includes("symbian") || ua.includes("symbos")) os = "Symbian";
-		else if (ua.includes("linux") || ua.includes("x11")) os = "Linux";
-		if (ua.includes("yabrowser") || ua.includes("yandex")) browser = "Yandex";
-		else if (ua.includes("brave")) browser = "Brave";
-		else if (ua.includes("vivaldi")) browser = "Vivaldi";
-		else if (ua.includes("samsungbrowser") || ua.includes("samsung")) browser = "Samsung Browser";
-		else if (ua.includes("ucbrowser") || ua.includes("uc browser")) browser = "UC Browser";
-		else if (ua.includes("opera") || ua.includes("opr/") || ua.includes("opios")) browser = "Opera";
-		else if (ua.includes("edg/") || ua.includes("edge") || ua.includes("edgios")) browser = "Edge";
-		else if (ua.includes("firefox") && !ua.includes("seamonkey")) browser = "Firefox";
-		else if (ua.includes("trident") || ua.includes("msie")) browser = "Internet Explorer";
-		else if (ua.includes("safari") && !ua.includes("chrome") && !ua.includes("chromium")) browser = "Safari";
-		else if (ua.includes("chrome") || ua.includes("chromium") || ua.includes("crios")) browser = "Chrome";
-		const mobileKeywords = [
-			"mobile",
-			"android",
-			"iphone",
-			"ipod",
-			"blackberry",
-			"windows phone",
-			"opera mini",
-			"iemobile",
-			"mobile safari",
-			"nokia",
-			"symbian"
-		];
-		const isTablet = [
-			"ipad",
-			"tablet",
-			"kindle",
-			"silk",
-			"gt-p",
-			"sm-t",
-			"nexus 7",
-			"nexus 10"
-		].some((keyword) => ua.includes(keyword));
-		const isMobile = mobileKeywords.some((keyword) => ua.includes(keyword));
-		if (isTablet) device = "TABLET";
-		else if (isMobile) device = "MOBILE";
-		else device = "DESKTOP";
-		return {
-			os,
-			browser,
-			device
-		};
-	}
-};
-
-//#endregion
-//#region src/server/services/ServerRequestParser.ts
-var ServerRequestParser = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	userAgentParser = (0, alepha.$inject)(UserAgentParser);
-	createServerRequest(rawRequest) {
-		const self = this;
-		return {
-			method: rawRequest.method,
-			url: rawRequest.url,
-			raw: rawRequest.raw,
-			headers: rawRequest.headers,
-			query: rawRequest.query,
-			params: rawRequest.params,
-			body: null,
-			metadata: {},
-			requestId: this.getRequestId(rawRequest) || crypto.randomUUID(),
-			reply: this.alepha.inject(ServerReply, { lifetime: "transient" }),
-			get ip() {
-				return self.getRequestIp(rawRequest);
-			},
-			get userAgent() {
-				return self.getRequestUserAgent(rawRequest);
-			}
-		};
-	}
-	getRequestId(request) {
-		return request.headers["x-request-id"];
-	}
-	getRequestUserAgent(request) {
-		return this.userAgentParser.parse(request.headers["user-agent"]);
-	}
-	getRequestIp(request) {
-		const forwardedFor = request.headers["x-forwarded-for"];
-		if (forwardedFor) return Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor.split(",")[0].trim();
-		const xRealIP = request.headers["x-real-ip"];
-		if (xRealIP) return Array.isArray(xRealIP) ? xRealIP[0] : xRealIP;
-	}
-};
-
-//#endregion
-//#region src/server/providers/ServerTimingProvider.ts
-var ServerTimingProvider = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	options = {
-		prefix: this.alepha.env.APP_NAME ? `${this.alepha.env.APP_NAME.toLowerCase()}-` : "",
-		disabled: this.alepha.isProduction()
-	};
-	onRequest = (0, alepha.$hook)({
-		priority: "first",
-		on: "server:onRequest",
-		handler: async ({ request }) => {
-			if (this.options.disabled) return;
-			request.metadata.timing = {};
-			request.metadata.timing[this.handlerName] = [Date.now()];
-		}
-	});
-	onResponse = (0, alepha.$hook)({
-		priority: "last",
-		on: "server:onResponse",
-		handler: async ({ request }) => {
-			if (this.options.disabled) return;
-			if (request.metadata.timing) {
-				this.setDuration(this.handlerName, request.metadata.timing);
-				let timingHeader = "";
-				for (const [name, [start, duration]] of Object.entries(request.metadata.timing)) {
-					if (typeof start !== "number" || typeof duration !== "number") {
-						this.log.warn(`Invalid timing for '${name}': [${start}, ${duration}]`);
-						continue;
-					}
-					const formattedName = this.options.prefix + name.replace(/[^a-zA-Z0-9-]/g, "-");
-					timingHeader += `${formattedName};dur=${duration}, `;
-				}
-				if (request.reply.headers["Server-Timing"]) request.reply.headers["Server-Timing"] += `, ${timingHeader}`;
-				else request.reply.headers["Server-Timing"] = timingHeader;
-			}
-		}
-	});
-	get handlerName() {
-		return `request`;
-	}
-	beginTiming(name) {
-		if (this.options.disabled) return;
-		const request = this.alepha.context.get("request");
-		if (!request) return;
-		request.metadata ??= {};
-		request.metadata.timing ??= {};
-		request.metadata.timing[name] = [Date.now()];
-	}
-	endTiming(name) {
-		if (this.options.disabled) return;
-		const request = this.alepha.context.get("request");
-		if (!request) return;
-		if (!request.metadata?.timing || !(name in request.metadata.timing)) {
-			this.log.warn(`No timing found for '${name}'.`);
-			return;
-		}
-		const start = request.metadata.timing[name]?.[0];
-		if (typeof start !== "number") {
-			this.log.warn(`Invalid timing start for '${name}': ${start}`);
-			return;
-		}
-		this.setDuration(name, request.metadata.timing);
-	}
-	setDuration(name, timing) {
-		timing[name] = [timing[name][0], Date.now() - timing[name][0]];
-	}
-};
-
-//#endregion
-//#region src/server/providers/ServerRouterProvider.ts
-/**
-* Main router for all routes on the server side.
-*
-* - $route => generic route
-* - $action => action route (for API calls)
-* - $page => React route (for SSR)
-*/
-var ServerRouterProvider = class extends alepha_router.RouterProvider {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	routes = [];
-	serverTimingProvider = (0, alepha.$inject)(ServerTimingProvider);
-	serverRequestParser = (0, alepha.$inject)(ServerRequestParser);
-	/**
-	* Get all registered routes, optionally filtered by a pattern.
-	*
-	* Pattern accept simple wildcard '*' at the end.
-	* Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
-	*/
-	getRoutes(pattern) {
-		if (pattern) if (pattern.endsWith("*")) {
-			const basePattern = pattern.slice(0, -1);
-			return this.routes.filter((route) => route.path.startsWith(basePattern));
-		} else return this.routes.filter((route) => route.path === pattern);
-		return this.routes;
-	}
-	createRoute(route) {
-		route.method ??= "GET";
-		route.method = route.method.toUpperCase();
-		this.routes.push(route);
-		const path = `/${route.method}/${route.path}`.replace(/\/+/g, "/");
-		const responseKind = this.getResponseType(route.schema);
-		this.log.trace(`Create route ${path}`);
-		this.push({
-			path,
-			handler: (rawRequest) => {
-				const request = this.serverRequestParser.createServerRequest(rawRequest);
-				return this.alepha.context.run(() => this.processRequest(request, route, responseKind), { context: this.getContextId(rawRequest.headers) });
-			}
-		});
-	}
-	getContextId(headers) {
-		const contextId = headers["x-request-id"] || headers["x-correlation-id"];
-		if ((0, alepha.isUUID)(contextId)) return contextId;
-		return crypto.randomUUID();
-	}
-	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", {
-			request,
-			route
-		}, { catch: true });
-		const response = {
-			status: request.reply.status ?? (request.reply.body ? 200 : 204),
-			headers: request.reply.headers,
-			body: request.reply.body
-		};
-		await this.alepha.events.emit("server:onResponse", {
-			request,
-			route,
-			response
-		}, { catch: true });
-		return response;
-	}
-	async runRouteHandler(route, request, responseKind) {
-		await this.alepha.events.emit("server:onRequest", {
-			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");
-		try {
-			this.validateRequest(route, request);
-		} finally {
-			this.serverTimingProvider.endTiming("validateRequest");
-		}
-		this.serverTimingProvider.beginTiming("runHandler");
-		try {
-			const result = await route.handler(request);
-			if (result) request.reply.body = result;
-		} finally {
-			this.serverTimingProvider.endTiming("runHandler");
-		}
-		this.serverTimingProvider.beginTiming("serializeResponse");
-		try {
-			this.serializeResponse(route, request.reply, responseKind);
-		} finally {
-			this.serverTimingProvider.endTiming("serializeResponse");
-		}
-	}
-	serializeResponse(route, reply, responseKind) {
-		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" });
-			return;
-		}
-		if (responseKind === "file") {
-			if (!(0, alepha.isFileLike)(reply.body)) throw new HttpError({
-				status: 500,
-				message: "Invalid response body - not a file"
-			});
-			reply.headers["content-type"] = reply.body.type;
-			reply.headers["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";
-			return;
-		}
-		if (reply.body == null || responseKind === "void") {
-			delete reply.headers["content-type"];
-			reply.body = void 0;
-			return;
-		}
-		if (Buffer.isBuffer(reply.body)) {
-			reply.headers["content-type"] ??= "application/octet-stream";
-			return;
-		}
-		if (reply.body instanceof node_stream_web.ReadableStream || reply.body instanceof node_stream.Readable) {
-			reply.headers["content-type"] ??= "application/octet-stream";
-			return;
-		}
-		reply.headers["content-type"] ??= "text/plain";
-		reply.body = String(reply.body);
-	}
-	getResponseType(schema) {
-		if (schema?.response) {
-			if (alepha.t.schema.isObject(schema.response) || alepha.t.schema.isRecord(schema.response) || alepha.t.schema.isArray(schema.response)) return "json";
-			if (alepha.t.schema.isString(schema.response) || alepha.t.schema.isInteger(schema.response) || alepha.t.schema.isNumber(schema.response) || alepha.t.schema.isBoolean(schema.response)) return "text";
-			if ((0, alepha.isTypeFile)(schema.response)) return "file";
-			if (alepha.t.schema.isVoid(schema.response)) return "void";
-		}
-		return "any";
-	}
-	async errorHandler(route, request, error) {
-		request.reply.body = null;
-		await this.alepha.events.emit("server:onError", {
-			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
-			});
-		} 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],
-					message: error.message,
-					requestId: request.requestId
-				});
-				return;
-			}
-			request.reply.status = 500;
-			request.reply.headers["content-type"] = "application/json";
-			request.reply.body = JSON.stringify({
-				status: 500,
-				error: "InternalServerError",
-				message: error.message,
-				requestId: request.requestId
-			});
-		}
-	}
-	validateRequest(route, request) {
-		if (route.schema?.params) try {
-			request.params = this.alepha.codec.validate(route.schema.params, request.params);
-		} catch (error) {
-			throw new ValidationError("Invalid request params", error);
-		}
-		if (route.schema?.query) try {
-			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]);
-			request.query = query;
-		} catch (error) {
-			throw new ValidationError("Invalid request query", error);
-		}
-		if (route.schema?.headers) try {
-			request.headers = this.alepha.codec.validate(route.schema.headers, request.headers);
-		} catch (error) {
-			throw new ValidationError("Invalid request header", error);
-		}
-		if (route.schema?.body) try {
-			request.body = this.alepha.codec.decode(route.schema.body, request.body);
-		} catch (error) {
-			throw new ValidationError("Invalid request body", error);
-		}
-	}
-};
-
-//#endregion
-//#region src/server/providers/ServerProvider.ts
-/**
-* Base server provider to handle incoming requests and route them.
-*
-* This is the default implementation for serverless environments.
-*
-* ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
-*/
-var ServerProvider = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	router = (0, alepha.$inject)(ServerRouterProvider);
-	internalServerErrorMessage = "Internal Server Error";
-	get hostname() {
-		return "";
-	}
-	/**
-	* When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-	*/
-	onNodeRequest = (0, alepha.$hook)({
-		on: "node:request",
-		handler: (ev) => this.handleNodeRequest(ev)
-	});
-	/**
-	* When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
-	*/
-	onWebRequest = (0, alepha.$hook)({
-		on: "web:request",
-		handler: (ev) => {
-			return this.handleWebRequest(ev);
-		}
-	});
-	/**
-	* Handle Node.js HTTP request event.
-	*
-	* Technically, we just convert Node.js request to Web Standard Request.
-	*/
-	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;
-		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 request = {
-			method: req.method?.toUpperCase() ?? "GET",
-			url,
-			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
-			};
-		});
-		if (!response.body) {
-			res.writeHead(response.status, response.headers).end();
-			return;
-		}
-		if (typeof response.body === "string" || Buffer.isBuffer(response.body)) {
-			res.writeHead(response.status, response.headers).end(response.body);
-			return;
-		}
-		if (response.body instanceof node_stream.Readable) {
-			res.writeHead(response.status, response.headers);
-			response.body.pipe(res);
-			return;
-		}
-		if (response.body instanceof ReadableStream) {
-			res.writeHead(response.status, response.headers);
-			try {
-				for await (const chunk of response.body) res.write(chunk);
-			} catch (error) {
-				this.log.error("Error piping proxy response stream", error);
-			} finally {
-				res.end();
-			}
-			return;
-		}
-		this.log.error("Unknown response body type:", typeof response.body);
-		res.writeHead(500, { "content-type": "text/plain" });
-		res.end(this.internalServerErrorMessage);
-	}
-	/**
-	* Handle Web (Fetch API) request event.
-	*/
-	async handleWebRequest(ev) {
-		const req = ev.req;
-		const url = new URL(req.url);
-		const { route, params } = this.router.match(`/${req.method}${url.pathname}`);
-		if (this.isViteNotFound(req.url, route, params)) return;
-		if (!route) {
-			ev.res = new Response("Not Found", {
-				status: 404,
-				headers: { "content-type": "text/plain" }
-			});
-			return;
-		}
-		const headers = {};
-		req.headers.forEach((value, key) => {
-			headers[key] = value;
-		});
-		const query = Object.fromEntries(url.searchParams.entries());
-		const request = {
-			method: req.method.toUpperCase() ?? "GET",
-			url,
-			headers,
-			params: params || {},
-			query,
-			raw: { web: ev }
-		};
-		const response = await route.handler(request).catch(() => {
-			return {
-				status: 500,
-				headers: { "content-type": "text/plain" },
-				body: this.internalServerErrorMessage
-			};
-		});
-		if (!response.body) {
-			ev.res = new Response(null, {
-				status: response.status,
-				headers: response.headers
-			});
-			return;
-		}
-		if (typeof response.body === "string") {
-			ev.res = new Response(response.body, {
-				status: response.status,
-				headers: response.headers
-			});
-			return;
-		}
-		if (Buffer.isBuffer(response.body)) {
-			ev.res = new Response(response.body.buffer, {
-				status: response.status,
-				headers: response.headers
-			});
-			return;
-		}
-		if (response.body instanceof node_stream.Readable) {
-			ev.res = new Response(node_stream.Readable.toWeb(response.body), {
-				status: response.status,
-				headers: response.headers
-			});
-			return;
-		}
-		if (response.body instanceof ReadableStream) {
-			ev.res = new Response(response.body, {
-				status: response.status,
-				headers: response.headers
-			});
-			return;
-		}
-		this.log.error(`Unknown response body type: ${typeof response.body}`);
-		ev.res = new Response(this.internalServerErrorMessage, {
-			status: 500,
-			headers: { "content-type": "text/plain" }
-		});
-	}
-	/**
-	* Helper for Vite development mode to let Vite handle (or not) 404.
-	*/
-	isViteNotFound(url, route, params) {
-		if (this.alepha.isViteDev()) {
-			if (!route) return true;
-			url = url?.split("?")[0];
-			if (!!params?.["*"] && `/${params?.["*"]}` === url) return true;
-		}
-		return false;
-	}
-};
-
-//#endregion
-//#region src/server/schemas/errorSchema.ts
-const errorSchema = alepha.t.object({
-	error: alepha.t.text({ description: "HTTP error name" }),
-	status: alepha.t.integer({ description: "HTTP status code" }),
-	message: alepha.t.text({
-		description: "Short text which describe the error",
-		size: "rich"
-	}),
-	details: alepha.t.optional(alepha.t.text({
-		description: "Detailed description of the error",
-		size: "rich"
-	})),
-	requestId: alepha.t.optional(alepha.t.text()),
-	cause: alepha.t.optional(alepha.t.object({
-		name: alepha.t.text(),
-		message: alepha.t.text({
-			description: "Cause Error message",
-			size: "rich"
-		})
-	}))
-}, {
-	title: "HttpError",
-	description: "Generic response after a failed operation"
-});
-
-//#endregion
-//#region src/server/services/HttpClient.ts
-var HttpClient = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	cache = (0, alepha_cache.$cache)();
-	pendingRequests = {};
-	async fetchAction(args) {
-		const route = args.action;
-		const options = args.options ?? {};
-		const config = args.config ?? {};
-		const host = args.host ?? "";
-		const request = { ...options.request };
-		const method = route.method;
-		const headers = {};
-		const url = this.url(host, route, config);
-		await this.alepha.events.emit("client:onRequest", {
-			route,
-			config,
-			options,
-			headers,
-			request
-		});
-		request.method ??= method;
-		await this.body(request, headers, route, config);
-		request.headers = {
-			...config.headers,
-			...Object.fromEntries(new Headers(request.headers).entries()),
-			...headers
-		};
-		return await this.fetch(url, {
-			...request,
-			schema: route.schema,
-			...options
-		});
-	}
-	async fetch(url, request = {}) {
-		const options = {
-			cache: request.localCache,
-			schema: request.schema?.response,
-			key: request.key
-		};
-		request.method ??= "GET";
-		this.log.trace("Request", {
-			url,
-			method: request.method,
-			body: request.body,
-			headers: request.headers,
-			options
-		});
-		const cached = await this.cache.get(url);
-		if (cached && request.method === "GET") if (cached.etag) {
-			request.headers = new Headers(request.headers);
-			if (!request.headers.has("if-none-match")) request.headers.set("if-none-match", cached.etag);
-		} else return {
-			data: cached.data,
-			status: 200,
-			statusText: "OK",
-			headers: new Headers()
-		};
-		await this.alepha.events.emit("client:beforeFetch", {
-			url,
-			options,
-			request
-		});
-		const key = options.key ?? JSON.stringify({
-			url,
-			method: request.method,
-			body: request.body
-		});
-		const existing = this.pendingRequests[key];
-		if (existing) {
-			this.log.info("Request already pending", key);
-			return existing;
-		}
-		this.pendingRequests[key] = fetch(url, request).then(async (response) => {
-			this.log.debug("Response", {
-				url,
-				status: response.status
-			});
-			const fetchResponse = {
-				data: await this.responseData(response, options),
-				status: response.status,
-				statusText: response.statusText,
-				headers: response.headers,
-				raw: response
-			};
-			if (request.method === "GET") {
-				if (options.cache) await this.cache.set(url, { data: fetchResponse.data }, typeof options.cache === "boolean" ? void 0 : options.cache);
-				else if (!this.alepha.isBrowser()) {
-					const etag = response.headers.get("etag") ?? void 0;
-					if (etag) await this.cache.set(url, {
-						data: fetchResponse.data,
-						etag
-					});
-				}
-			}
-			return fetchResponse;
-		}).finally(() => {
-			delete this.pendingRequests[key];
-		});
-		return this.pendingRequests[key];
-	}
-	url(host, action, args) {
-		let url = host;
-		if (action.prefix) url += action.prefix;
-		url += action.path;
-		url = this.pathVariables(url, action, args);
-		url = this.queryParams(url, action, args);
-		return url;
-	}
-	async body(init, headers, action, args = {}) {
-		if (typeof init.headers === "object" && "content-type" in init.headers && init.headers["content-type"] === "multipart/form-data" || isMultipart(action)) {
-			if (typeof init.headers === "object" && "content-type" in init.headers) delete init.headers["content-type"];
-			const formData = new FormData();
-			for (const [key, value] of Object.entries(args.body ?? {})) {
-				if (typeof value === "string") {
-					formData.append(key, value);
-					continue;
-				}
-				if (value instanceof Blob) {
-					formData.append(key, value);
-					continue;
-				}
-				if ((0, alepha.isFileLike)(value)) formData.append(key, new File([await value.arrayBuffer()], value.name, { type: value.type }));
-			}
-			init.body = formData;
-			return;
-		}
-		if (!init.body && action.schema?.body) {
-			headers["content-type"] = "application/json";
-			init.body = this.alepha.codec.encode(action.schema?.body, args.body, { as: "string" });
-		}
-	}
-	async responseData(response, options) {
-		if (response.status === 304) {
-			let cacheKey = response.url;
-			if (typeof window !== "undefined") cacheKey = cacheKey.replace(window.location.origin, "");
-			const cached = await this.cache.get(cacheKey);
-			if (cached) return cached.data;
-			return "";
-		}
-		if (response.status === 204) return;
-		if (this.isMaybeFile(response)) return this.createFileLike(response);
-		if (response.headers.get("Content-Type")?.startsWith("text/")) return await response.text();
-		if (response.headers.get("Content-Type") === "application/json") {
-			const json = await response.json();
-			if (response.status >= 400) {
-				const error = new HttpError(this.alepha.codec.decode(errorSchema, json));
-				await this.alepha.events.emit("client:onError", { error });
-				throw error;
-			}
-			if (options.schema) return this.alepha.codec.decode(options.schema, json);
-			return json;
-		}
-		if (response.status >= 400) {
-			const error = new HttpError({
-				status: response.status,
-				message: `An error occurred while fetching the resource. (${response.statusText})`
-			});
-			await this.alepha.events.emit("client:onError", { error });
-			throw error;
-		}
-		return response;
-	}
-	isMaybeFile(response) {
-		const contentType = response.headers.get("Content-Type");
-		if (!contentType) return false;
-		if (response.headers.get("Content-Disposition")?.includes("attachment")) return true;
-		return contentType.startsWith("application/octet-stream") || contentType.startsWith("application/pdf") || contentType.startsWith("application/zip") || contentType.startsWith("image/") || contentType.startsWith("video/") || contentType.startsWith("audio/");
-	}
-	createFileLike(response, defaultFileName = "") {
-		const match = (response.headers.get("Content-Disposition") ?? "").match(/filename="(.+)"/);
-		return {
-			name: match?.[1] ? match[1] : defaultFileName,
-			type: response.headers.get("Content-Type") ?? "application/octet-stream",
-			size: Number(response.headers.get("Content-Length") ?? 0),
-			lastModified: Date.now(),
-			stream: () => {
-				throw new Error("Not implemented");
-			},
-			arrayBuffer: async () => {
-				return await response.arrayBuffer();
-			},
-			text: async () => {
-				return await response.text();
-			}
-		};
-	}
-	pathVariables(url, action, args = {}) {
-		if (typeof args.params === "object") {
-			const params = action.schema?.params ? this.alepha.codec.decode(action.schema.params, args.params) : args.params;
-			for (const key of Object.keys(params)) {
-				url = url.replace(`:${key}`, params[key]);
-				url = url.replace(`{${key}}`, params[key]);
-			}
-		}
-		return url;
-	}
-	queryParams(url, action, args = {}) {
-		if (typeof args.query === "object") {
-			const query = action.schema?.query ? this.alepha.codec.decode(action.schema.query, args.query ?? {}) : args.query;
-			for (const key of Object.keys(query)) {
-				if (query[key] === void 0) delete query[key];
-				if (typeof query[key] === "object") query[key] = JSON.stringify(query[key]);
-			}
-			return `${url}?${new URLSearchParams(query).toString()}`;
-		}
-		return url;
-	}
-};
-
-//#endregion
-//#region src/server/descriptors/$action.ts
-/**
-* Creates a server action descriptor for defining type-safe HTTP endpoints.
-*
-* Server actions are the core building blocks for REST APIs in Alepha, providing declarative
-* HTTP endpoints with full type safety, automatic validation, and OpenAPI documentation.
-*
-* **Key Features**
-* - Full TypeScript inference for request/response types
-* - Automatic schema validation using TypeBox
-* - Convention-based URL generation with customizable paths
-* - Direct invocation (`run()`) or HTTP requests (`fetch()`)
-* - Built-in authentication and authorization support
-* - Automatic content-type handling (JSON, form-data, plain text)
-*
-* **URL Generation**
-* Actions are prefixed with `/api` by default (configurable via `SERVER_API_PREFIX`).
-* HTTP method defaults to GET, or POST if body schema is provided.
-*
-* **Common Use Cases**
-* - CRUD operations with type safety
-* - File upload and download endpoints
-* - Microservice communication
-*
-* @example
-* ```ts
-* class UserController {
-*   getUsers = $action({
-*     path: "/users",
-*     schema: {
-*       query: t.object({
-*         page: t.optional(t.number({ default: 1 })),
-*         limit: t.optional(t.number({ default: 10 }))
-*       }),
-*       response: t.object({
-*         users: t.array(t.object({
-*           id: t.text(),
-*           name: t.text(),
-*           email: t.text()
-*         })),
-*         total: t.number()
-*       })
-*     },
-*     handler: async ({ query }) => {
-*       const users = await this.userService.findUsers(query);
-*       return { users: users.items, total: users.total };
-*     }
-*   });
-*
-*   createUser = $action({
-*     method: "POST",
-*     path: "/users",
-*     schema: {
-*       body: t.object({
-*         name: t.text(),
-*         email: t.text({ format: "email" })
-*       }),
-*       response: t.object({ id: t.text(), name: t.text() })
-*     },
-*     handler: async ({ body }) => {
-*       return await this.userService.create(body);
-*     }
-*   });
-* }
-* ```
-*/
-const $action = (options) => {
-	const instance = (0, alepha.createDescriptor)(ActionDescriptor, options);
-	const fn = (config, options$1) => {
-		return instance.run(config, options$1);
-	};
-	Object.defineProperty(fn, "name", { get() {
-		return instance.options.name || instance.config.propertyKey;
-	} });
-	return Object.setPrototypeOf(fn, instance);
-};
-const envSchema$3 = alepha.t.object({ SERVER_API_PREFIX: alepha.t.text({
-	description: "Prefix for all API routes (e.g. $action).",
-	default: "/api"
-}) });
-var ActionDescriptor = class extends alepha.Descriptor {
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema$3);
-	httpClient = (0, alepha.$inject)(HttpClient);
-	serverProvider = (0, alepha.$inject)(ServerProvider);
-	serverRouterProvider = (0, alepha.$inject)(ServerRouterProvider);
-	onInit() {
-		if (this.options.disabled) {
-			this.log.debug(`Action '${this.name}' is disabled. It won't be available in the API.`);
-			return;
-		}
-		this.serverRouterProvider.createRoute(this.route);
-	}
-	get prefix() {
-		return this.env.SERVER_API_PREFIX;
-	}
-	get route() {
-		return {
-			...this.options,
-			method: this.method,
-			path: `${this.prefix}${this.path}`
-		};
-	}
-	/**
-	* Returns the name of the action.
-	*/
-	get name() {
-		return this.options.name || this.config.propertyKey;
-	}
-	/**
-	* Returns the group of the action. (e.g. "orders", "admin", etc.)
-	*/
-	get group() {
-		return this.options.group || this.config.service.name;
-	}
-	/**
-	* Returns the HTTP method of the action.
-	*/
-	get method() {
-		return this.options.method || (this.options.schema?.body ? "POST" : "GET");
-	}
-	/**
-	* Returns the path of the action.
-	*
-	* Path is prefixed by `/api` by default.
-	*/
-	get path() {
-		if (this.options.path) return this.options.path;
-		let path = `/${this.name}`;
-		if (this.options.schema?.params) for (const [key] of Object.entries(this.options.schema.params.properties)) path += `/:${key}`;
-		return path;
-	}
-	get schema() {
-		return this.options.schema;
-	}
-	getBodyContentType() {
-		if (this.options.schema?.body) {
-			if (isMultipart(this.options)) return "multipart/form-data";
-			if (alepha.t.schema.isString(this.options.schema.body)) return "text/plain";
-			if (alepha.t.schema.isObject(this.options.schema.body) || alepha.t.schema.isArray(this.options.schema.body) || alepha.t.schema.isRecord(this.options.schema.body)) return "application/json";
-		}
-	}
-	/**
-	* Call the action handler directly.
-	* There is no HTTP layer involved.
-	*/
-	async run(config, options = {}) {
-		const handler = this.options.handler;
-		const { body, params = {}, query = {}, headers = {} } = config ?? {};
-		const reply = new ServerReply();
-		const serverActionRequest = {
-			method: this.method,
-			url: new URL(`http://localhost${this.path ?? ""}`),
-			body,
-			params,
-			query,
-			headers,
-			reply,
-			metadata: {}
-		};
-		await this.alepha.events.emit("action:onRequest", {
-			action: this,
-			request: serverActionRequest,
-			options
-		});
-		if (serverActionRequest.reply?.body) return serverActionRequest.reply.body;
-		if (serverActionRequest.query && this.options.schema?.query) serverActionRequest.query = this.alepha.codec.encode(this.options.schema.query, serverActionRequest.query);
-		if (serverActionRequest.headers && this.options.schema?.headers) serverActionRequest.headers = this.alepha.codec.encode(this.options.schema.headers, serverActionRequest.headers);
-		if (serverActionRequest.body && this.options.schema?.body) serverActionRequest.body = this.alepha.codec.encode(this.options.schema.body, serverActionRequest.body);
-		if (serverActionRequest.params && this.options.schema?.params) serverActionRequest.params = this.alepha.codec.encode(this.options.schema.params, serverActionRequest.params);
-		this.serverRouterProvider.validateRequest(this.options, serverActionRequest);
-		let response = await handler(serverActionRequest);
-		if (this.options.schema?.response && !(0, alepha.isTypeFile)(this.options.schema.response)) response = this.alepha.codec.validate(this.options.schema.response, response);
-		await this.alepha.events.emit("action:onResponse", {
-			action: this,
-			request: serverActionRequest,
-			options,
-			response
-		});
-		return response;
-	}
-	/**
-	* Works like `run`, but always fetches (http request) the route.
-	*/
-	fetch(config, options) {
-		return this.httpClient.fetchAction({
-			host: this.serverProvider.hostname,
-			action: this,
-			config,
-			options
-		});
-	}
-};
-$action[alepha.KIND] = ActionDescriptor;
-
-//#endregion
-//#region src/server/descriptors/$route.ts
-/**
-* Create a basic endpoint.
-*
-* It's a low level descriptor. You probably want to use `$action` instead.
-*
-* @see {@link $action}
-* @see {@link $page}
-*/
-const $route = (options) => {
-	return (0, alepha.createDescriptor)(RouteDescriptor, options);
-};
-var RouteDescriptor = class extends alepha.Descriptor {
-	serverRouterProvider = (0, alepha.$inject)(ServerRouterProvider);
-	onInit() {
-		this.serverRouterProvider.createRoute(this.options);
-	}
-};
-$route[alepha.KIND] = RouteDescriptor;
-
-//#endregion
-//#region src/server/providers/BunHttpServerProvider.ts
-const envSchema$2 = alepha.t.object({
-	SERVER_PORT: alepha.t.integer({
-		default: 3e3,
-		min: 0,
-		max: 65535,
-		description: "Set 0 to listen on a random port."
-	}),
-	SERVER_HOST: alepha.t.text({
-		default: "localhost",
-		description: "Set 0.0.0.0 to listen on all interfaces."
-	})
-});
-var BunHttpServerProvider = class extends ServerProvider {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema$2);
-	router = (0, alepha.$inject)(ServerRouterProvider);
-	bunServer;
-	get hostname() {
-		if (this.bunServer) return `http://${this.bunServer.hostname}:${this.bunServer.port}`;
-		return `http://${this.env.SERVER_HOST}:${this.env.SERVER_PORT}`;
-	}
-	start = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			await this.listen();
-		}
-	});
-	stop = (0, alepha.$hook)({
-		on: "stop",
-		handler: async () => {
-			if (this.alepha.isProduction()) {
-				await this.close();
-				return;
-			}
-			this.close().catch(() => {});
-		}
-	});
-	async listen() {
-		let port = this.env.SERVER_PORT;
-		if (this.alepha.isTest() && port === 3e3) port = 0;
-		try {
-			this.bunServer = Bun.serve({
-				port,
-				hostname: this.env.SERVER_HOST,
-				fetch: async (request) => {
-					this.log.trace(`Incoming Bun request -> ${request.url}`);
-					const webRequestEvent = {
-						req: request,
-						res: void 0
-					};
-					try {
-						await this.handleWebRequest(webRequestEvent);
-						if (!webRequestEvent.res) return new Response("Internal Server Error", {
-							status: 500,
-							headers: { "content-type": "text/plain" }
-						});
-						return webRequestEvent.res;
-					} catch (err) {
-						this.log.error("Error handling request", err);
-						return new Response("Internal Server Error", {
-							status: 500,
-							headers: { "content-type": "text/plain" }
-						});
-					}
-				},
-				error: (error) => {
-					this.log.error("Bun server error", error);
-					return new Response("Internal Server Error", {
-						status: 500,
-						headers: { "content-type": "text/plain" }
-					});
-				}
-			});
-			this.log.info(`Server listening on ${this.hostname}`);
-		} catch (err) {
-			this.log.error("Failed to start Bun server", err);
-			throw err;
-		}
-	}
-	async close() {
-		if (!this.bunServer) return;
-		try {
-			const stopPromise = this.bunServer.stop();
-			await Promise.race([this.dateTimeProvider.wait(1e4), stopPromise]);
-			this.bunServer = void 0;
-			this.log.info("Server closed");
-		} catch (err) {
-			this.log.error("Error closing Bun server", err);
-			throw err;
-		}
-	}
-};
-
-//#endregion
-//#region src/server/providers/NodeHttpServerProvider.ts
-const envSchema$1 = alepha.t.object({
-	SERVER_PORT: alepha.t.integer({
-		default: 3e3,
-		min: 0,
-		max: 65535,
-		description: "Set 0 to listen on a random port."
-	}),
-	SERVER_HOST: alepha.t.text({
-		default: "localhost",
-		description: "Set 0.0.0.0 to listen on all interfaces."
-	})
-});
-var NodeHttpServerProvider = class extends ServerProvider {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema$1);
-	router = (0, alepha.$inject)(ServerRouterProvider);
-	get hostname() {
-		if (this.server.listening) {
-			const address = this.server.address();
-			if (typeof address === "object" && address !== null) return `http://${this.env.SERVER_HOST}:${address.port}`;
-		}
-		return `http://${this.env.SERVER_HOST}:${this.env.SERVER_PORT}`;
-	}
-	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");
-		});
-	});
-	start = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			await this.listen();
-			this.alepha.state.set("alepha.node.server", this.server);
-		}
-	});
-	createHttpServer(func) {
-		return (0, node_http.createServer)({ keepAlive: true }, func);
-	}
-	stop = (0, alepha.$hook)({
-		on: "stop",
-		handler: async () => {
-			if (this.alepha.isProduction()) {
-				await this.close();
-				return;
-			}
-			this.close().catch(() => {});
-		}
-	});
-	async listen() {
-		let port = this.env.SERVER_PORT;
-		if (this.alepha.isTest() && port === 3e3) port = 0;
-		await new Promise((resolve, reject) => {
-			this.server?.listen(port, this.env.SERVER_HOST, () => {
-				this.log.info(`Server listening on ${this.hostname}`);
-				resolve();
-			});
-			this.server?.on("error", (err) => {
-				reject(err);
-			});
-		});
-	}
-	async close() {
-		const promise = new Promise((resolve, reject) => {
-			this.server?.close((err) => {
-				if (err) reject(err);
-				else resolve();
-			});
-		});
-		await Promise.race([this.dateTimeProvider.wait(2e3), promise]);
-		this.log.info("Server closed");
-	}
-};
-
-//#endregion
-//#region src/server/providers/ServerBodyParserProvider.ts
-const envSchema = alepha.t.object({
-	SERVER_BODY_PARSER_INFLATE: alepha.t.boolean({
-		default: true,
-		description: "Enable decompression of request body."
-	}),
-	SERVER_BODY_PARSER_LIMIT: alepha.t.integer({
-		default: 1e5,
-		min: 0,
-		description: "Maximum size of request body in bytes."
-	})
-});
-var ServerBodyParserProvider = class {
-	env = (0, alepha.$env)(envSchema);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	log = (0, alepha_logger.$logger)();
-	onRequest = (0, alepha.$hook)({
-		on: "server:onRequest",
-		handler: async ({ 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 = node_stream_web.ReadableStream.from(request.raw.node.req);
-			if (!stream) return;
-			if (route.schema?.body) try {
-				const body = await this.parse(stream, request.headers);
-				if (body) request.body = body;
-			} catch (error) {
-				if (error instanceof HttpError) throw error;
-				throw new HttpError({
-					status: 400,
-					message: "Failed to parse request body"
-				}, error);
-			}
-		}
-	});
-	async parse(stream, headers) {
-		const contentType = headers["content-type"];
-		const contentEncoding = headers["content-encoding"];
-		if (!contentType) return void 0;
-		if (contentType.startsWith("application/json")) return this.parseJson(stream, contentEncoding);
-		if (contentType.startsWith("text/plain")) return this.parseText(stream, contentEncoding);
-		if (contentType.startsWith("application/x-www-form-urlencoded")) return this.parseUrlEncoded(stream, contentEncoding);
-	}
-	async parseText(stream, contentEncoding) {
-		const buffer = await this.streamToBuffer(stream);
-		return (await this.maybeDecompress(buffer, contentEncoding)).toString("utf-8");
-	}
-	async parseUrlEncoded(stream, contentEncoding) {
-		const text = await this.parseText(stream, contentEncoding);
-		const params = new URLSearchParams(text);
-		const result = {};
-		for (const [key, value] of params.entries()) result[key] = value;
-		return result;
-	}
-	async parseJson(stream, contentEncoding) {
-		const text = await this.parseText(stream, contentEncoding);
-		return JSON.parse(text);
-	}
-	async maybeDecompress(buffer, encoding) {
-		if (!this.env.SERVER_BODY_PARSER_INFLATE && encoding) throw new HttpError({
-			status: 415,
-			message: `Content-Encoding ${encoding} not allowed`
-		});
-		switch (encoding) {
-			case "gzip": return new Promise((res, rej) => (0, node_zlib.createGunzip)().end(buffer, () => {}).on("data", res).on("error", rej));
-			case "deflate": return new Promise((res, rej) => (0, node_zlib.createInflate)().end(buffer, () => {}).on("data", res).on("error", rej));
-			case "br": return new Promise((res, rej) => (0, node_zlib.createBrotliDecompress)().end(buffer, () => {}).on("data", res).on("error", rej));
-			case void 0:
-			case "identity": return buffer;
-			default: throw new Error(`Unsupported Content-Encoding: ${encoding}`);
-		}
-	}
-	/**
-	* Convert Web ReadableStream to Buffer, with a size limit.
-	*
-	* TODO: move to alepha/file FileUtils
-	*/
-	async streamToBuffer(stream) {
-		const chunks = [];
-		let totalLength = 0;
-		const reader = stream.getReader();
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				if (value) {
-					totalLength += value.length;
-					if (totalLength > this.env.SERVER_BODY_PARSER_LIMIT) {
-						this.log.error(`Body size limit exceeded: ${totalLength} > ${this.env.SERVER_BODY_PARSER_LIMIT}`);
-						await reader.cancel();
-						throw new HttpError({
-							status: 413,
-							message: `Request body size limit exceeded`
-						});
-					}
-					chunks.push(value);
-				}
-			}
-			const combinedLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-			const combined = new Uint8Array(combinedLength);
-			let offset = 0;
-			for (const chunk of chunks) {
-				combined.set(chunk, offset);
-				offset += chunk.length;
-			}
-			return Buffer.from(combined);
-		} catch (error) {
-			reader.releaseLock();
-			throw error;
-		}
-	}
-};
-
-//#endregion
-//#region src/server/providers/ServerLoggerProvider.ts
-var ServerLoggerProvider = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	onRequest = (0, alepha.$hook)({
-		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);
-			}
-		}
-	});
-	onError = (0, alepha.$hook)({
-		on: "server:onError",
-		priority: "last",
-		handler: ({ error }) => {
-			this.log.error("Request has failed", error);
-		}
-	});
-	onResponse = (0, alepha.$hook)({
-		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
-				});
-			}
-		}
-	});
-};
-
-//#endregion
-//#region src/server/providers/ServerNotReadyProvider.ts
-/**
-* On every request, this provider checks if the server is ready.
-*
-* If the server is not ready, it responds with a 503 status code and a message indicating that the server is not ready yet.
-*
-* The response also includes a `Retry-After` header indicating that the client should retry after 5 seconds.
-*/
-var ServerNotReadyProvider = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	onRequest = (0, alepha.$hook)({
-		on: "server:onRequest",
-		priority: "first",
-		handler: ({ request: { reply } }) => {
-			if (this.alepha.isReady()) return;
-			reply.headers["Retry-After"] = "5";
-			throw new HttpError({
-				status: 503,
-				message: "Server is not ready yet. Please try again later."
-			});
-		}
-	});
-};
-
-//#endregion
-//#region src/server/constants/routeMethods.ts
-const routeMethods = [
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE",
-	"HEAD",
-	"OPTIONS",
-	"CONNECT",
-	"TRACE"
-];
-
-//#endregion
-//#region src/server/errors/BadRequestError.ts
-var BadRequestError = class extends HttpError {
-	constructor(message = "Invalid request body", cause) {
-		super({
-			message,
-			status: 400
-		}, cause);
-	}
-};
-
-//#endregion
-//#region src/server/errors/ConflictError.ts
-var ConflictError = class extends HttpError {
-	constructor(message = "Entity already exists", cause) {
-		super({
-			message,
-			status: 409
-		}, cause);
-	}
-};
-
-//#endregion
-//#region src/server/errors/ForbiddenError.ts
-var ForbiddenError = class extends HttpError {
-	constructor(message = "No permission to access this resource", cause) {
-		super({
-			message,
-			status: 403
-		}, cause);
-	}
-};
-
-//#endregion
-//#region src/server/errors/NotFoundError.ts
-var NotFoundError = class extends HttpError {
-	constructor(message = "Resource not found", cause) {
-		super({
-			message,
-			status: 404
-		}, cause);
-	}
-};
-
-//#endregion
-//#region src/server/errors/UnauthorizedError.ts
-var UnauthorizedError = class extends HttpError {
-	name = "UnauthorizedError";
-	constructor(message = "Not allowed to access this resource", cause) {
-		super({
-			message,
-			status: 401
-		}, cause);
-	}
-};
-
-//#endregion
-//#region src/server/schemas/okSchema.ts
-const okSchema = alepha.t.object({
-	ok: alepha.t.boolean({ description: "True when operation succeed" }),
-	id: alepha.t.optional(alepha.t.union([alepha.t.text(), alepha.t.integer()])),
-	count: alepha.t.optional(alepha.t.number({ description: "Number of resources affected" }))
-}, {
-	title: "Ok",
-	description: "Generic response after a successful operation on a resource"
-});
-
-//#endregion
-//#region src/server/index.ts
-/**
-* Provides high-performance HTTP server capabilities with declarative routing and action descriptors.
-*
-* The server module enables building REST APIs and web applications using `$route` and `$action` descriptors
-* on class properties. It provides automatic request/response handling, schema validation, middleware support,
-* and seamless integration with other Alepha modules for a complete backend solution.
-*
-* @see {@link $route}
-* @see {@link $action}
-* @module alepha.server
-*/
-const AlephaServer = (0, alepha.$module)({
-	name: "alepha.server",
-	descriptors: [$route, $action],
-	services: [
-		ServerProvider,
-		BunHttpServerProvider,
-		NodeHttpServerProvider,
-		ServerBodyParserProvider,
-		ServerLoggerProvider,
-		ServerNotReadyProvider,
-		ServerTimingProvider,
-		HttpClient
-	],
-	register: (alepha$1) => {
-		if (!alepha$1.isServerless() && !alepha$1.isViteDev()) if (alepha$1.isBun()) alepha$1.with({
-			optional: true,
-			provide: ServerProvider,
-			use: BunHttpServerProvider
-		});
-		else alepha$1.with({
-			optional: true,
-			provide: ServerProvider,
-			use: NodeHttpServerProvider
-		});
-		else alepha$1.with(ServerProvider);
-		alepha$1.with(ServerBodyParserProvider);
-		alepha$1.with(ServerLoggerProvider);
-		alepha$1.with(ServerNotReadyProvider);
-		if (!alepha$1.isProduction()) alepha$1.with(ServerTimingProvider);
-	}
-});
-
-//#endregion
-exports.$action = $action;
-exports.$route = $route;
-exports.ActionDescriptor = ActionDescriptor;
-exports.AlephaServer = AlephaServer;
-exports.BadRequestError = BadRequestError;
-exports.BunHttpServerProvider = BunHttpServerProvider;
-exports.ConflictError = ConflictError;
-exports.ForbiddenError = ForbiddenError;
-exports.HttpClient = HttpClient;
-exports.HttpError = HttpError;
-exports.NodeHttpServerProvider = NodeHttpServerProvider;
-exports.NotFoundError = NotFoundError;
-exports.RouteDescriptor = RouteDescriptor;
-exports.ServerLoggerProvider = ServerLoggerProvider;
-exports.ServerNotReadyProvider = ServerNotReadyProvider;
-exports.ServerProvider = ServerProvider;
-exports.ServerReply = ServerReply;
-exports.ServerRouterProvider = ServerRouterProvider;
-exports.ServerTimingProvider = ServerTimingProvider;
-exports.UnauthorizedError = UnauthorizedError;
-exports.ValidationError = ValidationError;
-exports.errorNameByStatus = errorNameByStatus;
-exports.errorSchema = errorSchema;
-exports.isHttpError = isHttpError;
-exports.isMultipart = isMultipart;
-exports.okSchema = okSchema;
-exports.routeMethods = routeMethods;
-//# sourceMappingURL=index.cjs.map