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

package/dist/index.mjs

@@ -1,358 +1,287 @@
-import { __export, isTypegenSourceFile, generateFaasTypes, __reExport, resolveServerConfig } from './chunk-3FXFWIBW.mjs';
-export { generateFaasTypes, isTypegenSourceFile } from './chunk-3FXFWIBW.mjs';
-import { types, PGlite } from '@electric-sql/pglite';
-import knex from 'knex';
-import PgliteDialect from 'knex-pglite';
-import { brotliDecompressSync, gunzipSync, inflateSync } from 'zlib';
-import { deepMerge } from '@faasjs/deep_merge';
-import { Http } from '@faasjs/http';
-import { loadConfig } from '@faasjs/load';
-import { Logger } from '@faasjs/logger';
-import * as func_star from '@faasjs/func';
-import { join } from 'path';
-import { Server } from '@faasjs/server';
+import { n as __reExport, t as __exportAll } from "./chunk-CtajNgzt.mjs";
+import { n as isTypegenSourceFile, r as resolveServerConfig, t as generateFaasTypes } from "./typegen-D5s91_xL.mjs";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
+import { Http } from "@faasjs/http";
+import { Logger } from "@faasjs/logger";
+import { deepMerge, loadConfig, streamToObject, streamToString, streamToText } from "@faasjs/node-utils";
+import { join } from "node:path";
+import { Server } from "@faasjs/server";
 
-// 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 = {
-  [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)
-};
-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 = new PGlite({
-    ...dataDir ? { dataDir } : {},
-    parsers: postgresTypeParsers
-  });
-  const pgliteKnexConnection = {
-    ...connection,
-    pglite
-  };
-  return knex({
-    ...config,
-    client: PgliteDialect,
-    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];
-}
+export * from "@faasjs/func"
 
-// src/test.ts
-var test_exports = {};
-__export(test_exports, {
-  FuncWarper: () => FuncWarper,
-  streamToString: () => streamToString,
-  test: () => test
-});
-__reExport(test_exports, func_star);
-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("TestCase");
-    this.func = initBy.default ? initBy.default : initBy;
-    if (this.func.filename)
-      this.func.config = deepMerge(
-        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) {
-      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 = brotliDecompressSync(compressedBuffer);
-          } else if (encoding === "gzip") {
-            decompressed = gunzipSync(compressedBuffer);
-          } else if (encoding === "deflate") {
-            decompressed = 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 Logger("TestCase");
+		this.func = initBy.default ? initBy.default : initBy;
+		if (this.func.filename) this.func.config = deepMerge(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 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 = brotliDecompressSync(compressedBuffer);
+					else if (encoding === "gzip") decompressed = gunzipSync(compressedBuffer);
+					else if (encoding === "deflate") decompressed = 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 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);
-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 = null;
-  const logger = new Logger("FaasJs:Vite");
-  return {
-    name: "vite:faasjs",
-    enforce: "pre",
-    configResolved(resolvedConfig) {
-      const serverConfig = 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 Server(join(config.root, "src"));
-      const runTypegen = async () => {
-        try {
-          const result = await 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) 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) return next();
-        const originalUrl = req.url;
-        const strippedUrl = stripBase(req.url, config.base);
-        req.url = strippedUrl;
-        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();
-      });
-    }
-  };
+	let config;
+	let server = null;
+	const logger = new Logger("FaasJs:Vite");
+	return {
+		name: "vite:faasjs",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			const serverConfig = 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 Server(join(config.root, "src"));
+			const runTypegen = async () => {
+				try {
+					const result = await 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 (!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();
+			});
+		}
+	};
 }
 
-export { FuncWarper, createPgliteKnex, mountFaasKnex, streamToString, test, unmountFaasKnex, viteFaasJsServer };
+//#endregion
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	FuncWarper: () => FuncWarper,
+	generateFaasTypes: () => generateFaasTypes,
+	isTypegenSourceFile: () => isTypegenSourceFile,
+	streamToObject: () => streamToObject,
+	streamToString: () => streamToString,
+	streamToText: () => streamToText,
+	test: () => test,
+	viteFaasJsServer: () => viteFaasJsServer
+});
+
+//#endregion
+export { FuncWarper, generateFaasTypes, isTypegenSourceFile, streamToObject, streamToString, streamToText, test, viteFaasJsServer };