@faasjs/core 8.0.0-beta.10

package/dist/index.cjs

@@ -0,0 +1,1951 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let zod = require("zod");
+zod = __toESM(zod);
+let node_crypto = require("node:crypto");
+let node_url = require("node:url");
+let _faasjs_node_utils = require("@faasjs/node-utils");
+let node_zlib = require("node:zlib");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let mime_types = require("mime-types");
+let node_child_process = require("node:child_process");
+let node_http = require("node:http");
+let node_stream = require("node:stream");
+let node_util = require("node:util");
+let knex = require("knex");
+knex = __toESM(knex);
+
+//#region src/plugins/run_handler/index.ts
+const Name$2 = "handler";
+var RunHandler = class {
+	type = Name$2;
+	name = Name$2;
+	async onInvoke(data, next) {
+		if (data.handler) if (!data.runHandler) {
+			try {
+				data.response = await new Promise((resolve, reject) => {
+					data.callback = (error, result) => {
+						if (error) reject(error);
+						else resolve(result);
+					};
+					Promise.resolve(data.handler?.(data)).then(resolve).catch(reject);
+				});
+			} catch (error) {
+				data.logger.error(error);
+				data.response = error;
+			}
+			data.runHandler = true;
+		} else data.logger.warn("handler has been run");
+		await next();
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+/**
+* Assigns a name to a given function handler, which will be displayed in logs and error messages.
+*
+* @template T - The type of the function handler.
+* @param {string} name - The name to assign to the function handler.
+* @param {T} handler - The function handler to which the name will be assigned.
+* @returns {T} - The original function handler with the assigned name.
+*
+* @example
+* ```ts
+* import { nameFunc } from '@faasjs/core'
+*
+* const handler = nameFunc('myHandler', () => {
+*  return 'Hello World'
+* })
+*
+* console.log(handler.name) // => 'myHandler'
+* ```
+*/
+function nameFunc(name, handler) {
+	Object.defineProperty(handler, "name", { value: name });
+	return handler;
+}
+
+//#endregion
+//#region src/func.ts
+function parseFuncFilenameFromStack(stack) {
+	if (!stack) return;
+	const frame = stack.split("\n").map((line) => line.trim()).find((line) => line.includes(".func.ts"));
+	if (!frame) return;
+	const content = frame.replace(/^at\s+/, "");
+	const match = (content.endsWith(")") && content.includes("(") ? content.slice(content.lastIndexOf("(") + 1, -1) : content).match(/^(.+\.func\.ts):\d+:\d+$/);
+	if (!match) return;
+	const filename = match[1];
+	if (filename.startsWith("file://")) try {
+		return (0, node_url.fileURLToPath)(filename);
+	} catch (_) {
+		return filename;
+	}
+	return filename;
+}
+function normalizeMountData(data, options) {
+	const mountData = data || Object.create(null);
+	const ensureEventAndContext = options.ensureEventAndContext ?? true;
+	if (!mountData.config) mountData.config = options.defaultConfig || Object.create(null);
+	if (ensureEventAndContext) {
+		if (!mountData.context) mountData.context = Object.create(null);
+		if (!mountData.event) mountData.event = Object.create(null);
+	}
+	if (!mountData.logger) mountData.logger = new _faasjs_node_utils.Logger(options.loggerLabel);
+	return mountData;
+}
+var Func = class {
+	plugins;
+	handler;
+	config;
+	mounted = false;
+	filename;
+	cachedFunctions = Object.create(null);
+	/**
+	* Create a cloud function.
+	*/
+	constructor(config) {
+		if (config.handler) this.handler = config.handler;
+		this.plugins = config.plugins || [];
+		this.plugins.push(new RunHandler());
+		this.config = { plugins: Object.create(null) };
+		try {
+			const filename = parseFuncFilenameFromStack((/* @__PURE__ */ new Error()).stack);
+			if (filename) this.filename = filename;
+		} catch (_) {}
+	}
+	getCachedFunctions(key) {
+		const cached = this.cachedFunctions[key];
+		if (cached) return cached;
+		const list = [];
+		for (const plugin of this.plugins) {
+			const handler = plugin[key];
+			if (typeof handler !== "function") continue;
+			list.push({
+				key: plugin.name,
+				handler: handler.bind(plugin)
+			});
+		}
+		this.cachedFunctions[key] = list;
+		return list;
+	}
+	compose(key) {
+		const list = this.getCachedFunctions(key);
+		return async (data, next) => {
+			let index = -1;
+			if (!data.logger) data.logger = new _faasjs_node_utils.Logger();
+			const dispatch = async (i) => {
+				if (i <= index) return Promise.reject(Error("next() called multiple times"));
+				index = i;
+				let fn = list[i];
+				if (i === list.length) fn = next;
+				if (!fn) return Promise.resolve();
+				if (typeof fn.key === "undefined") fn.key = `uname#${i}`;
+				if (!data.context) data.context = Object.create(null);
+				if (!data.context.request_at) data.context.request_at = (0, node_crypto.randomBytes)(16).toString("hex");
+				const label = `${data.context.request_id}] [${fn.key}] [${key}`;
+				data.logger.label = label;
+				data.logger.debug("begin");
+				data.logger.time(label);
+				try {
+					const res = await Promise.resolve(fn.handler(data, dispatch.bind(null, i + 1)));
+					data.logger.label = label;
+					data.logger.timeEnd(label, "end");
+					return res;
+				} catch (err) {
+					data.logger.label = label;
+					data.logger.timeEnd(label, "failed");
+					data.logger.error(err);
+					return Promise.reject(err);
+				}
+			};
+			return await dispatch(0);
+		};
+	}
+	/**
+	* First time mount the function.
+	*/
+	async mount(data = {
+		event: Object.create(null),
+		context: Object.create(null)
+	}) {
+		const mountData = normalizeMountData(data, {
+			loggerLabel: "Func",
+			defaultConfig: this.config,
+			ensureEventAndContext: false
+		});
+		if (this.mounted) {
+			mountData.logger.warn("mount() has been called, skipped.");
+			return;
+		}
+		mountData.logger.debug(`plugins: ${this.plugins.map((p) => `${p.type}#${p.name}`).join(",")}`);
+		await this.compose("onMount")(mountData);
+		this.mounted = true;
+	}
+	/**
+	* Invoke the function.
+	*/
+	async invoke(data) {
+		if (!this.mounted) await this.mount(data);
+		try {
+			await this.compose("onInvoke")(data);
+		} catch (error) {
+			data.logger.error(error);
+			data.response = error;
+		}
+	}
+	/**
+	* Export the function.
+	*/
+	export() {
+		const handler = async (event, context, callback) => {
+			if (typeof context === "undefined") context = {};
+			if (!context.request_id) context.request_id = event?.headers?.["x-faasjs-request-id"] || (0, node_crypto.randomBytes)(16).toString("hex");
+			if (!context.request_at) context.request_at = (0, node_crypto.randomBytes)(16).toString("hex");
+			context.callbackWaitsForEmptyEventLoop = false;
+			const logger = new _faasjs_node_utils.Logger(context.request_id);
+			const data = {
+				event: event ?? Object.create(null),
+				context,
+				callback,
+				response: void 0,
+				logger,
+				config: this.config,
+				...this.handler ? { handler: this.handler } : {}
+			};
+			await this.invoke(data);
+			if (Object.prototype.toString.call(data.response) === "[object Error]") throw data.response;
+			return data.response;
+		};
+		return { handler: handler.bind(this) };
+	}
+};
+let plugins = [];
+function usePlugin(plugin) {
+	if (!plugins.find((p) => p.name === plugin.name)) plugins.push(plugin);
+	if (!plugin.mount) plugin.mount = async (data) => {
+		const mountData = normalizeMountData(data, { loggerLabel: plugin.name });
+		if (plugin.onMount) await plugin.onMount(mountData, async () => Promise.resolve());
+		return plugin;
+	};
+	return plugin;
+}
+/**
+* Create a cloud function.
+*/
+function useFunc(handler) {
+	plugins = [];
+	const invokeHandler = handler();
+	const func = new Func({
+		plugins,
+		handler: invokeHandler
+	});
+	plugins = [];
+	return func;
+}
+
+//#endregion
+//#region src/http/session.ts
+var Session = class {
+	content;
+	config;
+	secret;
+	signedSecret;
+	cookie;
+	changed;
+	constructor(cookie, config) {
+		this.cookie = cookie;
+		if (!config?.secret) cookie.logger?.warn("Session's secret is missing.");
+		this.config = Object.assign({
+			key: "key",
+			secret: (0, node_crypto.randomBytes)(128).toString("hex"),
+			salt: "salt",
+			signedSalt: "signedSalt",
+			keylen: 64,
+			iterations: 100,
+			digest: "sha256",
+			cipherName: "aes-256-cbc"
+		}, config);
+		this.secret = (0, node_crypto.pbkdf2Sync)(this.config.secret, this.config.salt, this.config.iterations, this.config.keylen / 2, this.config.digest);
+		this.signedSecret = (0, node_crypto.pbkdf2Sync)(this.config.secret, this.config.signedSalt, this.config.iterations, this.config.keylen, this.config.digest);
+		this.content = Object.create(null);
+	}
+	invoke(cookie, logger) {
+		try {
+			this.content = cookie ? this.decode(cookie) : Object.create(null);
+		} catch (error) {
+			logger?.error(error);
+			this.content = Object.create(null);
+		}
+		this.changed = false;
+	}
+	encode(text) {
+		if (typeof text !== "string") text = JSON.stringify(text);
+		const iv = (0, node_crypto.randomBytes)(16);
+		const cipher = (0, node_crypto.createCipheriv)(this.config.cipherName, this.secret, iv);
+		const encrypted = Buffer.concat([cipher.update(text), cipher.final()]).toString("base64");
+		const main = Buffer.from([encrypted, iv.toString("base64")].join("--")).toString("base64");
+		const hmac = (0, node_crypto.createHmac)(this.config.digest, this.signedSecret);
+		hmac.update(main);
+		return `${main}--${hmac.digest("hex")}`;
+	}
+	decode(text) {
+		text = decodeURIComponent(text);
+		const signedParts = text.split("--");
+		const hmac = (0, node_crypto.createHmac)(this.config.digest, this.signedSecret);
+		hmac.update(signedParts[0]);
+		const digest = hmac.digest("hex");
+		if (signedParts[1] !== digest) throw Error("Session Not valid");
+		const parts = Buffer.from(signedParts[0], "base64").toString().split("--").map((part) => Buffer.from(part, "base64"));
+		const cipher = (0, node_crypto.createDecipheriv)(this.config.cipherName, this.secret, parts[1]);
+		const decrypt = [Buffer.from(cipher.update(parts[0])).toString("utf8"), cipher.final("utf8")].join("");
+		return JSON.parse(decrypt);
+	}
+	read(key) {
+		return this.content[key];
+	}
+	write(key, value) {
+		if (value === null || typeof value === "undefined") delete this.content[key];
+		else this.content[key] = value;
+		this.changed = true;
+		return this;
+	}
+	update() {
+		if (this.changed) this.cookie.write(this.config.key, this.encode(this.content));
+		return this;
+	}
+};
+
+//#endregion
+//#region src/http/cookie.ts
+var Cookie = class {
+	session;
+	content;
+	config;
+	logger;
+	setCookie;
+	constructor(config, logger) {
+		this.logger = logger;
+		this.config = (0, _faasjs_node_utils.deepMerge)({
+			path: "/",
+			expires: 31536e3,
+			secure: true,
+			httpOnly: true,
+			session: {}
+		}, config);
+		this.session = new Session(this, this.config.session);
+		this.content = Object.create(null);
+		this.setCookie = Object.create(null);
+	}
+	invoke(cookie, logger) {
+		this.content = Object.create(null);
+		if (cookie) for (const x of cookie.split(";")) {
+			const trimX = x.trim();
+			const k = /([^=]+)/.exec(trimX);
+			if (k !== null) this.content[k[0]] = decodeURIComponent(trimX.replace(`${k[0]}=`, "").replace(/;$/, ""));
+		}
+		this.setCookie = Object.create(null);
+		this.session.invoke(this.read(this.session.config.key), logger);
+		return this;
+	}
+	read(key) {
+		return this.content[key];
+	}
+	write(key, value, opts) {
+		const options = Object.assign({}, this.config, opts || {});
+		let cookie;
+		if (value === null || typeof value === "undefined") {
+			cookie = `${key}=;`;
+			cookie += "expires=Thu, 01 Jan 1970 00:00:01 GMT;";
+			delete this.content[key];
+		} else {
+			cookie = `${key}=${encodeURIComponent(value)};`;
+			this.content[key] = value;
+			if (typeof options.expires === "number") cookie += `max-age=${options.expires};`;
+			else if (typeof options.expires === "string") cookie += `expires=${options.expires};`;
+		}
+		cookie += `path=${options.path || "/"};`;
+		if (options.domain) cookie += `domain=${options.domain};`;
+		if (options.secure) cookie += "Secure;";
+		if (options.httpOnly) cookie += "HttpOnly;";
+		if (options.sameSite) cookie += `SameSite=${options.sameSite};`;
+		this.setCookie[key] = cookie;
+		return this;
+	}
+	headers() {
+		if (Object.keys(this.setCookie).length === 0) return {};
+		return { "Set-Cookie": Object.values(this.setCookie) };
+	}
+};
+
+//#endregion
+//#region src/http/index.ts
+const ContentType = {
+	plain: "text/plain",
+	html: "text/html",
+	xml: "application/xml",
+	csv: "text/csv",
+	css: "text/css",
+	javascript: "application/javascript",
+	json: "application/json",
+	jsonp: "application/javascript"
+};
+var HttpError = class HttpError extends Error {
+	statusCode;
+	message;
+	constructor({ statusCode, message }) {
+		super(message);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, HttpError);
+		this.statusCode = statusCode || 500;
+		this.message = message;
+	}
+};
+const Name$1 = "http";
+function createCompressedStream(body, encoding) {
+	const compressStream = encoding === "br" ? (0, node_zlib.createBrotliCompress)() : encoding === "gzip" ? (0, node_zlib.createGzip)() : (0, node_zlib.createDeflate)();
+	return new ReadableStream({ async start(controller) {
+		try {
+			const compressed = await new Promise((resolve, reject) => {
+				const chunks = [];
+				compressStream.on("data", (chunk) => chunks.push(chunk));
+				compressStream.on("end", () => resolve(Buffer.concat(chunks)));
+				compressStream.on("error", reject);
+				compressStream.write(Buffer.from(body));
+				compressStream.end();
+			});
+			const chunkSize = 16 * 1024;
+			for (let i = 0; i < compressed.length; i += chunkSize) controller.enqueue(compressed.subarray(i, i + chunkSize));
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+}
+var Http = class {
+	type = "http";
+	name = Name$1;
+	headers = Object.create(null);
+	body;
+	params = Object.create(null);
+	cookie;
+	session;
+	config;
+	response;
+	constructor(config) {
+		this.name = config?.name || this.type;
+		this.config = config?.config || Object.create(null);
+		this.cookie = new Cookie(this.config.cookie || {});
+		this.session = this.cookie.session;
+		this.response = { headers: Object.create(null) };
+	}
+	async onMount(data, next) {
+		data.logger.debug("merge config");
+		const prefix = `SECRET_${this.name.toUpperCase()}_`;
+		for (let key in process.env) if (key.startsWith(prefix)) {
+			const value = process.env[key];
+			key = key.replace(prefix, "").toLowerCase();
+			if (key.includes("_")) {
+				let config = this.config;
+				const keys = key.split("_");
+				for (const k of keys.slice(0, keys.length - 1)) {
+					if (!config[k]) config[k] = Object.create(null);
+					config = config[k];
+				}
+				config[keys[keys.length - 1]] = value;
+			} else this.config[key] = value;
+		}
+		if (!data.config) throw Error(`[${this.name}] Config not found.`);
+		if (data.config.plugins?.[this.name || this.type]) this.config = (0, _faasjs_node_utils.deepMerge)(this.config, data.config.plugins[this.name || this.type].config);
+		data.logger.debug("prepare cookie & session");
+		this.cookie = new Cookie(this.config.cookie || {}, data.logger);
+		this.session = this.cookie.session;
+		await next();
+	}
+	async onInvoke(data, next) {
+		this.headers = data.event.headers || Object.create(null);
+		this.body = data.event.body;
+		this.params = data.event.queryString || Object.create(null);
+		this.response = { headers: Object.create(null) };
+		this.parseEventParams(data);
+		data.params = data.event.params;
+		this.cookie.invoke(this.headers.cookie, data.logger);
+		if (this.headers.cookie) {
+			data.logger.debug("Cookie: %j", this.cookie.content);
+			data.logger.debug("Session: %s %j", this.session.config.key, this.session.content);
+		}
+		data.cookie = this.cookie;
+		data.session = this.session;
+		try {
+			await next();
+		} catch (error) {
+			data.response = error;
+		}
+		this.session.update();
+		this.buildResponse(data);
+		this.finalizeBody(data);
+	}
+	parseEventParams(data) {
+		if (!data.event.body) return;
+		if (this.headers["content-type"]?.includes("application/json") && typeof data.event.body === "string" && data.event.body.length > 1) {
+			data.logger.debug("Parse params from json body");
+			try {
+				this.params = Object.keys(this.params).length ? Object.assign(this.params, JSON.parse(data.event.body)) : JSON.parse(data.event.body);
+			} catch (error) {
+				data.logger.error("Parse params from json body failed: %s", error.message);
+			}
+		} else {
+			data.logger.debug("Parse params from raw body");
+			this.params = data.event.body || Object.create(null);
+		}
+		if (this.params && typeof this.params === "object" && this.params._) delete this.params._;
+		if (this.params && typeof this.params === "object") try {
+			data.event.params = structuredClone(this.params);
+		} catch {
+			data.event.params = this.params;
+		}
+		else data.event.params = this.params;
+		data.logger.debug("Params: %j", this.params);
+	}
+	buildResponse(data) {
+		if (this.response.body && !data.response) data.response = this.response.body;
+		if (data.response) if (data.response instanceof Error || data.response.constructor?.name === "Error") {
+			data.logger.error(data.response);
+			this.response.body = JSON.stringify({ error: { message: data.response.message } });
+			try {
+				this.response.statusCode = data.response.statusCode || 500;
+			} catch (error) {
+				data.logger.error(error);
+				this.response.statusCode = 500;
+			}
+		} else if (Object.prototype.toString.call(data.response) === "[object Object]" && data.response.statusCode && data.response.headers) this.response = data.response;
+		else if (data.response instanceof ReadableStream) this.response.body = data.response;
+		else this.response.body = JSON.stringify({ data: data.response === void 0 ? null : data.response });
+		if (!this.response.statusCode) this.response.statusCode = data.response ? 200 : 204;
+		this.response.headers = Object.assign({
+			"content-type": this.response.body instanceof ReadableStream ? "text/plain; charset=utf-8" : "application/json; charset=utf-8",
+			"cache-control": "no-cache, no-store",
+			"x-faasjs-request-id": data.context.request_id
+		}, this.cookie.headers(), this.response.headers);
+		data.response = Object.assign({}, data.response, this.response);
+	}
+	finalizeBody(data) {
+		const originBody = data.response.body;
+		data.response.originBody = originBody;
+		if (originBody instanceof ReadableStream) {
+			data.response.isBase64Encoded = true;
+			return;
+		}
+		if (originBody === void 0 && data.response.statusCode === 204) return;
+		const normalizedBody = originBody === void 0 ? JSON.stringify({ data: null }) : typeof originBody === "string" ? originBody : JSON.stringify(originBody);
+		if (normalizedBody.length < 1024) {
+			data.response.body = new ReadableStream({ start(controller) {
+				try {
+					controller.enqueue(new TextEncoder().encode(normalizedBody));
+					controller.close();
+				} catch (error) {
+					controller.error(error);
+				}
+			} });
+			return;
+		}
+		data.response.body = normalizedBody;
+		const acceptEncoding = this.headers["accept-encoding"] || this.headers["Accept-Encoding"];
+		if (!acceptEncoding || !/(br|gzip|deflate)/.test(acceptEncoding)) return;
+		const encoding = acceptEncoding.includes("br") ? "br" : acceptEncoding.includes("gzip") ? "gzip" : "deflate";
+		data.response.headers["Content-Encoding"] = encoding;
+		try {
+			data.response.body = createCompressedStream(normalizedBody, encoding);
+		} catch (error) {
+			data.logger.error("Compression failed: %s", error.message);
+			data.response.body = normalizedBody;
+			delete data.response.headers["Content-Encoding"];
+		}
+	}
+	/**
+	* set header
+	* @param key {string} key
+	* @param value {string} value
+	*/
+	setHeader(key, value) {
+		(this.response.headers || (this.response.headers = Object.create(null)))[key.toLowerCase()] = value;
+		return this;
+	}
+	/**
+	* set Content-Type
+	* @param type {string} 类型
+	* @param charset {string} 编码
+	*/
+	setContentType(type, charset = "utf-8") {
+		this.setHeader("Content-Type", `${ContentType[type] || type}; charset=${charset}`);
+		return this;
+	}
+	/**
+	* set status code
+	* @param code {number} 状态码
+	*/
+	setStatusCode(code) {
+		this.response.statusCode = code;
+		return this;
+	}
+	/**
+	* set body
+	* @param body {*} 内容
+	*/
+	setBody(body) {
+		this.response.body = body;
+		return this;
+	}
+};
+function useHttp(config) {
+	return usePlugin(new Http(config));
+}
+
+//#endregion
+//#region src/response-error.ts
+const INTERNAL_SERVER_ERROR_MESSAGE = "Internal Server Error";
+function getErrorStatusCode(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const statusCode = error.statusCode;
+	if (typeof statusCode !== "number" || !Number.isFinite(statusCode)) return void 0;
+	return statusCode;
+}
+function getErrorMessage(error, fallback = INTERNAL_SERVER_ERROR_MESSAGE) {
+	if (error && typeof error === "object") {
+		const message = error.message;
+		if (typeof message === "string" && message.length) return message;
+	}
+	return fallback;
+}
+function respondWithJsonError(res, statusCode, message) {
+	if (res.writableEnded) return;
+	if (res.headersSent) {
+		res.end();
+		return;
+	}
+	res.statusCode = statusCode;
+	res.setHeader("Content-Type", "application/json; charset=utf-8");
+	res.end(JSON.stringify({ error: { message } }));
+}
+function respondWithInternalServerError(res) {
+	if (res.writableEnded) return;
+	if (res.headersSent) {
+		res.end();
+		return;
+	}
+	res.statusCode = 500;
+	res.setHeader("Content-Type", "text/plain; charset=utf-8");
+	res.end(INTERNAL_SERVER_ERROR_MESSAGE);
+}
+
+//#endregion
+//#region src/middleware/middleware.ts
+async function invokeMiddleware(event, logger, handler) {
+	const loggerKey = (0, node_crypto.randomUUID)();
+	const handlerLogger = new _faasjs_node_utils.Logger(`${logger.label}] [middleware] [${handler.name || "uname"}`);
+	handlerLogger.debug("begin");
+	handlerLogger.time(loggerKey, "debug");
+	try {
+		await handler(Object.assign(event.raw.request, { body: event.body }), event.raw.response, { logger: handlerLogger });
+	} catch (error) {
+		handlerLogger.error("error:", error);
+		if (getErrorStatusCode(error) === 500) respondWithJsonError(event.raw.response, 500, getErrorMessage(error));
+		else respondWithInternalServerError(event.raw.response);
+	} finally {
+		handlerLogger.timeEnd(loggerKey, "end");
+	}
+}
+/**
+* Apply a middleware function to handle incoming requests.
+*
+* @param handler - The middleware function to handle the request and response.
+* @returns A function that processes the event and applies the middleware.
+*
+* @example
+* ```typescript
+* import { useMiddleware } from '@faasjs/core'
+*
+* export const func = useMiddleware((request, response, logger) => {
+*   response.setHeader('X-Hello', 'World')
+*   response.end('Hello, World!')
+*   logger.info('Hello, World!')
+* })
+* ```
+*/
+async function useMiddleware(handler) {
+	return useFunc(() => async ({ event, logger }) => {
+		await invokeMiddleware(event, logger, handler);
+		if (!event.raw.response.writableEnded) {
+			event.raw.response.statusCode = 404;
+			event.raw.response.end("Not Found");
+		}
+	});
+}
+/**
+* Apply an array of middleware functions to an event.
+*
+* @param {Middleware[]} handlers - An array of middleware functions to be applied.
+* @returns {Promise<void>} A promise that resolves when all middleware functions have been applied.
+*
+* @example
+* ```typescript
+* import { useMiddlewares } from '@faasjs/core'
+*
+* export const func = useMiddlewares([
+*   (request, response) => {
+*     if (request.url === '/hi') return
+*     response.end('Hello, World!')
+*   },
+*   (request, response) => {
+*     if (request.url === '/hello') return
+*     response.end('Hi, World!')
+*   }
+* ])
+* ```
+*/
+async function useMiddlewares(handlers) {
+	return useFunc(() => async ({ event, logger }) => {
+		for (const handler of handlers) {
+			if (event.raw.response.writableEnded) break;
+			await invokeMiddleware(event, logger, handler);
+		}
+		if (!event.raw.response.writableEnded) {
+			event.raw.response.statusCode = 404;
+			event.raw.response.end("Not Found");
+		}
+	});
+}
+
+//#endregion
+//#region src/request-url.ts
+const BAD_REQUEST_URL_MESSAGE = "Bad Request: url is undefined";
+function ensureRequestUrl(req, res) {
+	if (req.url) return req.url;
+	res.statusCode = 400;
+	res.setHeader("Content-Type", "text/plain; charset=utf-8");
+	res.end(BAD_REQUEST_URL_MESSAGE);
+}
+
+//#endregion
+//#region src/middleware/static.ts
+const cachedStaticFiles = /* @__PURE__ */ new Map();
+async function respondWithNotFound(options, request, response, logger) {
+	if (!options.notFound) return;
+	if (options.notFound === true) {
+		response.statusCode = 404;
+		response.end("Not Found");
+		return;
+	}
+	if (typeof options.notFound === "string") {
+		const path = (0, node_path.resolve)(options.root, options.notFound);
+		return await respondWithFile(path, (0, mime_types.lookup)(path) || "application/octet-stream", response);
+	}
+	return await options.notFound(request, response, { logger });
+}
+async function respondWithFile(path, mimeType, response) {
+	const stream = (0, node_fs.createReadStream)(path);
+	response.setHeader("Content-Type", mimeType);
+	await new Promise((resolve, reject) => {
+		stream.on("error", (error) => {
+			respondWithInternalServerError(response);
+			reject(error);
+		}).on("end", resolve);
+		stream.pipe(response);
+	});
+}
+/**
+* Middleware to handle static file requests.
+*
+* @param {StaticHandlerOptions} options - Options for the static handler.
+* @returns {Middleware} The middleware function.
+*
+* The middleware resolves the requested URL to a file path within the specified root directory.
+* If the file exists, it reads the file content and sends it in the response.
+* If the file does not exist, it does nothing.
+*
+* @example
+* ```typescript
+* import { useMiddleware, staticHandler } from '@faasjs/core'
+*
+* export const func = useMiddleware(staticHandler({ root: __dirname + '/public' }))
+* ```
+*/
+function staticHandler(options) {
+	const handler = async (request, response, { logger }) => {
+		if (response.writableEnded) return;
+		const requestUrl = ensureRequestUrl(request, response);
+		if (!requestUrl) return;
+		if (request.method !== "GET" || requestUrl.slice(0, 2) === "/.") return;
+		const cacheKey = options.cache !== false ? `${options.cache || options.root}${requestUrl}` : null;
+		if (cacheKey) {
+			const cached = cachedStaticFiles.get(cacheKey);
+			if (cached === false) return await respondWithNotFound(options, request, response, logger);
+			if (cached) {
+				response.setHeader("Content-Type", cached.mimeType);
+				return await respondWithFile(cached.path, cached.mimeType, response);
+			}
+		}
+		let url = options.stripPrefix ? requestUrl.replace(options.stripPrefix, "") : requestUrl;
+		if (url === "/") url = "/index.html";
+		if (url.startsWith("/")) url = url.slice(1);
+		logger.debug("finding:", requestUrl);
+		const path = (0, node_path.resolve)(options.root, url);
+		if (!(0, node_fs.existsSync)(path)) {
+			logger.debug("not found:", path);
+			if (cacheKey) cachedStaticFiles.set(cacheKey, false);
+			return await respondWithNotFound(options, request, response, logger);
+		}
+		const mimeType = (0, mime_types.lookup)(path) || "application/octet-stream";
+		logger.debug("found:", mimeType, url);
+		if (cacheKey) cachedStaticFiles.set(cacheKey, {
+			path,
+			mimeType
+		});
+		return await respondWithFile(path, mimeType, response);
+	};
+	nameFunc("static", handler);
+	return handler;
+}
+
+//#endregion
+//#region src/cron/index.ts
+const CronFields = [
+	{
+		name: "minute",
+		min: 0,
+		max: 59
+	},
+	{
+		name: "hour",
+		min: 0,
+		max: 23
+	},
+	{
+		name: "dayOfMonth",
+		min: 1,
+		max: 31
+	},
+	{
+		name: "month",
+		min: 1,
+		max: 12
+	},
+	{
+		name: "dayOfWeek",
+		min: 0,
+		max: 6
+	}
+];
+function toError(error) {
+	if (error instanceof Error) return error;
+	return Error(String(error));
+}
+function parsePositiveInt(value) {
+	if (!/^\d+$/.test(value)) return NaN;
+	return Number.parseInt(value, 10);
+}
+function invalidExpressionError(expression) {
+	return Error(`[CronJob] Invalid expression "${expression}". Expected 5 fields: minute hour dayOfMonth month dayOfWeek.`);
+}
+function createCronMatcher(segment, field) {
+	if (segment === "*") return () => true;
+	if (segment.startsWith("*/")) {
+		const step = parsePositiveInt(segment.slice(2));
+		if (!Number.isInteger(step) || step <= 0) throw Error(`[CronJob] Invalid ${field.name} segment "${segment}".`);
+		return (value) => (value - field.min) % step === 0;
+	}
+	const fixed = parsePositiveInt(segment);
+	if (!Number.isInteger(fixed)) throw Error(`[CronJob] Invalid ${field.name} segment "${segment}".`);
+	if (fixed < field.min || fixed > field.max) throw Error(`[CronJob] ${field.name} value out of range: ${fixed}. Allowed range is ${field.min}-${field.max}.`);
+	return (value) => value === fixed;
+}
+function parseExpression(expression) {
+	const trimmed = expression.trim();
+	if (!trimmed) throw Error("[CronJob] expression is required.");
+	const segments = trimmed.split(/\s+/);
+	if (segments.length !== 5) throw invalidExpressionError(expression);
+	const matchers = [];
+	for (const [index, field] of CronFields.entries()) {
+		const segment = segments[index];
+		if (typeof segment !== "string") throw invalidExpressionError(expression);
+		matchers.push(createCronMatcher(segment, field));
+	}
+	return matchers;
+}
+function shouldRun(matchers, now) {
+	const values = [
+		now.getMinutes(),
+		now.getHours(),
+		now.getDate(),
+		now.getMonth() + 1,
+		now.getDay()
+	];
+	return matchers.every((matcher, index) => matcher(values[index]));
+}
+function getDelayToNextMinute(nowMs = Date.now()) {
+	const now = new Date(nowMs);
+	now.setSeconds(0, 0);
+	now.setMinutes(now.getMinutes() + 1);
+	return now.getTime() - nowMs;
+}
+/**
+* Simple cron job scheduler with 5-field cron expression support.
+*/
+var CronJob = class {
+	name;
+	expression;
+	handler;
+	onError;
+	logger;
+	matchers;
+	timer;
+	started = false;
+	lastTickMinute = -1;
+	constructor(options) {
+		this.expression = options.expression;
+		this.handler = options.handler;
+		this.onError = options.onError;
+		this.name = options.name || `cron#${(0, node_crypto.randomBytes)(8).toString("hex")}`;
+		this.logger = options.logger || new _faasjs_node_utils.Logger(`cron][${this.name}`);
+		this.matchers = parseExpression(this.expression);
+	}
+	start() {
+		if (this.started) {
+			this.logger.warn("start() has been called, skipped.");
+			return;
+		}
+		this.started = true;
+		this.lastTickMinute = -1;
+		this.logger.debug("[start] %s", this.expression);
+		this.scheduleNext();
+	}
+	stop() {
+		if (!this.started) return;
+		this.started = false;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		this.logger.debug("[stop]");
+	}
+	get isStarted() {
+		return this.started;
+	}
+	scheduleNext() {
+		if (!this.started) return;
+		const delay = getDelayToNextMinute();
+		this.timer = setTimeout(() => {
+			this.tick();
+		}, delay);
+	}
+	tick() {
+		if (!this.started) return;
+		this.scheduleNext();
+		const now = /* @__PURE__ */ new Date();
+		const minute = Math.floor(now.getTime() / 6e4);
+		if (minute === this.lastTickMinute) return;
+		this.lastTickMinute = minute;
+		if (!shouldRun(this.matchers, now)) return;
+		this.execute(now);
+	}
+	async execute(now) {
+		const context = {
+			now,
+			logger: this.logger,
+			job: this
+		};
+		try {
+			await this.handler(context);
+		} catch (error) {
+			this.handleError(toError(error), context);
+		}
+	}
+	handleError(error, context) {
+		this.logger.error(error);
+		if (!this.onError) return;
+		Promise.resolve(this.onError(error, context)).catch((onErrorError) => {
+			this.logger.error(toError(onErrorError));
+		});
+	}
+};
+var CronJobRegistry = class {
+	cronJobs = /* @__PURE__ */ new Set();
+	mountedServerCount = 0;
+	create(options) {
+		const cronJob = new CronJob(options);
+		this.cronJobs.add(cronJob);
+		if (this.mountedServerCount > 0) cronJob.start();
+		return cronJob;
+	}
+	remove(cronJob) {
+		const removed = this.cronJobs.delete(cronJob);
+		if (removed && this.mountedServerCount > 0) cronJob.stop();
+		return removed;
+	}
+	list() {
+		return Array.from(this.cronJobs);
+	}
+	mountServer() {
+		this.mountedServerCount++;
+		if (this.mountedServerCount > 1) return;
+		for (const cronJob of this.cronJobs) cronJob.start();
+	}
+	unmountServer() {
+		if (this.mountedServerCount === 0) return;
+		this.mountedServerCount--;
+		if (this.mountedServerCount > 0) return;
+		for (const cronJob of this.cronJobs) cronJob.stop();
+	}
+};
+const cronJobRegistry = new CronJobRegistry();
+/**
+* Create and register a cron job.
+*
+* Registered jobs are managed by `Server` lifecycle automatically.
+*/
+function createCronJob(options) {
+	return cronJobRegistry.create(options);
+}
+function removeCronJob(cronJob) {
+	return cronJobRegistry.remove(cronJob);
+}
+function listCronJobs() {
+	return cronJobRegistry.list();
+}
+function mountServerCronJobs() {
+	cronJobRegistry.mountServer();
+}
+function unmountServerCronJobs() {
+	cronJobRegistry.unmountServer();
+}
+
+//#endregion
+//#region src/server/headers.ts
+const AdditionalHeaders = [
+	"content-type",
+	"authorization",
+	"x-faasjs-request-id",
+	"x-faasjs-timing-pending",
+	"x-faasjs-timing-processing",
+	"x-faasjs-timing-total"
+];
+const ExposedHeadersBlacklist = [
+	"host",
+	"connection",
+	"user-agent",
+	"accept",
+	"accept-language",
+	"referer",
+	"origin",
+	"content-length",
+	"content-md5"
+];
+function buildCORSHeaders(headers, extra = {}) {
+	const commonHeaderNames = [
+		...AdditionalHeaders,
+		...Object.keys(headers),
+		...Object.keys(extra),
+		extra["access-control-request-headers"],
+		headers["access-control-request-headers"]
+	].filter((key) => !!key && !key.startsWith("access-control-") && !ExposedHeadersBlacklist.includes(key.toLowerCase()));
+	return {
+		"access-control-allow-origin": headers.origin || "*",
+		"access-control-allow-credentials": "true",
+		"access-control-allow-methods": "OPTIONS, POST",
+		"access-control-allow-headers": Array.from(new Set(commonHeaderNames.concat(extra["access-control-allow-headers"] || headers["access-control-allow-headers"] || []))).sort().join(", "),
+		"access-control-expose-headers": Array.from(new Set(commonHeaderNames.concat(extra["access-control-expose-headers"] || headers["access-control-expose-headers"] || []))).sort().join(", "),
+		...extra
+	};
+}
+
+//#endregion
+//#region src/server/routes.ts
+function getRouteFiles(root, path) {
+	const normalizedRoot = root.endsWith(node_path.sep) ? root : `${root}${node_path.sep}`;
+	const normalizedPath = path.endsWith(node_path.sep) ? path.slice(0, -1) : path;
+	const searchPaths = [
+		`${normalizedPath}.func.ts`,
+		`${normalizedPath}${node_path.sep}index.func.ts`,
+		`${normalizedPath}${node_path.sep}default.func.ts`
+	];
+	let currentPath = normalizedPath;
+	while (currentPath.length > normalizedRoot.length) {
+		const lastSepIndex = currentPath.lastIndexOf(node_path.sep);
+		if (lastSepIndex === -1) break;
+		currentPath = currentPath.substring(0, lastSepIndex);
+		if (currentPath.length < normalizedRoot.length - 1) break;
+		searchPaths.push(`${currentPath}${node_path.sep}default.func.ts`);
+	}
+	return searchPaths;
+}
+
+//#endregion
+//#region src/server/index.ts
+const servers = [];
+function getAll() {
+	return servers;
+}
+async function closeAll() {
+	for (const server of servers) await server.close();
+}
+/**
+* FaasJS Server.
+*
+* @param {string} root The root path of the server.
+* @param {ServerOptions} opts The options of the server.
+* @returns {Server}
+* @example
+* ```ts
+* import { Server } from '@faasjs/core'
+*
+* const server = new Server(process.cwd(), {
+*   port: 8080,
+* })
+*
+* server.listen()
+* ```
+*/
+var Server = class {
+	root;
+	logger;
+	options;
+	closed = false;
+	activeRequests = 0;
+	cachedFuncs = {};
+	onError;
+	server;
+	sockets = /* @__PURE__ */ new Set();
+	constructor(root, opts = {}) {
+		(0, _faasjs_node_utils.loadEnvFileIfExists)();
+		if (!process.env.FaasEnv && process.env.NODE_ENV) process.env.FaasEnv = process.env.NODE_ENV;
+		this.root = root.endsWith(node_path.sep) ? root : root + node_path.sep;
+		this.options = (0, _faasjs_node_utils.deepMerge)({
+			port: 3e3,
+			cronJob: true
+		}, opts);
+		if (this.options.onClose && !node_util.types.isAsyncFunction(this.options.onClose)) throw Error("onClose must be async function");
+		if (this.options.onError && !node_util.types.isAsyncFunction(this.options.onError)) throw Error("onError must be async function");
+		if (this.options.onStart && !node_util.types.isAsyncFunction(this.options.onStart)) throw Error("onStart must be async function");
+		if (!process.env.FaasMode) process.env.FaasMode = "mono";
+		this.logger = new _faasjs_node_utils.Logger(`server][${(0, node_crypto.randomBytes)(16).toString("hex")}`);
+		this.logger.debug("FaasJS server initialized: [%s] [%s] %s %j", process.env.FaasEnv, process.env.FaasMode, this.root, this.options);
+		this.onError = (error) => {
+			if (!(error instanceof Error)) error = Error(error);
+			this.logger.error(error);
+			if (this.options.onError) try {
+				this.options.onError(error, { logger: this.logger });
+			} catch (error) {
+				this.logger.error(error);
+			}
+		};
+		servers.push(this);
+	}
+	async handle(req, res, options = {}) {
+		if (req.method === "OPTIONS") {
+			this.handleOptionRequest(req, res);
+			return;
+		}
+		const requestedAt = options.requestedAt || Date.now();
+		const requestId = req.headers["x-faasjs-request-id"] || req.headers["x-request-id"] || `FS-${(0, node_crypto.randomBytes)(16).toString("hex")}`;
+		const logger = new _faasjs_node_utils.Logger(requestId);
+		logger.info("%s %s", req.method, req.url);
+		const requestUrl = ensureRequestUrl(req, res);
+		if (!requestUrl) return;
+		const startedAt = Date.now();
+		const path = (0, node_path.join)(this.root, requestUrl).replace(/\?.*/, "");
+		const body = await this.readRequestBody(req);
+		if (!await this.runBeforeHandle(req, res, logger)) return;
+		let data;
+		try {
+			const cache = await this.getOrLoadHandler(path, options.filepath, logger);
+			data = await this.invokeHandler(cache, req, res, requestUrl, body, requestId);
+		} catch (error) {
+			logger.error(error);
+			data = error;
+		}
+		if (res.writableEnded) return;
+		const headers = this.buildResponseHeaders(req, requestId, requestedAt, startedAt, data);
+		for (const key in headers) res.setHeader(key, headers[key]);
+		if (data instanceof Response) {
+			res.statusCode = data.status;
+			const reader = data.body?.getReader();
+			if (reader) {
+				const stream = node_stream.Readable.from((async function* () {
+					while (true) try {
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value) yield value;
+					} catch (error) {
+						logger.error(error);
+						break;
+					}
+				})());
+				await new Promise((done) => {
+					this.pipeToResponse(stream, res, done);
+				});
+				return;
+			}
+			res.end();
+			return;
+		}
+		if (data.body instanceof ReadableStream) {
+			if (typeof data.statusCode === "number") res.statusCode = data.statusCode;
+			await new Promise((done) => {
+				this.pipeToResponse(node_stream.Readable.fromWeb(data.body), res, done);
+			});
+			return;
+		}
+		const statusCode = getErrorStatusCode(data);
+		if (statusCode === 500) {
+			respondWithJsonError(res, 500, getErrorMessage(data));
+			return;
+		}
+		let resBody;
+		if (data instanceof Error || data?.constructor?.name?.includes("Error") || typeof data === "undefined" || data === null) {
+			if (typeof statusCode === "number") respondWithJsonError(res, statusCode, getErrorMessage(data, statusCode === 500 ? INTERNAL_SERVER_ERROR_MESSAGE : "No response"));
+			else respondWithInternalServerError(res);
+			return;
+		}
+		if (typeof statusCode === "number") res.statusCode = statusCode;
+		if (data.body) resBody = data.body;
+		if (typeof resBody !== "undefined") {
+			logger.debug("Response %s %j", res.statusCode, headers);
+			res.write(resBody);
+		}
+		res.end();
+	}
+	readRequestBody(req) {
+		return new Promise((resolve) => {
+			let body = "";
+			req.on("readable", () => {
+				body += req.read() || "";
+			});
+			req.on("end", () => {
+				resolve(body);
+			});
+		});
+	}
+	async runBeforeHandle(req, res, logger) {
+		if (!this.options.beforeHandle) return true;
+		try {
+			await this.options.beforeHandle(req, res, { logger });
+			return !res.writableEnded;
+		} catch (error) {
+			logger.error(error);
+			respondWithInternalServerError(res);
+			return false;
+		}
+	}
+	async getOrLoadHandler(path, filepath, logger) {
+		const cached = this.cachedFuncs[path];
+		if (cached?.handler) {
+			logger.debug("response with cached %s", cached.file);
+			return cached;
+		}
+		const file = filepath || this.getFilePath(path);
+		const cache = { file };
+		logger.debug("response with %s", cache.file);
+		const func = await (0, _faasjs_node_utils.loadPackage)(file, ["func", "default"]);
+		func.config = (0, _faasjs_node_utils.loadConfig)(this.root, path, process.env.FaasEnv || "development", logger);
+		if (!func.config) throw Error("No config file found");
+		cache.handler = func.export().handler;
+		this.cachedFuncs[path] = cache;
+		return cache;
+	}
+	async invokeHandler(cache, req, res, requestUrl, body, requestId) {
+		const url = new URL(requestUrl, `http://${req.headers.host}`);
+		if (!cache.handler) throw Error("handler is undefined");
+		return cache.handler({
+			headers: req.headers,
+			httpMethod: req.method,
+			path: url.pathname,
+			queryString: Object.fromEntries(new URLSearchParams(url.search)),
+			body,
+			raw: {
+				request: req,
+				response: res
+			}
+		}, { request_id: requestId });
+	}
+	buildResponseHeaders(req, requestId, requestedAt, startedAt, data) {
+		const finishedAt = Date.now();
+		let headers = buildCORSHeaders(req.headers, {
+			"x-faasjs-request-id": requestId,
+			"x-faasjs-timing-pending": (startedAt - requestedAt).toString()
+		});
+		if (data.headers) headers = Object.assign(headers, data.headers);
+		if (!headers["x-faasjs-timing-processing"]) headers["x-faasjs-timing-processing"] = (finishedAt - startedAt).toString();
+		if (!headers["x-faasjs-timing-total"]) headers["x-faasjs-timing-total"] = (finishedAt - requestedAt).toString();
+		Object.freeze(headers);
+		return headers;
+	}
+	pipeToResponse(stream, res, done) {
+		stream.pipe(res).on("finish", () => {
+			res.end();
+			done();
+		}).on("error", (err) => {
+			this.onError(err);
+			respondWithInternalServerError(res);
+			done();
+		});
+	}
+	/**
+	* Start server.
+	* @returns {Server}
+	*/
+	listen() {
+		if (this.server) throw Error("Server already running");
+		const mounted = {};
+		if (this.options.onStart) {
+			this.logger.debug("[onStart] begin");
+			this.logger.time(`${this.logger.label}onStart`);
+			this.options.onStart({ logger: this.logger }).catch(this.onError).finally(() => this.logger.timeEnd(`${this.logger.label}onStart`, "[onStart] end"));
+		}
+		this.server = (0, node_http.createServer)(async (req, res) => {
+			this.activeRequests++;
+			res.on("finish", () => this.activeRequests--);
+			if (req.method === "OPTIONS") return this.handleOptionRequest(req, res);
+			const requestUrl = ensureRequestUrl(req, res);
+			if (!requestUrl) return;
+			const path = (0, node_path.join)(this.root, requestUrl).replace(/\?.*/, "");
+			if (!mounted[path]) mounted[path] = { pending: [] };
+			mounted[path].pending.push([
+				req,
+				res,
+				Date.now()
+			]);
+			const pending = mounted[path].pending;
+			mounted[path].pending = [];
+			for (const event of pending) await this.handle(event[0], event[1], { requestedAt: event[2] });
+		}).on("connection", (socket) => {
+			this.sockets.add(socket);
+			socket.on("close", () => {
+				this.sockets.delete(socket);
+			});
+		}).on("error", (e) => {
+			if ("code" in e && e.code === "EADDRINUSE") {
+				(0, node_child_process.execSync)(`lsof -i :${this.options.port}`, { stdio: "inherit" });
+				this.logger.error("Port %s is already in use. Please kill the process or use another port.", this.options.port);
+			}
+			this.onError(e);
+		}).listen(this.options.port, "0.0.0.0");
+		if (this.options.cronJob) try {
+			mountServerCronJobs();
+		} catch (error) {
+			this.onError(error);
+		}
+		process.on("uncaughtException", (e) => {
+			this.logger.debug("Uncaught exception");
+			this.onError(e);
+		}).on("unhandledRejection", (e) => {
+			this.logger.debug("Unhandled rejection");
+			this.onError(e);
+		}).on("SIGTERM", async () => {
+			this.logger.debug("received SIGTERM");
+			if (this.closed) {
+				this.logger.debug("already closed");
+				return;
+			}
+			await this.close();
+			if (!process.env.JEST_WORKER_ID && !process.env.VITEST_POOL_ID) process.exit(0);
+		}).on("SIGINT", async () => {
+			this.logger.debug("received SIGINT");
+			if (this.closed) {
+				this.logger.debug("already closed");
+				return;
+			}
+			await this.close();
+			if (!process.env.JEST_WORKER_ID && !process.env.VITEST_POOL_ID) process.exit(0);
+		});
+		this.logger.info("[%s] Listen http://localhost:%s with", process.env.FaasEnv, this.options.port, this.root);
+		return this.server;
+	}
+	/**
+	* Close server.
+	*/
+	async close() {
+		if (this.closed) {
+			this.logger.debug("already closed");
+			return;
+		}
+		this.logger.debug("closing");
+		this.logger.time(`${this.logger.label}close`);
+		if (this.options.cronJob) try {
+			unmountServerCronJobs();
+		} catch (error) {
+			this.onError(error);
+		}
+		if (this.activeRequests) await new Promise((resolve) => {
+			const check = () => {
+				if (this.activeRequests === 0) {
+					resolve();
+					return;
+				}
+				this.logger.debug("waiting for %i requests", this.activeRequests);
+				setTimeout(check, 50);
+			};
+			check();
+		});
+		for (const socket of this.sockets) try {
+			socket.destroy();
+		} catch (error) {
+			this.onError(error);
+		} finally {
+			this.sockets.delete(socket);
+		}
+		const server = this.server;
+		if (server) await new Promise((resolve) => {
+			server.close((err) => {
+				if (err) this.onError(err);
+				resolve();
+			});
+		});
+		if (this.options.onClose) {
+			this.logger.debug("[onClose] begin");
+			this.logger.time(`${this.logger.label}onClose`);
+			try {
+				await this.options.onClose({ logger: this.logger });
+			} catch (error) {
+				this.onError(error);
+			}
+			this.logger.timeEnd(`${this.logger.label}onClose`, "[onClose] end");
+		}
+		this.logger.timeEnd(`${this.logger.label}close`, "closed");
+		await (0, _faasjs_node_utils.getTransport)().stop();
+		this.closed = true;
+	}
+	/**
+	* Middleware function to handle incoming HTTP requests.
+	*
+	* @param req - The incoming HTTP request object.
+	* @param res - The server response object.
+	* @param next - A callback function to pass control to the next middleware.
+	* @returns A promise that resolves when the middleware processing is complete.
+	*/
+	async middleware(req, res, next) {
+		const requestUrl = ensureRequestUrl(req, res);
+		if (!requestUrl) {
+			next();
+			return;
+		}
+		try {
+			const filepath = this.getFilePath((0, node_path.join)(this.root, requestUrl).replace(/\?.*/, ""));
+			await this.handle(req, res, {
+				requestedAt: Date.now(),
+				filepath
+			});
+		} catch (error) {
+			this.logger.debug("middleware error", error);
+		}
+		next();
+	}
+	getFilePath(path) {
+		if (/^(\.|\|\/)+$/.test(path)) throw Error("Illegal characters");
+		const searchPaths = getRouteFiles(this.root, path);
+		for (const path of searchPaths) if ((0, node_fs.existsSync)(path)) return (0, node_path.resolve)(".", path);
+		throw new HttpError({
+			statusCode: 404,
+			message: process.env.FaasEnv === "production" ? "Not found." : `Not found function file.\nSearch paths:\n${searchPaths.map((p) => `- ${p}`).join("\n")}`
+		});
+	}
+	handleOptionRequest(req, res) {
+		res.writeHead(204, buildCORSHeaders(req.headers));
+		res.end();
+	}
+};
+
+//#endregion
+//#region src/knex/pglite.ts
+function parsePgliteConnection(connection) {
+	if (typeof connection === "undefined" || connection === null) return `memory://${(0, node_crypto.randomUUID)()}`;
+	if (typeof connection !== "string" || !connection.trim().length) throw Error("[Knex] Invalid \"pglite\" connection, expected non-empty string in config.connection or SECRET_<NAME>_CONNECTION.");
+	return connection;
+}
+function ensurePgliteConnectionPath(connection) {
+	if (connection.includes("://")) return;
+	(0, node_fs.mkdirSync)((0, node_path.dirname)((0, node_path.resolve)(connection)), { recursive: true });
+}
+async function loadPglitePackages() {
+	try {
+		const pgliteModule = await (0, _faasjs_node_utils.loadPackage)("@electric-sql/pglite", []);
+		const PgliteDialect = await (0, _faasjs_node_utils.loadPackage)("knex-pglite");
+		if (typeof pgliteModule.PGlite !== "function" || !pgliteModule.types) throw Error("Invalid @electric-sql/pglite exports");
+		if (typeof PgliteDialect !== "function") throw Error("Invalid knex-pglite exports");
+		return {
+			PGlite: pgliteModule.PGlite,
+			types: pgliteModule.types,
+			PgliteDialect
+		};
+	} catch {
+		throw Error("[Knex] client \"pglite\" requires dependencies \"@electric-sql/pglite\" and \"knex-pglite\". Please install both packages in your project.");
+	}
+}
+/**
+* Create a knex instance backed by `knex-pglite`.
+* If connection is missing, it defaults to an in-memory database.
+*/
+async function createPgliteKnex(config = {}, connection) {
+	const resolvedConnection = parsePgliteConnection(connection ?? config.connection);
+	ensurePgliteConnectionPath(resolvedConnection);
+	const { PGlite, types, PgliteDialect } = await loadPglitePackages();
+	const { client: _client, connection: _connection, pool: _pool, ...restConfig } = config;
+	const pglite = new PGlite(resolvedConnection, { parsers: {
+		[types.INT2]: (v) => Number.parseInt(v, 10),
+		[types.INT4]: (v) => Number.parseInt(v, 10),
+		[types.INT8]: (v) => Number.parseInt(v, 10),
+		[types.FLOAT4]: (v) => Number.parseFloat(v),
+		[types.FLOAT8]: (v) => Number.parseFloat(v),
+		[types.NUMERIC]: (v) => Number.parseFloat(v)
+	} });
+	return (0, knex.default)({
+		...restConfig,
+		client: PgliteDialect,
+		connection: { pglite }
+	});
+}
+/**
+* Mount a knex adapter to `globalThis.FaasJS_Knex` for `@faasjs/core`.
+*/
+function mountFaasKnex(db, options = {}) {
+	const globalWithFaasKnex = globalThis;
+	const name = options.name || "knex";
+	if (!globalWithFaasKnex.FaasJS_Knex) globalWithFaasKnex.FaasJS_Knex = {};
+	globalWithFaasKnex.FaasJS_Knex[name] = {
+		adapter: db,
+		query: db,
+		config: options.config || {}
+	};
+}
+/**
+* Remove mounted knex adapter from `globalThis.FaasJS_Knex`.
+*/
+function unmountFaasKnex(name = "knex") {
+	const globalWithFaasKnex = globalThis;
+	if (!globalWithFaasKnex.FaasJS_Knex) return;
+	delete globalWithFaasKnex.FaasJS_Knex[name];
+}
+
+//#endregion
+//#region src/knex/plugin.ts
+/**
+* Origin [knex](https://knexjs.org/) instance.
+*/
+const originKnex = knex.default;
+const Name = "knex";
+if (!global.FaasJS_Knex) global.FaasJS_Knex = {};
+function getGlobalKnexAdapters() {
+	if (!global.FaasJS_Knex) global.FaasJS_Knex = {};
+	return global.FaasJS_Knex;
+}
+async function initPostgresTypeParsers() {
+	const pg = await (0, _faasjs_node_utils.loadPackage)("pg");
+	pg.types.setTypeParser(pg.types.builtins.INT2, (v) => Number.parseInt(v, 10));
+	pg.types.setTypeParser(pg.types.builtins.INT4, (v) => Number.parseInt(v, 10));
+	pg.types.setTypeParser(pg.types.builtins.INT8, (v) => Number.parseInt(v, 10));
+	pg.types.setTypeParser(pg.types.builtins.FLOAT4, (v) => Number.parseFloat(v));
+	pg.types.setTypeParser(pg.types.builtins.FLOAT8, (v) => Number.parseFloat(v));
+	pg.types.setTypeParser(pg.types.builtins.NUMERIC, (v) => Number.parseFloat(v));
+}
+var Knex = class {
+	type = "knex";
+	name = Name;
+	config;
+	adapter;
+	query;
+	logger;
+	constructor(config) {
+		if (config) {
+			this.name = config.name || this.name;
+			this.config = config.config || Object.create(null);
+		} else this.config = Object.create(null);
+	}
+	async onMount(data, next) {
+		this.logger = data.logger;
+		const existsAdapter = getGlobalKnexAdapters()[this.name];
+		if (existsAdapter) {
+			this.config = existsAdapter.config;
+			this.adapter = existsAdapter.adapter;
+			this.query = this.adapter;
+			this.logger.debug("use exists adapter");
+			await next();
+			return;
+		}
+		const prefix = `SECRET_${this.name.toUpperCase()}_`;
+		for (let key in process.env) if (key.startsWith(prefix)) {
+			const value = process.env[key];
+			key = key.replace(prefix, "").toLowerCase();
+			if (typeof this.config[key] === "undefined") if (key.startsWith("connection_")) {
+				if (typeof this.config.connection === "string") continue;
+				if (!this.config.connection || typeof this.config.connection !== "object") this.config.connection = Object.create(null);
+				this.config.connection[key.replace("connection_", "")] = value;
+			} else this.config[key] = value;
+		}
+		if (data.config.plugins?.[this.name || this.type]?.config) this.config = (0, _faasjs_node_utils.deepMerge)(data.config.plugins[this.name || this.type].config, this.config);
+		if (this.config.client === "pglite") {
+			const connectionEnvKeys = Object.keys(process.env).filter((key) => key.startsWith(`${prefix}CONNECTION_`));
+			if (connectionEnvKeys.length) throw Error(`[Knex] Invalid "pglite" env keys: ${connectionEnvKeys.join(", ")}. Use ${prefix}CONNECTION instead.`);
+			this.adapter = await createPgliteKnex(this.config);
+		} else {
+			switch (this.config.client) {
+				case "sqlite3":
+					this.config.client = "better-sqlite3";
+					this.config.useNullAsDefault = true;
+					break;
+				case "pg":
+					if (!this.config.pool) this.config.pool = Object.create(null);
+					this.config.pool = Object.assign({
+						propagateCreateError: false,
+						min: 0,
+						max: 10,
+						acquireTimeoutMillis: 5e3,
+						idleTimeoutMillis: 3e4
+					}, this.config.pool);
+					if (typeof this.config.connection === "string" && !this.config.connection.includes("json=true")) this.config.connection = `${this.config.connection}?json=true`;
+					break;
+				default:
+					if (typeof this.config.client === "string") {
+						if (this.config.client.startsWith("npm:")) {
+							const client = await (0, _faasjs_node_utils.loadPackage)(this.config.client.replace("npm:", ""));
+							if (!client) throw Error(`Invalid client: ${this.config.client}`);
+							if (typeof client === "function") {
+								this.config.client = client;
+								break;
+							}
+							if (client.default && typeof client.default === "function") {
+								this.config.client = client.default;
+								break;
+							}
+							throw Error(`Invalid client: ${this.config.client}`);
+						}
+					}
+					break;
+			}
+			this.adapter = (0, knex.default)(this.config);
+			if (this.config.client === "pg") await initPostgresTypeParsers();
+		}
+		this.query = this.adapter;
+		this.query.on("query", ({ sql, __knexQueryUid, bindings }) => {
+			if (!__knexQueryUid) return;
+			this.logger.time(`Knex${this.name}${__knexQueryUid}`);
+			this.logger.debug("[%s] query begin: %s %j", __knexQueryUid, sql, bindings);
+		}).on("query-response", (response, { sql, __knexQueryUid, bindings }) => {
+			if (!__knexQueryUid) return;
+			this.logger.timeEnd(`Knex${this.name}${__knexQueryUid}`, "[%s] query done: %s %j %j", __knexQueryUid, sql, bindings, response);
+		}).on("query-error", (_, { __knexQueryUid, sql, bindings }) => {
+			if (!__knexQueryUid) return;
+			this.logger.timeEnd(`Knex${this.name}${__knexQueryUid}`, "[%s] query failed: %s %j", __knexQueryUid, sql, bindings);
+		});
+		data.logger.debug("connected");
+		getGlobalKnexAdapters()[this.name] = this;
+		await next();
+	}
+	async onInvoke(data, next) {
+		this.logger = data.logger;
+		await next();
+	}
+	async raw(sql, bindings = []) {
+		if (!this.adapter) throw Error("[Knex] Client not initialized.");
+		return this.adapter.raw(sql, bindings);
+	}
+	/**
+	* Wraps a transaction, returning a promise that resolves to the return value of the callback.
+	*
+	* - Support 'commit' and 'rollback' event.
+	*/
+	async transaction(scope, config, options) {
+		if (!this.adapter) throw Error(`[${this.name}] Client not initialized.`);
+		if (options?.trx) return scope(options.trx);
+		const trx = await this.adapter.transaction(config);
+		const trxId = (0, node_crypto.randomUUID)();
+		this.logger.debug("[%s] transaction begin", trxId);
+		try {
+			const result = await scope(trx);
+			if (trx.isCompleted()) {
+				this.logger.debug("[%s] transaction has been finished in scope", trxId);
+				return result;
+			}
+			this.logger.debug("[%s] transaction begin commit", trxId);
+			await trx.commit();
+			this.logger.debug("[%s] transaction committed: %j", trxId, result);
+			trx.emit("commit");
+			return result;
+		} catch (error) {
+			await trx.rollback(error);
+			this.logger.error("[%s] transaction rollback: %s", trxId, error);
+			trx.emit("rollback", error);
+			throw error;
+		}
+	}
+	schema() {
+		if (!this.adapter) throw Error(`[${this.name}] Client not initialized.`);
+		return this.adapter.schema;
+	}
+	async quit() {
+		const adapters = getGlobalKnexAdapters();
+		if (!adapters[this.name]) return;
+		try {
+			await adapters[this.name].adapter.destroy();
+			delete adapters[this.name];
+		} catch (error) {
+			console.error(error);
+		}
+	}
+};
+function useKnex(config) {
+	const name = config?.name || Name;
+	const adapters = getGlobalKnexAdapters();
+	if (adapters[name]) return usePlugin(adapters[name]);
+	return usePlugin(new Knex(config));
+}
+function query(table) {
+	return useKnex().query(table);
+}
+async function transaction(scope, config, options) {
+	return useKnex().transaction(scope, config, options);
+}
+async function raw(sql, bindings = []) {
+	return useKnex().raw(sql, bindings);
+}
+
+//#endregion
+//#region src/knex/schema.ts
+const DefaultMigratorConfig = {
+	directory: "./src/db/migrations",
+	extension: "ts"
+};
+/**
+* Migration helper for FaasJS knex plugin.
+*/
+var KnexSchema = class {
+	knex;
+	constructor(knex) {
+		this.knex = knex;
+	}
+	getAdapter() {
+		if (!this.knex.adapter) throw Error(`[${this.knex.name}] Client not initialized.`);
+		return this.knex.adapter;
+	}
+	getMigratorConfig() {
+		return Object.assign({}, DefaultMigratorConfig, this.knex.config?.migrations || Object.create(null));
+	}
+	async migrateLatest() {
+		return this.getAdapter().migrate.latest(this.getMigratorConfig());
+	}
+	async migrateRollback() {
+		return this.getAdapter().migrate.rollback(this.getMigratorConfig());
+	}
+	async migrateStatus() {
+		return this.getAdapter().migrate.status(this.getMigratorConfig());
+	}
+	async migrateCurrentVersion() {
+		return this.getAdapter().migrate.currentVersion(this.getMigratorConfig());
+	}
+	async migrateMake(name) {
+		const migrationName = name?.trim();
+		if (!migrationName) throw Error("[KnexSchema] Missing migration name. Usage: npm run migrate:make -- create_users");
+		return this.getAdapter().migrate.make(migrationName, this.getMigratorConfig());
+	}
+};
+
+//#endregion
+//#region src/index.ts
+function formatPluginModuleName(type) {
+	const normalizedType = type.startsWith("npm:") ? type.slice(4) : type;
+	if (normalizedType === "http" || normalizedType === "@faasjs/http" || normalizedType === "knex" || normalizedType === "@faasjs/knex") return "@faasjs/core";
+	if (normalizedType.startsWith("@") || normalizedType.startsWith(".") || normalizedType.startsWith("/") || normalizedType.includes(":")) return normalizedType;
+	return `@faasjs/${normalizedType}`;
+}
+function formatPluginClassName(type) {
+	return type.replace(/^@[^/]+\//, "").split(/[^A-Za-z0-9]+/).filter(Boolean).map((item) => item.slice(0, 1).toUpperCase() + item.slice(1)).join("");
+}
+function isPluginConstructor(value) {
+	if (typeof value !== "function") return false;
+	const prototype = value.prototype;
+	if (!prototype || typeof prototype !== "object") return false;
+	return typeof prototype.onMount === "function" || typeof prototype.onInvoke === "function";
+}
+function normalizeIssueMessage(message) {
+	return message.replace(": expected", ", expected").replace(/>=\s+/g, ">=").replace(/<=\s+/g, "<=");
+}
+function formatZodErrorMessage(error) {
+	const lines = ["Invalid params"];
+	for (const issue of error.issues) {
+		const path = issue.path.length ? issue.path.map((item) => String(item)).join(".") : "<root>";
+		lines.push(`${path}: ${normalizeIssueMessage(issue.message)}`);
+	}
+	return lines.join("\n");
+}
+function findPluginByType(func, type) {
+	return func.plugins.find((plugin) => plugin.type === type);
+}
+function resolvePluginConfig(key, rawConfig) {
+	const configValue = rawConfig && typeof rawConfig === "object" ? Object.assign(Object.create(null), rawConfig) : Object.create(null);
+	return {
+		configValue,
+		pluginName: typeof configValue.name === "string" && configValue.name.length ? configValue.name : key,
+		pluginType: typeof configValue.type === "string" && configValue.type || typeof rawConfig === "string" && rawConfig || key
+	};
+}
+var CoreFunc = class extends Func {
+	loadedConfigPlugins = false;
+	insertPluginBeforeRunHandler(plugin) {
+		const index = this.plugins.findIndex((item) => item.type === "handler" && item.name === "handler");
+		if (index === -1) this.plugins.push(plugin);
+		else this.plugins.splice(index, 0, plugin);
+	}
+	async resolvePluginConstructor(moduleName, className, pluginName) {
+		let mod;
+		try {
+			mod = await import(moduleName);
+		} catch (error) {
+			throw Error(`[defineApi] Failed to load plugin "${pluginName}" from "${moduleName}": ${error.message}`);
+		}
+		if (className && isPluginConstructor(mod[className])) return mod[className];
+		if (isPluginConstructor(mod.default)) return mod.default;
+		throw Error(`[defineApi] Failed to resolve plugin class "${className}" from "${moduleName}" for plugin "${pluginName}". Supported exports are named class "${className}" or default class export.`);
+	}
+	async loadPluginsFromConfig(config) {
+		const pluginConfigs = config.plugins || Object.create(null);
+		for (const key in pluginConfigs) {
+			if (!Object.hasOwn(pluginConfigs, key)) continue;
+			const rawConfig = pluginConfigs[key];
+			const { configValue, pluginName, pluginType } = resolvePluginConfig(key, rawConfig);
+			if (this.plugins.find((plugin) => plugin.name === pluginName)) continue;
+			const moduleName = formatPluginModuleName(pluginType);
+			const className = formatPluginClassName(pluginType);
+			const PluginConstructor = await this.resolvePluginConstructor(moduleName, className, pluginName);
+			let plugin;
+			try {
+				plugin = new PluginConstructor({
+					...configValue,
+					name: pluginName,
+					type: pluginType
+				});
+			} catch (error) {
+				throw Error(`[defineApi] Failed to initialize plugin "${pluginName}" from "${moduleName}": ${error.message}`);
+			}
+			if (!plugin || typeof plugin !== "object") throw Error(`[defineApi] Invalid plugin instance for "${pluginName}" from "${moduleName}".`);
+			this.insertPluginBeforeRunHandler(plugin);
+		}
+		this.loadedConfigPlugins = true;
+	}
+	async mount(data = {
+		event: Object.create(null),
+		context: Object.create(null)
+	}) {
+		if (!data.config) data.config = this.config;
+		if (!this.loadedConfigPlugins) await this.loadPluginsFromConfig(data.config);
+		await super.mount(data);
+	}
+};
+/**
+* Create an HTTP API function with optional Zod validation.
+*
+* Plugins are always auto-loaded from `func.config.plugins`.
+* Plugin module exports must be either a named class (normalized from
+* plugin type) or a default class export.
+*
+* The `http` plugin is required.
+*/
+function defineApi(options) {
+	let func;
+	let pluginRefsResolved = false;
+	let hasHttp = false;
+	let knexQuery;
+	const parseParams = async (event) => {
+		if (!pluginRefsResolved) {
+			hasHttp = !!findPluginByType(func, "http");
+			knexQuery = findPluginByType(func, "knex")?.query;
+			pluginRefsResolved = true;
+		}
+		if (!hasHttp) throw Error("[defineApi] Missing required \"http\" plugin. Please configure it in func.config.plugins.");
+		if (!options.schema) return {};
+		const result = await options.schema.safeParseAsync(event?.params ?? {});
+		if (!result.success) throw new HttpError({
+			statusCode: 400,
+			message: formatZodErrorMessage(result.error)
+		});
+		return result.data;
+	};
+	const invokeHandler = async (data) => {
+		const params = await parseParams(data.event);
+		const invokeData = {
+			...data,
+			params,
+			knex: knexQuery
+		};
+		return options.handler(invokeData);
+	};
+	func = new CoreFunc({
+		plugins: [],
+		handler: invokeHandler
+	});
+	return func;
+}
+
+//#endregion
+exports.ContentType = ContentType;
+exports.Cookie = Cookie;
+exports.CronJob = CronJob;
+exports.Func = Func;
+exports.Http = Http;
+exports.HttpError = HttpError;
+exports.Knex = Knex;
+exports.KnexSchema = KnexSchema;
+exports.Server = Server;
+exports.Session = Session;
+exports.closeAll = closeAll;
+exports.createCronJob = createCronJob;
+exports.createPgliteKnex = createPgliteKnex;
+exports.defineApi = defineApi;
+exports.getAll = getAll;
+exports.initPostgresTypeParsers = initPostgresTypeParsers;
+exports.listCronJobs = listCronJobs;
+exports.mountFaasKnex = mountFaasKnex;
+exports.nameFunc = nameFunc;
+exports.originKnex = originKnex;
+exports.parseFuncFilenameFromStack = parseFuncFilenameFromStack;
+exports.query = query;
+exports.raw = raw;
+exports.removeCronJob = removeCronJob;
+exports.staticHandler = staticHandler;
+exports.transaction = transaction;
+exports.unmountFaasKnex = unmountFaasKnex;
+exports.useFunc = useFunc;
+exports.useHttp = useHttp;
+exports.useKnex = useKnex;
+exports.useMiddleware = useMiddleware;
+exports.useMiddlewares = useMiddlewares;
+exports.usePlugin = usePlugin;
+Object.defineProperty(exports, 'z', {
+  enumerable: true,
+  get: function () {
+    return zod;
+  }
+});