@faasjs/dev 8.0.0-beta.6 → 8.0.0-beta.8

package/dist/index.cjs

@@ -1,606 +1,334 @@
-'use strict';
-
-var pglite = require('@electric-sql/pglite');
-var knex = require('knex');
-var PgliteDialect = require('knex-pglite');
-var zlib = require('zlib');
-var deep_merge = require('@faasjs/deep_merge');
-var http = require('@faasjs/http');
-var load = require('@faasjs/load');
-var logger = require('@faasjs/logger');
-var func_star = require('@faasjs/func');
-var fs = require('fs');
-var promises = require('fs/promises');
-var path = require('path');
-var server = require('@faasjs/server');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var knex__default = /*#__PURE__*/_interopDefault(knex);
-var PgliteDialect__default = /*#__PURE__*/_interopDefault(PgliteDialect);
-var func_star__namespace = /*#__PURE__*/_interopNamespace(func_star);
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  FuncWarper: () => FuncWarper,
-  createPgliteKnex: () => createPgliteKnex,
-  generateFaasTypes: () => generateFaasTypes,
-  isTypegenSourceFile: () => isTypegenSourceFile,
-  mountFaasKnex: () => mountFaasKnex,
-  streamToString: () => streamToString,
-  test: () => test,
-  unmountFaasKnex: () => unmountFaasKnex,
-  viteFaasJsServer: () => viteFaasJsServer
-});
-var postgresTypeParsers = {
-  [pglite.types.INT2]: (v) => Number.parseInt(v, 10),
-  [pglite.types.INT4]: (v) => Number.parseInt(v, 10),
-  [pglite.types.INT8]: (v) => Number.parseInt(v, 10),
-  [pglite.types.FLOAT4]: (v) => Number.parseFloat(v),
-  [pglite.types.FLOAT8]: (v) => Number.parseFloat(v),
-  [pglite.types.NUMERIC]: (v) => Number.parseFloat(v)
-};
-function createPgliteKnex(config = {}, connection = {}) {
-  const pgliteConnection = connection;
-  const dataDir = typeof pgliteConnection.filename === "string" ? pgliteConnection.filename : typeof pgliteConnection.connectionString === "string" ? pgliteConnection.connectionString : void 0;
-  const pglite$1 = new pglite.PGlite({
-    ...dataDir ? { dataDir } : {},
-    parsers: postgresTypeParsers
-  });
-  const pgliteKnexConnection = {
-    ...connection,
-    pglite: pglite$1
-  };
-  return knex__default.default({
-    ...config,
-    client: PgliteDialect__default.default,
-    connection: pgliteKnexConnection
-  });
-}
-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 || {}
-  };
-}
-function unmountFaasKnex(name = "knex") {
-  const globalWithFaasKnex = globalThis;
-  if (!globalWithFaasKnex.FaasJS_Knex) return;
-  delete globalWithFaasKnex.FaasJS_Knex[name];
-}
+//#endregion
+const require_typegen = require('./typegen-C6t9LIyi.cjs');
+let node_zlib = require("node:zlib");
+let _faasjs_http = require("@faasjs/http");
+let _faasjs_logger = require("@faasjs/logger");
+let _faasjs_node_utils = require("@faasjs/node-utils");
+let node_path = require("node:path");
+let _faasjs_server = require("@faasjs/server");
 
