@faasjs/dev 8.0.0-beta.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present, Zhu Feng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,103 @@
+# @faasjs/dev
+
+FaasJS development toolkit for local development and testing.
+
+[![License: MIT](https://img.shields.io/npm/l/@faasjs/dev.svg)](https://github.com/faasjs/faasjs/blob/main/packages/dev/LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/@faasjs/dev.svg)](https://www.npmjs.com/package/@faasjs/dev)
+
+## Install
+
+```sh
+npm install @faasjs/dev
+```
+
+## Features
+
+- Vite integration for in-process FaasJS API during local development.
+- PGlite helpers for lightweight database setup in tests.
+- Test helpers to invoke and assert FaasJS functions.
+
+## Usage: Vite integration
+
+```ts
+import { viteFaasJsServer } from '@faasjs/dev'
+
+export default defineConfig({
+  plugins: [viteFaasJsServer()],
+})
+```
+
+## Usage: PGlite helpers
+
+```ts
+import {
+  createPgliteKnex,
+  mountFaasKnex,
+  unmountFaasKnex,
+} from '@faasjs/dev'
+
+const db = createPgliteKnex()
+mountFaasKnex(db)
+
+// run tests...
+
+await db.destroy()
+unmountFaasKnex()
+```
+
+## Usage: Test helpers
+
+```ts
+import { test } from '@faasjs/dev'
+import Func from '../demo.func.ts'
+
+const func = test(Func)
+const response = await func.JSONhandler({ name: 'FaasJS' })
+
+expect(response.statusCode).toBe(200)
+expect(response.data).toEqual({ message: 'Hello, FaasJS' })
+```
+
+## API
+
+- Vite: [viteFaasJsServer](functions/viteFaasJsServer.md), [ViteFaasJsServerOptions](type-aliases/ViteFaasJsServerOptions.md)
+- PGlite: [createPgliteKnex](functions/createPgliteKnex.md), [mountFaasKnex](functions/mountFaasKnex.md), [runPgliteSql](functions/runPgliteSql.md), [runPgliteSqlFile](functions/runPgliteSqlFile.md), [unmountFaasKnex](functions/unmountFaasKnex.md), [MountFaasKnexOptions](type-aliases/MountFaasKnexOptions.md)
+- Test: [test](functions/test.md), [FuncWarper](classes/FuncWarper.md), [streamToString](functions/streamToString.md)
+
+## Functions
+
+- [createPgliteKnex](functions/createPgliteKnex.md)
+- [defineFunc](functions/defineFunc.md)
+- [mountFaasKnex](functions/mountFaasKnex.md)
+- [nameFunc](functions/nameFunc.md)
+- [parseFuncFilenameFromStack](functions/parseFuncFilenameFromStack.md)
+- [runPgliteSql](functions/runPgliteSql.md)
+- [runPgliteSqlFile](functions/runPgliteSqlFile.md)
+- [streamToString](functions/streamToString.md)
+- [test](functions/test.md)
+- [unmountFaasKnex](functions/unmountFaasKnex.md)
+- [useFunc](functions/useFunc.md)
+- [usePlugin](functions/usePlugin.md)
+- [viteFaasJsServer](functions/viteFaasJsServer.md)
+
+## Classes
+
+- [Func](classes/Func.md)
+- [FuncWarper](classes/FuncWarper.md)
+
+## Type Aliases
+
+- [Config](type-aliases/Config.md)
+- [ExportedHandler](type-aliases/ExportedHandler.md)
+- [FuncConfig](type-aliases/FuncConfig.md)
+- [FuncEventType](type-aliases/FuncEventType.md)
+- [FuncReturnType](type-aliases/FuncReturnType.md)
+- [Handler](type-aliases/Handler.md)
+- [InvokeData](type-aliases/InvokeData.md)
+- [LifeCycleKey](type-aliases/LifeCycleKey.md)
+- [MountData](type-aliases/MountData.md)
+- [MountFaasKnexOptions](type-aliases/MountFaasKnexOptions.md)
+- [Next](type-aliases/Next.md)
+- [Plugin](type-aliases/Plugin.md)
+- [UseifyPlugin](type-aliases/UseifyPlugin.md)
+- [ViteFaasJsServerOptions](type-aliases/ViteFaasJsServerOptions.md)

package/dist/index.cjs

@@ -0,0 +1,356 @@
+'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);
+
+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 __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;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+
+// 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);
+}
+
+// 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))));
+}
+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;
+  }
+};
+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;
+}
+
+// src/index.ts
+__reExport(index_exports, test_exports);
+function normalizeBase(base) {
+  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;
+}
+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();
+      });
+    }
+  };
+}
+
+exports.FuncWarper = FuncWarper;
+exports.createPgliteKnex = createPgliteKnex;
+exports.mountFaasKnex = mountFaasKnex;
+exports.runPgliteSql = runPgliteSql;
+exports.runPgliteSqlFile = runPgliteSqlFile;
+exports.streamToString = streamToString;
+exports.test = test;
+exports.unmountFaasKnex = unmountFaasKnex;
+exports.viteFaasJsServer = viteFaasJsServer;

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+import { Knex } from 'knex';
+import { Func, Config, Plugin } from '@faasjs/func';
+export * from '@faasjs/func';
+import { Logger } from '@faasjs/logger';
+import { Plugin as Plugin$1 } from 'vite';
+
+type MountFaasKnexOptions = {
+    /** key of `globalThis.FaasJS_Knex`, default is `knex` */
+    name?: string;
+    /** optional config metadata passed through to `@faasjs/knex` */
+    config?: Record<string, unknown>;
+};
+/**
+ * Create a knex instance backed by `knex-pglite`.
+ */
+declare function createPgliteKnex(config?: Partial<Knex.Config>, connection?: Record<string, unknown>): Knex;
+/**
+ * Mount a knex adapter to `globalThis.FaasJS_Knex` for `@faasjs/knex`.
+ */
+declare function mountFaasKnex(db: Knex, options?: MountFaasKnexOptions): void;
+/**
+ * Remove mounted knex adapter from `globalThis.FaasJS_Knex`.
+ */
+declare function unmountFaasKnex(name?: string): void;
+/**
+ * Run a SQL string on a PGlite-backed knex instance.
+ */
+declare function runPgliteSql(db: Knex, sql: string): Promise<void>;
+/**
+ * Run SQL from file on a PGlite-backed knex instance.
+ */
+declare function runPgliteSqlFile(db: Knex, filePath: string, options?: {
+    stripUuidOsspExtension?: boolean;
+}): Promise<void>;
+
+/**
+ * Convert ReadableStream to string.
+ * @param stream {ReadableStream<Uint8Array>} The stream to convert
+ * @returns {Promise<string>} The string content of stream
+ * @throws {TypeError} If stream is not a ReadableStream instance
+ */
+declare function streamToString(stream: ReadableStream<Uint8Array>): Promise<string>;
+/**
+ * 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')
+ * ```
+ */
+declare class FuncWarper {
+    [key: string]: any;
+    readonly file: string;
+    readonly staging: string;
+    readonly logger: Logger;
+    readonly func: Func;
+    readonly config: Config;
+    readonly plugins: Plugin[];
+    private readonly _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: Func);
+    mount(handler?: (func: FuncWarper) => Promise<void> | void): Promise<void>;
+    handler<TResult = any>(event?: any, context?: any): Promise<TResult>;
+    JSONhandler<TData = any>(body?: {
+        [key: string]: any;
+    }, options?: {
+        headers?: {
+            [key: string]: any;
+        };
+        cookie?: {
+            [key: string]: any;
+        };
+        session?: {
+            [key: string]: any;
+        };
+    }): Promise<{
+        statusCode: number;
+        headers: {
+            [key: string]: string;
+        };
+        cookie?: Record<string, any>;
+        session?: Record<string, any>;
+        body: any;
+        data?: TData;
+        error?: {
+            message: string;
+        };
+    }>;
+}
+/**
+ * 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')
+ * ```
+ */
+declare function test(initBy: Func): FuncWarper;
+
+type ViteFaasJsServerOptions = {
+    /** faas project root path, default is vite's root */
+    root: string;
+    /** faas server base path, default is vite's base */
+    base: string;
+};
+/**
+ * Create a Vite plugin that proxies POST requests to an in-process FaasJS server.
+ *
+ * It resolves project root/base from Vite config and strips `base` from request URL
+ * before forwarding to `@faasjs/server`.
+ */
+declare function viteFaasJsServer(options?: Partial<ViteFaasJsServerOptions> & Record<string, unknown>): Plugin$1;
+
+export { FuncWarper, type MountFaasKnexOptions, type ViteFaasJsServerOptions, createPgliteKnex, mountFaasKnex, runPgliteSql, runPgliteSqlFile, streamToString, test, unmountFaasKnex, viteFaasJsServer };

