@faasjs/dev 8.0.0-beta.5 → 8.0.0-beta.7

package/dist/index.cjs

@@ -1,356 +1,334 @@
-'use strict';
-
-var fs = require('fs');
-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 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 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,
-  mountFaasKnex: () => mountFaasKnex,
-  runPgliteSql: () => runPgliteSql,
-  runPgliteSqlFile: () => runPgliteSqlFile,
-  streamToString: () => streamToString,
-  test: () => test,
-  unmountFaasKnex: () => unmountFaasKnex,
-  viteFaasJsServer: () => viteFaasJsServer
-});
-function createPgliteKnex(config = {}, connection = {}) {
-  return knex.knex({
-    ...config,
-    client: PgliteDialect__default.default,
-    connection
-  });
-}
-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];
-}
-async function runPgliteSql(db, sql) {
-  if (!sql.trim()) return;
-  await db.raw(sql);
-}
-async function runPgliteSqlFile(db, filePath, options = {}) {
-  const stripUuidOsspExtension = options.stripUuidOsspExtension !== false;
-  let sql = fs.readFileSync(filePath, "utf8");
-  if (stripUuidOsspExtension)
-    sql = sql.replace(/CREATE EXTENSION IF NOT EXISTS "uuid-ossp";\s*/gi, "");
-  await runPgliteSql(db, sql);
-}
+//#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 file {string} Full file path
-   * @param func {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);
+//#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;
 }
-function viteFaasJsServer(options = {}) {
-  let config;
-  let server$1 = null;
-  const logger$1 = new logger.Logger("FaasJs:Vite");
-  return {
-    name: "vite:faasjs",
-    enforce: "pre",
-    configResolved(resolvedConfig) {
-      const root = options.root || resolvedConfig.root;
-      const base = normalizeBase(options.base || resolvedConfig.base);
-      config = {
-        root,
-        base
-      };
-    },
-    configureServer: async ({ middlewares }) => {
-      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"));
-      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();
-      });
-    }
-  };
+/**
+* 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 = 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.mountFaasKnex = mountFaasKnex;
-exports.runPgliteSql = runPgliteSql;
-exports.runPgliteSqlFile = runPgliteSqlFile;
-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]; }
+  });
+});