-// src/test.ts
-var test_exports = {};
-__export(test_exports, {
-  FuncWarper: () => FuncWarper,
-  streamToString: () => streamToString,
-  test: () => test
-});
-__reExport(test_exports, func_star__namespace);
-async function streamToString(stream) {
-  if (!(stream instanceof ReadableStream))
-    throw new TypeError("stream must be a ReadableStream instance");
-  const reader = stream.getReader();
-  const chunks = [];
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (value) chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const decoder = new TextDecoder();
-  return decoder.decode(Buffer.concat(chunks.map((c) => Buffer.from(c))));
-}
+//#region src/test.ts
+/**
+* Test wrapper for a function.
+*
+* ```ts
+* import { FuncWarper } from '@faasjs/dev'
+* import Func from '../demo.func.ts'
+*
+* const func = new FuncWarper(Func)
+*
+* expect(await func.handler()).toEqual('Hello, world')
+* ```
+*/
 var FuncWarper = class {
-  file;
-  staging;
-  logger;
-  func;
-  config;
-  plugins;
-  _handler;
-  /**
-   * @param initBy {Func} A FaasJS function
-   * ```ts
-   * import { FuncWarper } from '@faasjs/dev'
-   *
-   * new FuncWarper(__dirname + '/../demo.func.ts')
-   * ```
-   */
-  constructor(initBy) {
-    this.staging = process.env.FaasEnv;
-    this.logger = new logger.Logger("TestCase");
-    this.func = initBy.default ? initBy.default : initBy;
-    if (this.func.filename)
-      this.func.config = deep_merge.deepMerge(
-        load.loadConfig(process.cwd(), initBy.filename, this.staging, this.logger),
-        initBy.config
-      );
-    this.plugins = this.func.plugins || [];
-    for (const plugin of this.plugins) {
-      if (["handler", "config", "plugins", "logger", "mount"].includes(
-        plugin.type
-      ))
-        continue;
-      this[plugin.type] = plugin;
-    }
-    this._handler = this.func.export().handler;
-  }
-  async mount(handler) {
-    if (!this.func.mounted) await this.func.mount();
-    if (handler) await handler(this);
-  }
-  async handler(event = /* @__PURE__ */ Object.create(null), context = /* @__PURE__ */ Object.create(null)) {
-    await this.mount();
-    const response = await this._handler(event, context);
-    this.logger.debug("response: %j", response);
-    return response;
-  }
-  async JSONhandler(body, options = /* @__PURE__ */ Object.create(null)) {
-    await this.mount();
-    const headers = options.headers || /* @__PURE__ */ Object.create(null);
-    if (this.http && this.http instanceof http.Http) {
-      if (options.cookie)
-        for (const key in options.cookie)
-          this.http.cookie.write(key, options.cookie[key]);
-      if (options.session) {
-        for (const key in options.session)
-          this.http.session.write(key, options.session[key]);
-        this.http.session.update();
-      }
-      const cookie = this.http.cookie.headers()["Set-Cookie"]?.map((c) => c.split(";")[0]).join(";");
-      if (cookie)
-        if (headers.cookie) headers.cookie += `;${cookie}`;
-        else headers.cookie = cookie;
-    }
-    const response = await this._handler({
-      httpMethod: "POST",
-      headers: Object.assign({ "content-type": "application/json" }, headers),
-      body: typeof body === "string" ? body : JSON.stringify(body)
-    });
-    if (response?.body instanceof ReadableStream) {
-      let stream = response.body;
-      const encoding = response.headers?.["Content-Encoding"] || response.headers?.["content-encoding"];
-      if (encoding) {
-        const chunks = [];
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            if (value) chunks.push(value);
-          }
-        } catch (error) {
-          this.logger.error("Failed to read ReadableStream: %s", error);
-          response.body = JSON.stringify({
-            error: { message: error.message }
-          });
-          response.error = { message: error.message };
-          response.statusCode = 500;
-          reader.releaseLock();
-          return response;
-        }
-        reader.releaseLock();
-        const compressedBuffer = Buffer.concat(chunks);
-        try {
-          let decompressed;
-          if (encoding === "br") {
-            decompressed = zlib.brotliDecompressSync(compressedBuffer);
-          } else if (encoding === "gzip") {
-            decompressed = zlib.gunzipSync(compressedBuffer);
-          } else if (encoding === "deflate") {
-            decompressed = zlib.inflateSync(compressedBuffer);
-          } else {
-            throw new Error(`Unsupported encoding: ${encoding}`);
-          }
-          stream = new ReadableStream({
-            start(controller) {
-              controller.enqueue(new Uint8Array(decompressed));
-              controller.close();
-            }
-          });
-        } catch (error) {
-          this.logger.error("Failed to decompress: %s", error);
-          response.body = JSON.stringify({
-            error: { message: error.message }
-          });
-          response.error = { message: error.message };
-          response.statusCode = 500;
-          return response;
-        }
-      }
-      try {
-        response.body = await streamToString(stream);
-      } catch (error) {
-        this.logger.error("Failed to decode ReadableStream: %s", error);
-        response.body = JSON.stringify({
-          error: { message: error.message }
-        });
-        response.error = { message: error.message };
-        response.statusCode = 500;
-      }
-    }
-    if (response?.headers && response.body && response.headers["content-type"]?.includes("json")) {
-      const parsedBody = JSON.parse(response.body);
-      response.data = parsedBody.data;
-      response.error = parsedBody.error;
-    }
-    if (this.http) {
-      response.cookie = this.http.cookie.content;
-      response.session = this.http.session.content;
-    }
-    this.logger.debug("response: %j", response);
-    return response;
-  }
+	file;
+	staging;
+	logger;
+	func;
+	config;
+	plugins;
+	_handler;
+	/**
+	* @param initBy {Func} A FaasJS function
+	* ```ts
+	* import { FuncWarper } from '@faasjs/dev'
+	*
+	* new FuncWarper(__dirname + '/../demo.func.ts')
+	* ```
+	*/
+	constructor(initBy) {
+		this.staging = process.env.FaasEnv ?? "default";
+		this.logger = new _faasjs_logger.Logger("TestCase");
+		this.func = initBy.default ? initBy.default : initBy;
+		if (this.func.filename) this.func.config = (0, _faasjs_node_utils.deepMerge)((0, _faasjs_node_utils.loadConfig)(process.cwd(), this.func.filename, this.staging, this.logger), this.func.config);
+		this.file = this.func.filename || "";
+		this.config = this.func.config;
+		this.plugins = this.func.plugins || [];
+		for (const plugin of this.plugins) {
+			if ([
+				"handler",
+				"config",
+				"plugins",
+				"logger",
+				"mount"
+			].includes(plugin.type)) continue;
+			this[plugin.type] = plugin;
+		}
+		this._handler = this.func.export().handler;
+	}
+	async mount(handler) {
+		if (!this.func.mounted) await this.func.mount();
+		if (handler) await handler(this);
+	}
+	async handler(event = Object.create(null), context = Object.create(null)) {
+		await this.mount();
+		const response = await this._handler(event, context);
+		this.logger.debug("response: %j", response);
+		return response;
+	}
+	async JSONhandler(body, options = Object.create(null)) {
+		await this.mount();
+		const headers = options.headers || Object.create(null);
+		if (this.http && this.http instanceof _faasjs_http.Http) {
+			if (options.cookie) for (const key in options.cookie) this.http.cookie.write(key, options.cookie[key]);
+			if (options.session) {
+				for (const key in options.session) this.http.session.write(key, options.session[key]);
+				this.http.session.update();
+			}
+			const cookie = this.http.cookie.headers()["Set-Cookie"]?.map((c) => c.split(";")[0]).join(";");
+			if (cookie) if (headers.cookie) headers.cookie += `;${cookie}`;
+			else headers.cookie = cookie;
+		}
+		const response = await this._handler({
+			httpMethod: "POST",
+			headers: Object.assign({ "content-type": "application/json" }, headers),
+			body: typeof body === "string" ? body : JSON.stringify(body)
+		});
+		if (response?.body instanceof ReadableStream) {
+			let stream = response.body;
+			const encoding = response.headers?.["Content-Encoding"] || response.headers?.["content-encoding"];
+			if (encoding) {
+				const chunks = [];
+				const reader = stream.getReader();
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value) chunks.push(value);
+					}
+				} catch (error) {
+					this.logger.error("Failed to read ReadableStream: %s", error);
+					response.body = JSON.stringify({ error: { message: error.message } });
+					response.error = { message: error.message };
+					response.statusCode = 500;
+					reader.releaseLock();
+					return response;
+				}
+				reader.releaseLock();
+				const compressedBuffer = Buffer.concat(chunks);
+				try {
+					let decompressed;
+					if (encoding === "br") decompressed = (0, node_zlib.brotliDecompressSync)(compressedBuffer);
+					else if (encoding === "gzip") decompressed = (0, node_zlib.gunzipSync)(compressedBuffer);
+					else if (encoding === "deflate") decompressed = (0, node_zlib.inflateSync)(compressedBuffer);
+					else throw new Error(`Unsupported encoding: ${encoding}`);
+					stream = new ReadableStream({ start(controller) {
+						controller.enqueue(new Uint8Array(decompressed));
+						controller.close();
+					} });
+				} catch (error) {
+					this.logger.error("Failed to decompress: %s", error);
+					response.body = JSON.stringify({ error: { message: error.message } });
+					response.error = { message: error.message };
+					response.statusCode = 500;
+					return response;
+				}
+			}
+			try {
+				response.body = await (0, _faasjs_node_utils.streamToText)(stream);
+			} catch (error) {
+				this.logger.error("Failed to decode ReadableStream: %s", error);
+				response.body = JSON.stringify({ error: { message: error.message } });
+				response.error = { message: error.message };
+				response.statusCode = 500;
+			}
+		}
+		if (response?.headers && response.body && response.headers["content-type"]?.includes("json")) {
+			const parsedBody = JSON.parse(response.body);
+			response.data = parsedBody.data;
+			response.error = parsedBody.error;
+		}
+		if (this.http) {
+			response.cookie = this.http.cookie.content;
+			response.session = this.http.session.content;
+		}
+		this.logger.debug("response: %j", response);
+		return response;
+	}
 };