package/dist/index.mjs

@@ -0,0 +1,323 @@
+import { readFileSync } from 'fs';
+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';
+
+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 __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;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+
+// 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({
+    ...config,
+    client: PgliteDialect,
+    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 = readFileSync(filePath, "utf8");
+  if (stripUuidOsspExtension)
+    sql = sql.replace(/CREATE EXTENSION IF NOT EXISTS "uuid-ossp";\s*/gi, "");
+  await runPgliteSql(db, sql);
+}
+
+// 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))));
+}
+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("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;
+  }
+};
+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;
+}
+
+// src/index.ts
+__reExport(index_exports, test_exports);
+function normalizeBase(base) {
+  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;
+}
+function viteFaasJsServer(options = {}) {
+  let config;
+  let server = null;
+  const logger = new 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.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"));
+      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();
+      });
+    }
+  };
+}
+
+export { FuncWarper, createPgliteKnex, mountFaasKnex, runPgliteSql, runPgliteSqlFile, streamToString, test, unmountFaasKnex, viteFaasJsServer };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@faasjs/dev",
+  "version": "v8.0.0-beta.5",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "homepage": "https://faasjs.com/doc/dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faasjs/faasjs.git",
+    "directory": "packages/dev"
+  },
+  "bugs": {
+    "url": "https://github.com/faasjs/faasjs/issues"
+  },
+  "funding": "https://github.com/sponsors/faasjs",
+  "scripts": {
+    "build": "tsup-node src/index.ts --config ../../tsup.config.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@faasjs/deep_merge": ">=v8.0.0-beta.5",
+    "@faasjs/func": ">=v8.0.0-beta.5",
+    "@faasjs/http": ">=v8.0.0-beta.5",
+    "@faasjs/server": ">=v8.0.0-beta.5",
+    "@faasjs/knex": ">=v8.0.0-beta.5",
+    "@faasjs/load": ">=v8.0.0-beta.5",
+    "@faasjs/logger": ">=v8.0.0-beta.5",
+    "knex": "*",
+    "vite": "*",
+    "knex-pglite": "*"
+  },
+  "devDependencies": {
+    "@faasjs/deep_merge": ">=v8.0.0-beta.5",
+    "@faasjs/func": ">=v8.0.0-beta.5",
+    "@faasjs/http": ">=v8.0.0-beta.5",
+    "@faasjs/server": ">=v8.0.0-beta.5",
+    "@faasjs/knex": ">=v8.0.0-beta.5",
+    "@faasjs/load": ">=v8.0.0-beta.5",
+    "@faasjs/logger": ">=v8.0.0-beta.5",
+    "knex": "*",
+    "vite": "*",
+    "knex-pglite": "*"
+  },
+  "engines": {
+    "node": ">=24.0.0",
+    "npm": ">=11.0.0"
+  }
+}