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

package/dist/cli.mjs

@@ -0,0 +1,136 @@
+import { generateFaasTypes } from './chunk-3FXFWIBW.mjs';
+
+// package.json
+var package_default = {
+  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",
+  bin: {
+    "faas-types": "faas-types.mjs"
+  },
+  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 --entry src/index.ts --entry src/cli.ts --config ../../tsup.config.ts"
+  },
+  files: [
+    "dist",
+    "faas-types.mjs"
+  ],
+  peerDependencies: {
+    "@electric-sql/pglite": "*",
+    "@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",
+    "@types/node": "*",
+    knex: "*",
+    vite: "*",
+    vitest: "*",
+    "knex-pglite": "*"
+  },
+  devDependencies: {
+    "@electric-sql/pglite": "*",
+    "@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",
+    "@types/node": "*",
+    knex: "*",
+    vite: "*",
+    vitest: "*",
+    "knex-pglite": "*"
+  },
+  engines: {
+    node: ">=24.0.0",
+    npm: ">=11.0.0"
+  }
+};
+
+// src/cli.ts
+var HelpText = `Generate FaasJS API/event type declarations.
+
+Usage:
+  faas-types [options]
+
+Options:
+  --root <path>      Project root path (default: process.cwd())
+  -h, --help         Show help
+  -v, --version      Show version
+`;
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  const options = {};
+  const readValue = (index, name) => {
+    const value = args[index + 1];
+    if (!value || value.startsWith("-"))
+      throw Error(`[faas-types] Missing value for ${name}`);
+    return value;
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") return { showHelp: true, options };
+    if (arg === "-v" || arg === "--version")
+      return {
+        showVersion: true,
+        options
+      };
+    if (arg === "--root") {
+      options.root = readValue(i, arg);
+      i++;
+      continue;
+    }
+    throw Error(`[faas-types] Unknown option: ${arg}`);
+  }
+  return {
+    options
+  };
+}
+async function main(argv = process.argv) {
+  try {
+    const parsed = parseCliArgs(argv);
+    if (parsed.showHelp) {
+      console.log(HelpText);
+      return 0;
+    }
+    if (parsed.showVersion) {
+      console.log(package_default.version);
+      return 0;
+    }
+    const result = await generateFaasTypes(parsed.options);
+    console.log(
+      `[faas-types] ${result.changed ? "Generated" : "Up to date"} ${result.output} (${result.routeCount} routes from ${result.fileCount} files)`
+    );
+    return 0;
+  } catch (error) {
+    console.error(error?.message || error);
+    return 1;
+  }
+}
+
+export { main };

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var fs = require('fs');
+var pglite = require('@electric-sql/pglite');
 var knex = require('knex');
 var PgliteDialect = require('knex-pglite');
 var zlib = require('zlib');
@@ -9,6 +9,8 @@ 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');
 
@@ -32,6 +34,7 @@ function _interopNamespace(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);
 