+/**
+* A simple way to wrap a FaasJS function.
+* @param initBy {Func} Full file path or a FaasJs function
+*
+* ```ts
+* import { test } from '@faasjs/dev'
+* import Func from '../demo.func.ts'
+*
+* const func = test(Func)
+*
+* expect(await func.handler()).toEqual('Hello, world')
+* ```
+*/
 function test(initBy) {
-  const warper = new FuncWarper(initBy);
-  warper.mount = warper.mount.bind(warper);
-  warper.handler = warper.handler.bind(warper);
-  warper.JSONhandler = warper.JSONhandler.bind(warper);
-  return warper;
+	const warper = new FuncWarper(initBy);
+	warper.mount = warper.mount.bind(warper);
+	warper.handler = warper.handler.bind(warper);
+	warper.JSONhandler = warper.JSONhandler.bind(warper);
+	return warper;
 }
 
-// src/index.ts
-__reExport(index_exports, test_exports);
-function resolveFaasStaging() {
-  return process.env.FaasEnv || "development";
-}
-function resolveServerConfig(root, logger, defaultBase = "/") {
-  const projectRoot = path.resolve(root);
-  const staging = resolveFaasStaging();
-  const srcRoot = path.join(projectRoot, "src");
-  const config = load.loadConfig(
-    srcRoot,
-    path.join(srcRoot, "index.func.ts"),
-    staging,
-    logger
-  );
-  const server = config && typeof config === "object" ? config.server : void 0;
-  const resolvedRoot = server && typeof server.root === "string" && server.root.length ? path.resolve(projectRoot, server.root) : projectRoot;
-  const resolvedBase = server && typeof server.base === "string" && server.base.length ? server.base : defaultBase;
-  return {
-    root: resolvedRoot,
-    base: resolvedBase,
-    staging
-  };
-}
-
-// src/typegen.ts
-function normalizeSlashes(path) {
-  return path.replace(/\\/g, "/");
-}
-function normalizeRoute(path) {
-  const normalized = path.replace(/\/+/g, "/");
-  if (!normalized.length || normalized === "/") return "/";
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-}
-function toRoute(srcRoot, file) {
-  const relativePath = normalizeSlashes(path.relative(srcRoot, file));
-  const noTsPath = relativePath.replace(/\.ts$/, "");
-  if (noTsPath === "index.func") return { route: "/", priority: 2 };
-  if (noTsPath === "default.func") return { route: "/*", priority: 1 };
-  if (noTsPath.endsWith("/index.func"))
-    return {
-      route: normalizeRoute(`/${noTsPath.slice(0, -"/index.func".length)}`),
-      priority: 2
-    };
-  if (noTsPath.endsWith("/default.func"))
-    return {
-      route: normalizeRoute(`/${noTsPath.slice(0, -"/default.func".length)}/*`),
-      priority: 1
-    };
-  if (noTsPath.endsWith(".func"))
-    return {
-      route: normalizeRoute(`/${noTsPath.slice(0, -".func".length)}`),
-      priority: 3
-    };
-  throw Error(`[faas-types] Invalid func filename: ${file}`);
-}
-function toImportPath(fromFile, targetFile) {
-  const fromDir = path.dirname(fromFile);
-  const importPath = normalizeSlashes(path.relative(fromDir, targetFile)).replace(
-    /\.ts$/,
-    ""
-  );
-  if (importPath.startsWith(".")) return importPath;
-  return `./${importPath}`;
-}
-function parsePluginTypes(config) {
-  const pluginConfig = config.plugins;
-  if (!pluginConfig || typeof pluginConfig !== "object") return [];
-  const pluginTypes = /* @__PURE__ */ new Set();
-  for (const key in pluginConfig) {
-    const data = pluginConfig[key];
-    if (typeof data === "string" && data.length) {
-      pluginTypes.add(data);
-      continue;
-    }
-    if (data && typeof data === "object") {
-      if (typeof data.type === "string" && data.type.length)
-        pluginTypes.add(data.type);
-      else pluginTypes.add(key);
-      continue;
-    }
-    pluginTypes.add(key);
-  }
-  return Array.from(pluginTypes).sort((a, b) => a.localeCompare(b));
-}
-async function readFuncFiles(dir) {
-  const result = [];
-  async function walk(currentDir) {
-    const entries = await promises.readdir(currentDir, {
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      if (entry.name === ".faasjs" || entry.name === "node_modules") continue;
-      const filePath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(filePath);
-        continue;
-      }
-      if (entry.isFile() && entry.name.endsWith(".func.ts"))
-        result.push(filePath);
-    }
-  }
-  await walk(dir);
-  return result.sort((a, b) => a.localeCompare(b));
-}
-function formatTypes(items) {
-  const actionLines = items.map((item) => {
-    return `    ${JSON.stringify(item.route)}: __FaasFuncAction<__FaasModuleFunc<typeof import(${JSON.stringify(item.importPath)})>>`;
-  });
-  const eventLines = items.map((item) => {
-    const plugins = item.pluginTypes.length ? `[${item.pluginTypes.map((type) => JSON.stringify(type)).join(", ")}]` : "[]";
-    return `    ${JSON.stringify(item.route)}: InferPluginEvent<${plugins}>`;
-  });
-  return `/**
- * Generated by @faasjs/dev.
- *
- * Do not edit this file manually.
- */
-import type { Func, InferPluginEvent } from '@faasjs/func'
-
-type __FaasModuleFunc<TModule> = TModule extends { func: infer TFunc }
-  ? TFunc extends Func
-    ? TFunc
-    : never
-  : TModule extends { default: infer TFunc }
-    ? TFunc extends Func
-      ? TFunc
-      : never
-    : never
-
-type __FaasFuncAction<TFunc extends Func> = {
-  Params: Parameters<ReturnType<TFunc['export']>['handler']>[0]['params']
-  Data: Awaited<ReturnType<ReturnType<TFunc['export']>['handler']>>
-}
-
-declare module '@faasjs/types' {
-  interface FaasActions {
-${actionLines.length ? `${actionLines.join("\n")}
-` : ""}  }
-
-  interface FaasEvents {
-${eventLines.length ? `${eventLines.join("\n")}
-` : ""}  }
-}
-`;
-}
-function isTypegenSourceFile(filePath) {
-  return /\.func\.ts$/.test(filePath) || /(^|[\\/])faas\.ya?ml$/.test(filePath);
-}
-async function generateFaasTypes(options = {}) {
-  const logger$1 = options.logger || new logger.Logger("FaasJs:Typegen");
-  const { root: projectRoot, staging } = resolveServerConfig(
-    options.root || process.cwd(),
-    logger$1
-  );
-  const srcRoot = path.join(projectRoot, "src");
-  const output = path.join(srcRoot, ".faasjs", "types.d.ts");
-  if (!fs.existsSync(srcRoot))
-    throw Error(`[faas-types] Source directory not found: ${srcRoot}`);
-  const files = await readFuncFiles(srcRoot);
-  const routeMap = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const { route, priority } = toRoute(srcRoot, file);
-    const config = load.loadConfig(srcRoot, file, staging, logger$1);
-    const pluginTypes = parsePluginTypes(config);
-    const importPath = toImportPath(output, file);
-    const prev = routeMap.get(route);
-    if (!prev || priority > prev.priority)
-      routeMap.set(route, {
-        route,
-        importPath,
-        pluginTypes,
-        priority
-      });
-  }
-  const items = Array.from(routeMap.values()).sort(
-    (a, b) => a.route.localeCompare(b.route)
-  );
-  const content = formatTypes(items);
-  let changed = true;
-  try {
-    const previous = await promises.readFile(output, "utf8");
-    if (previous === content) changed = false;
-  } catch (_error) {
-  }
-  if (changed) {
-    await promises.mkdir(path.dirname(output), {
-      recursive: true
-    });
-    await promises.writeFile(output, content);
-  }
-  return {
-    output,
-    changed,
-    fileCount: files.length,
-    routeCount: items.length
-  };
-}
-var TYPEGEN_DEBOUNCE = 120;
+//#endregion
+//#region src/vite.ts
+const TYPEGEN_DEBOUNCE = 120;
 function normalizeBase(base) {
-  const normalized = base.startsWith("/") ? base : `/${base}`;
-  if (normalized === "/") return "/";
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+	const normalized = base.startsWith("/") ? base : `/${base}`;
+	if (normalized === "/") return "/";
+	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
 }
 function stripBase(url, base) {
-  if (base === "/") return url;
-  const queryIndex = url.indexOf("?");
-  const pathname = queryIndex >= 0 ? url.slice(0, queryIndex) : url;
-  const search = queryIndex >= 0 ? url.slice(queryIndex) : "";
-  if (pathname === base) return `/${search}`;
-  if (pathname.startsWith(`${base}/`))
-    return `${pathname.slice(base.length)}${search}`;
-  return url;
+	if (base === "/") return url;
+	const queryIndex = url.indexOf("?");
+	const pathname = queryIndex >= 0 ? url.slice(0, queryIndex) : url;
+	const search = queryIndex >= 0 ? url.slice(queryIndex) : "";
+	if (pathname === base) return `/${search}`;
+	if (pathname.startsWith(`${base}/`)) return `${pathname.slice(base.length)}${search}`;
+	return url;
 }