@@ -58,19 +61,37 @@ var index_exports = {};
 __export(index_exports, {
   FuncWarper: () => FuncWarper,
   createPgliteKnex: () => createPgliteKnex,
+  generateFaasTypes: () => generateFaasTypes,
+  isTypegenSourceFile: () => isTypegenSourceFile,
   mountFaasKnex: () => mountFaasKnex,
-  runPgliteSql: () => runPgliteSql,
-  runPgliteSqlFile: () => runPgliteSqlFile,
   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 = {}) {
-  return knex.knex({
+  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
+    connection: pgliteKnexConnection
   });
 }
 function mountFaasKnex(db, options = {}) {
@@ -88,17 +109,6 @@ function unmountFaasKnex(name = "knex") {
   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 = {};
@@ -134,8 +144,7 @@ var FuncWarper = class {
   plugins;
   _handler;
   /**
-   * @param file {string} Full file path
-   * @param func {Func} A FaasJs function
+   * @param initBy {Func} A FaasJS function
    * ```ts
    * import { FuncWarper } from '@faasjs/dev'
    *
@@ -278,6 +287,203 @@ function test(initBy) {
 
 // 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;
 function normalizeBase(base) {
   const normalized = base.startsWith("/") ? base : `/${base}`;
   if (normalized === "/") return "/";
@@ -293,7 +499,7 @@ function stripBase(url, base) {
     return `${pathname.slice(base.length)}${search}`;
   return url;
 }
-function viteFaasJsServer(options = {}) {
+function viteFaasJsServer() {
   let config;
   let server$1 = null;
   const logger$1 = new logger.Logger("FaasJs:Vite");
@@ -301,20 +507,64 @@ function viteFaasJsServer(options = {}) {
     name: "vite:faasjs",
     enforce: "pre",
     configResolved(resolvedConfig) {
-      const root = options.root || resolvedConfig.root;
-      const base = normalizeBase(options.base || resolvedConfig.base);
+      const serverConfig = resolveServerConfig(
+        resolvedConfig.root,
+        logger$1,
+        resolvedConfig.base
+      );
       config = {
-        root,
-        base
+        root: serverConfig.root,
+        base: normalizeBase(serverConfig.base)
       };
     },
-    configureServer: async ({ middlewares }) => {
+    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;
@@ -347,9 +597,9 @@ function viteFaasJsServer(options = {}) {
 
 exports.FuncWarper = FuncWarper;
 exports.createPgliteKnex = createPgliteKnex;
+exports.generateFaasTypes = generateFaasTypes;
+exports.isTypegenSourceFile = isTypegenSourceFile;
 exports.mountFaasKnex = mountFaasKnex;
-exports.runPgliteSql = runPgliteSql;
-exports.runPgliteSqlFile = runPgliteSqlFile;
 exports.streamToString = streamToString;
 exports.test = test;
 exports.unmountFaasKnex = unmountFaasKnex;

package/dist/index.d.ts

@@ -22,16 +22,6 @@ 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.
@@ -62,8 +52,7 @@ declare class FuncWarper {
     readonly plugins: Plugin[];
     private readonly _handler;
     /**
-     * @param file {string} Full file path
-     * @param func {Func} A FaasJs function
+     * @param initBy {Func} A FaasJS function
      * ```ts
      * import { FuncWarper } from '@faasjs/dev'
      *
@@ -114,18 +103,27 @@ declare class FuncWarper {
  */
 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;
+type GenerateFaasTypesOptions = {
+    /** faas project root path, default is process.cwd() */
+    root?: string;
+    /** optional logger instance */
+    logger?: Logger;
+};
+type GenerateFaasTypesResult = {
+    output: string;
+    changed: boolean;
+    fileCount: number;
+    routeCount: number;
 };
+declare function isTypegenSourceFile(filePath: string): boolean;
+declare function generateFaasTypes(options?: GenerateFaasTypesOptions): Promise<GenerateFaasTypesResult>;
+
 /**
  * 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`.
+ * It resolves server root/base from `src/faas.yaml` and strips `base` from
+ * request URL before forwarding to `@faasjs/server`.
  */
-declare function viteFaasJsServer(options?: Partial<ViteFaasJsServerOptions> & Record<string, unknown>): Plugin$1;
+declare function viteFaasJsServer(): Plugin$1;
 
-export { FuncWarper, type MountFaasKnexOptions, type ViteFaasJsServerOptions, createPgliteKnex, mountFaasKnex, runPgliteSql, runPgliteSqlFile, streamToString, test, unmountFaasKnex, viteFaasJsServer };
+export { FuncWarper, type GenerateFaasTypesOptions, type GenerateFaasTypesResult, type MountFaasKnexOptions, createPgliteKnex, generateFaasTypes, isTypegenSourceFile, mountFaasKnex, streamToString, test, unmountFaasKnex, viteFaasJsServer };