+/**
+* Create a Vite plugin that proxies POST requests to an in-process FaasJS server.
+*
+* It resolves server root/base from `src/faas.yaml` and strips `base` from
+* request URL before forwarding to `@faasjs/server`.
+*/
 function viteFaasJsServer() {
-  let config;
-  let server$1 = null;
-  const logger$1 = new logger.Logger("FaasJs:Vite");
-  return {
-    name: "vite:faasjs",
-    enforce: "pre",
-    configResolved(resolvedConfig) {
-      const serverConfig = resolveServerConfig(
-        resolvedConfig.root,
-        logger$1,
-        resolvedConfig.base
-      );
-      config = {
-        root: serverConfig.root,
-        base: normalizeBase(serverConfig.base)
-      };
-    },
-    configureServer: async ({ middlewares, watcher }) => {
-      if (process.env.VITEST) {
-        logger$1.debug("Skipping faas server in vitest environment");
-        return;
-      }
-      if (!config) throw new Error("viteFaasJsServer: config is not resolved");
-      server$1 = new server.Server(path.join(config.root, "src"));
-      const runTypegen = async () => {
-        try {
-          const result = await generateFaasTypes({
-            root: config.root
-          });
-          logger$1.debug(
-            "[faas-types] %s %s (%i routes)",
-            result.changed ? "generated" : "up-to-date",
-            result.output,
-            result.routeCount
-          );
-        } catch (error) {
-          logger$1.error("[faas-types] %s", error.message);
-        }
-      };
-      let timer = null;
-      let runningTypegen = false;
-      let pendingTypegen = false;
-      const flushTypegen = async () => {
-        if (runningTypegen || !pendingTypegen) return;
-        pendingTypegen = false;
-        runningTypegen = true;
-        try {
-          await runTypegen();
-        } finally {
-          runningTypegen = false;
-          if (pendingTypegen) void flushTypegen();
-        }
-      };
-      const scheduleTypegen = () => {
-        pendingTypegen = true;
-        if (timer) clearTimeout(timer);
-        timer = setTimeout(() => {
-          void flushTypegen();
-        }, TYPEGEN_DEBOUNCE);
-      };
-      await runTypegen();
-      watcher.on("all", (_eventName, filePath) => {
-        if (!isTypegenSourceFile(filePath)) return;
-        scheduleTypegen();
-      });
-      middlewares.use(async (req, res, next) => {
-        if (!req.url || req.method !== "POST" || !server$1) return next();
-        const originalUrl = req.url;
-        const strippedUrl = stripBase(req.url, config.base);
-        req.url = strippedUrl;
-        try {
-          logger$1.debug(`Request ${req.url}`);
-          await server$1.handle(req, res, {
-            requestedAt: Date.now()
-          });
-        } catch (error) {
-          logger$1.error(error);
-          if (!res.headersSent && !res.writableEnded) {
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.write(
-              JSON.stringify({
-                error: { message: "Internal Server Error" }
-              })
-            );
-            res.end();
-          }
-        } finally {
-          req.url = originalUrl;
-        }
-        if (!res.writableEnded) next();
-      });
-    }
-  };
+	let config;
+	let server = null;
+	const logger = new _faasjs_logger.Logger("FaasJs:Vite");
+	return {
+		name: "vite:faasjs",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			const serverConfig = require_typegen.resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
+			config = {
+				root: serverConfig.root,
+				base: normalizeBase(serverConfig.base)
+			};
+		},
+		configureServer: async ({ middlewares, watcher }) => {
+			if (process.env.VITEST) {
+				logger.debug("Skipping faas server in vitest environment");
+				return;
+			}
+			if (!config) throw new Error("viteFaasJsServer: config is not resolved");
+			server = new _faasjs_server.Server((0, node_path.join)(config.root, "src"));
+			const runTypegen = async () => {
+				try {
+					const result = await require_typegen.generateFaasTypes({ root: config.root });
+					logger.debug("[faas-types] %s %s (%i routes)", result.changed ? "generated" : "up-to-date", result.output, result.routeCount);
+				} catch (error) {
+					logger.error("[faas-types] %s", error.message);
+				}
+			};
+			let timer = null;
+			let runningTypegen = false;
+			let pendingTypegen = false;
+			const flushTypegen = async () => {
+				if (runningTypegen || !pendingTypegen) return;
+				pendingTypegen = false;
+				runningTypegen = true;
+				try {
+					await runTypegen();
+				} finally {
+					runningTypegen = false;
+					if (pendingTypegen) flushTypegen();
+				}
+			};
+			const scheduleTypegen = () => {
+				pendingTypegen = true;
+				if (timer) clearTimeout(timer);
+				timer = setTimeout(() => {
+					flushTypegen();
+				}, TYPEGEN_DEBOUNCE);
+			};
+			await runTypegen();
+			watcher.on("all", (_eventName, filePath) => {
+				if (!require_typegen.isTypegenSourceFile(filePath)) return;
+				scheduleTypegen();
+			});
+			middlewares.use(async (req, res, next) => {
+				if (!req.url || req.method !== "POST" || !server) return next();
+				const originalUrl = req.url;
+				req.url = stripBase(req.url, config.base);
+				try {
+					logger.debug(`Request ${req.url}`);
+					await server.handle(req, res, { requestedAt: Date.now() });
+				} catch (error) {
+					logger.error(error);
+					if (!res.headersSent && !res.writableEnded) {
+						res.writeHead(500, { "Content-Type": "application/json" });
+						res.write(JSON.stringify({ error: { message: "Internal Server Error" } }));
+						res.end();
+					}
+				} finally {
+					req.url = originalUrl;
+				}
+				if (!res.writableEnded) next();
+			});
+		}
+	};
 }
 
+//#endregion
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	FuncWarper: () => FuncWarper,
+	generateFaasTypes: () => require_typegen.generateFaasTypes,
+	isTypegenSourceFile: () => require_typegen.isTypegenSourceFile,
+	streamToObject: () => _faasjs_node_utils.streamToObject,
+	streamToString: () => _faasjs_node_utils.streamToString,
+	streamToText: () => _faasjs_node_utils.streamToText,
+	test: () => test,
+	viteFaasJsServer: () => viteFaasJsServer
+});
+
+//#endregion
 exports.FuncWarper = FuncWarper;
-exports.createPgliteKnex = createPgliteKnex;
-exports.generateFaasTypes = generateFaasTypes;
-exports.isTypegenSourceFile = isTypegenSourceFile;
-exports.mountFaasKnex = mountFaasKnex;
-exports.streamToString = streamToString;
+exports.generateFaasTypes = require_typegen.generateFaasTypes;
+exports.isTypegenSourceFile = require_typegen.isTypegenSourceFile;
+exports.streamToObject = _faasjs_node_utils.streamToObject;
+exports.streamToString = _faasjs_node_utils.streamToString;
+exports.streamToText = _faasjs_node_utils.streamToText;
 exports.test = test;
-exports.unmountFaasKnex = unmountFaasKnex;
 exports.viteFaasJsServer = viteFaasJsServer;
+var _faasjs_func = require("@faasjs/func");
+Object.keys(_faasjs_func).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _faasjs_func[k]; }
+  });
+});