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

package/dist/cli/index.mjs

@@ -0,0 +1,295 @@
+import { r as resolveServerConfig, t as generateFaasTypes } from "../typegen-BNWmP5Qp.mjs";
+import { createRequire } from "node:module";
+import { KnexSchema, useKnex } from "@faasjs/core";
+import { loadConfig } from "@faasjs/node-utils";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+
+//#region package.json
+var version = "8.0.0-beta.8";
+
+//#endregion
+//#region src/cli/shared.ts
+function parseCommonCliArgs(args, scope) {
+	const options = {};
+	const rest = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-h" || arg === "--help") return {
+			mode: "help",
+			options,
+			rest
+		};
+		if (arg === "-v" || arg === "--version") return {
+			mode: "version",
+			options,
+			rest
+		};
+		if (arg === "--root") {
+			const value = args[i + 1];
+			if (!value || value.startsWith("-")) throw Error(`[${scope}] Missing value for ${arg}`);
+			options.root = value;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith("-")) throw Error(`[${scope}] Unknown option: ${arg}`);
+		rest.push(arg);
+	}
+	return {
+		mode: "run",
+		options,
+		rest
+	};
+}
+function printVersion() {
+	console.log(version);
+	return 0;
+}
+async function runCli(handler) {
+	try {
+		return await handler();
+	} catch (error) {
+		console.error(error?.message || error);
+		return 1;
+	}
+}
+function createMain(run) {
+	return async (argv = process.argv) => runCli(() => run(argv.slice(2)));
+}
+
+//#endregion
+//#region src/cli/knex.ts
+const MigrateActions = [
+	"latest",
+	"rollback",
+	"status",
+	"current",
+	"make"
+];
+function isMigrateAction(value) {
+	return MigrateActions.includes(value);
+}
+const ActionHandlers = {
+	latest: (schema) => schema.migrateLatest(),
+	rollback: (schema) => schema.migrateRollback(),
+	status: async (schema) => {
+		console.log(await schema.migrateStatus());
+	},
+	current: async (schema) => {
+		console.log(await schema.migrateCurrentVersion());
+	}
+};
+const HelpText$3 = `Run FaasJS knex migrations.
+
+Usage:
+  faas knex <action> [name] [options]
+
+Actions:
+  latest             Run all pending migrations
+  rollback           Roll back the last migration batch
+  status             Print pending migration count
+  current            Print current migration version
+  make <name>        Create a new migration file
+
+Options:
+  --root <path>      Project root path (default: process.cwd())
+  -h, --help         Show help
+  -v, --version      Show version
+`;
+function parseCliArgs(args) {
+	const { mode, options, rest } = parseCommonCliArgs(args, "faas knex");
+	if (mode !== "run") return {
+		mode,
+		options
+	};
+	const [action, name, extra] = rest;
+	if (!action) throw Error("[faas knex] Missing action. Usage: faas knex <latest|rollback|status|current|make>");
+	if (!isMigrateAction(action)) throw Error(`[faas knex] Unknown action: ${action}`);
+	if (action !== "make") {
+		if (name) throw Error(`[faas knex] Unexpected argument: ${name}`);
+		return {
+			mode: "run",
+			action,
+			options
+		};
+	}
+	if (!name) throw Error("[faas knex] Missing migration name. Usage: faas knex make create_users");
+	if (extra) throw Error(`[faas knex] Unexpected argument: ${extra}`);
+	return {
+		mode: "run",
+		action: "make",
+		name,
+		options
+	};
+}
+async function run$3(args) {
+	const parsed = parseCliArgs(args);
+	if (parsed.mode === "help") {
+		console.log(HelpText$3);
+		return 0;
+	}
+	if (parsed.mode === "version") return printVersion();
+	const { root: projectRoot, staging } = resolveServerConfig(parsed.options.root ?? process.cwd());
+	const srcRoot = join(projectRoot, "src");
+	const knex = useKnex({ config: loadConfig(srcRoot, join(srcRoot, "index.func.ts"), staging).plugins?.knex?.config });
+	await knex.mount();
+	const schema = new KnexSchema(knex);
+	try {
+		if (parsed.action === "make") console.log(await schema.migrateMake(parsed.name));
+		else await ActionHandlers[parsed.action](schema);
+	} finally {
+		await knex.quit();
+	}
+	return 0;
+}
+const main$3 = createMain(run$3);
+
+//#endregion
+//#region src/cli/lint.ts
+const HelpText$2 = `Run formatter and lint checks with Oxc shared configs.
+
+Usage:
+  faas lint [options]
+
+Options:
+  --root <path>      Project root path (default: process.cwd())
+  -h, --help         Show help
+  -v, --version      Show version
+`;
+function resolvePackageJsonPath(projectRoot, packageName) {
+	const requireFromProject = createRequire(resolve(projectRoot, "package.json"));
+	let packageEntryPath = "";
+	try {
+		packageEntryPath = requireFromProject.resolve(packageName);
+	} catch {
+		throw Error(`[faas lint] Missing dependency: ${packageName}. Please install ${packageName} in your project.`);
+	}
+	let currentPath = dirname(packageEntryPath);
+	let packageJsonPath = "";
+	while (true) {
+		const candidate = join(currentPath, "package.json");
+		if (existsSync(candidate)) {
+			packageJsonPath = candidate;
+			break;
+		}
+		const parentPath = dirname(currentPath);
+		if (parentPath === currentPath) break;
+		currentPath = parentPath;
+	}
+	if (!packageJsonPath) throw Error(`[faas lint] Invalid dependency: Cannot find package.json for ${packageName}.`);
+	return packageJsonPath;
+}
+function resolveBinPath(projectRoot, packageName, binName) {
+	const packageJsonPath = resolvePackageJsonPath(projectRoot, packageName);
+	const packageJSON = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	const bin = typeof packageJSON.bin === "string" ? packageJSON.bin : packageJSON.bin?.[binName];
+	if (!bin) throw Error(`[faas lint] Invalid dependency: ${packageName} does not expose "${binName}" bin.`);
+	return resolve(dirname(packageJsonPath), bin);
+}
+function resolveSharedConfigPath(projectRoot, configFileName) {
+	const configPath = resolve(dirname(resolvePackageJsonPath(projectRoot, "@faasjs/dev")), "configs", configFileName);
+	if (!existsSync(configPath)) throw Error(`[faas lint] Missing shared config: ${configPath}`);
+	return configPath;
+}
+function runNodeBin(projectRoot, command, binPath, args) {
+	try {
+		execFileSync(process.execPath, [binPath, ...args], {
+			cwd: projectRoot,
+			stdio: "inherit"
+		});
+	} catch {
+		throw Error(`[faas lint] ${command} failed`);
+	}
+}
+async function run$2(args) {
+	const { mode, options, rest } = parseCommonCliArgs(args, "faas lint");
+	if (mode === "help") {
+		console.log(HelpText$2);
+		return 0;
+	}
+	if (mode === "version") return printVersion();
+	if (rest.length) throw Error(`[faas lint] Unexpected argument: ${rest[0]}`);
+	const projectRoot = options.root ?? process.cwd();
+	const oxfmtBinPath = resolveBinPath(projectRoot, "oxfmt", "oxfmt");
+	const oxlintBinPath = resolveBinPath(projectRoot, "oxlint", "oxlint");
+	const oxfmtConfigPath = resolveSharedConfigPath(projectRoot, "oxfmt.base.json");
+	const oxlintConfigPath = resolveSharedConfigPath(projectRoot, "oxlint.base.json");
+	runNodeBin(projectRoot, "oxfmt", oxfmtBinPath, [
+		"-c",
+		oxfmtConfigPath,
+		"."
+	]);
+	runNodeBin(projectRoot, "oxlint", oxlintBinPath, [
+		"-c",
+		oxlintConfigPath,
+		"--fix",
+		"."
+	]);
+	console.log("[faas lint] Done");
+	return 0;
+}
+const main$2 = createMain(run$2);
+
+//#endregion
+//#region src/cli/types.ts
+const HelpText$1 = `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
+`;
+async function run$1(args) {
+	const { mode, options, rest } = parseCommonCliArgs(args, "faas types");
+	if (mode === "help") {
+		console.log(HelpText$1);
+		return 0;
+	}
+	if (mode === "version") return printVersion();
+	if (rest.length) throw Error(`[faas types] Unknown option: ${rest[0]}`);
+	const result = await generateFaasTypes(options);
+	console.log(`[faas types] ${result.changed ? "Generated" : "Up to date"} ${result.output} (${result.routeCount} routes from ${result.fileCount} files)`);
+	return 0;
+}
+const main$1 = createMain(run$1);
+
+//#endregion
+//#region src/cli/index.ts
+const HelpText = `FaasJS CLI.
+
+Usage:
+  faas <command> [...args]
+
+Commands:
+  types [options]                 Generate FaasJS API/event type declarations
+  knex <action> [name] [options]  Run FaasJS knex migrations
+  lint [options]                  Run formatter and lint with Oxc
+
+Options:
+  -h, --help                      Show help
+  -v, --version                   Show version
+`;
+const Commands = {
+	types: run$1,
+	knex: run$3,
+	lint: run$2
+};
+async function run(args) {
+	const command = args[0];
+	if (!command || command === "-h" || command === "--help") {
+		console.log(HelpText);
+		return 0;
+	}
+	if (command === "-v" || command === "--version") return printVersion();
+	const handler = Commands[command];
+	if (!handler) throw Error(`[faas] Unknown command: ${command}`);
+	return await handler(args.slice(1));
+}
+const main = createMain(run);
+
+//#endregion
+export { main, run };

package/dist/index.cjs

@@ -34,13 +34,11 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
 //#endregion
-const require_typegen = require('./typegen-C6t9LIyi.cjs');
+const require_typegen = require('./typegen-HX5QyuhP.cjs');
 let node_zlib = require("node:zlib");
-let _faasjs_http = require("@faasjs/http");
-let _faasjs_logger = require("@faasjs/logger");
+let _faasjs_core = require("@faasjs/core");
 let _faasjs_node_utils = require("@faasjs/node-utils");
 let node_path = require("node:path");
-let _faasjs_server = require("@faasjs/server");
 
 //#region src/test.ts
 /**
@@ -73,7 +71,7 @@ var FuncWarper = class {
 	*/
 	constructor(initBy) {
 		this.staging = process.env.FaasEnv ?? "default";
-		this.logger = new _faasjs_logger.Logger("TestCase");
+		this.logger = new _faasjs_node_utils.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 || "";
@@ -104,7 +102,7 @@ var FuncWarper = class {
 	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 (this.http && this.http instanceof _faasjs_core.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]);
@@ -223,20 +221,20 @@ function stripBase(url, base) {
 * 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`.
+* request URL before forwarding to `@faasjs/core`.
 */
 function viteFaasJsServer() {
 	let config;
 	let server = null;
-	const logger = new _faasjs_logger.Logger("FaasJs:Vite");
+	const logger = new _faasjs_node_utils.Logger("FaasJs:Vite");
 	return {
 		name: "vite:faasjs",
 		enforce: "pre",
 		configResolved(resolvedConfig) {
-			const serverConfig = require_typegen.resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
+			const { root, base } = require_typegen.resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
 			config = {
-				root: serverConfig.root,
-				base: normalizeBase(serverConfig.base)
+				root,
+				base: normalizeBase(base)
 			};
 		},
 		configureServer: async ({ middlewares, watcher }) => {
@@ -245,34 +243,21 @@ function viteFaasJsServer() {
 				return;
 			}
 			if (!config) throw new Error("viteFaasJsServer: config is not resolved");
-			server = new _faasjs_server.Server((0, node_path.join)(config.root, "src"));
+			server = new _faasjs_core.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);
+					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();
+					logger.error("[faas types] %s", error.message);
 				}
 			};
+			let timer;
+			let typegenChain = Promise.resolve();
 			const scheduleTypegen = () => {
-				pendingTypegen = true;
 				if (timer) clearTimeout(timer);
 				timer = setTimeout(() => {
-					flushTypegen();
+					typegenChain = typegenChain.then(runTypegen);
 				}, TYPEGEN_DEBOUNCE);
 			};
 			await runTypegen();
@@ -325,10 +310,9 @@ exports.streamToString = _faasjs_node_utils.streamToString;
 exports.streamToText = _faasjs_node_utils.streamToText;
 exports.test = test;
 exports.viteFaasJsServer = viteFaasJsServer;
-var _faasjs_func = require("@faasjs/func");
-Object.keys(_faasjs_func).forEach(function (k) {
+Object.keys(_faasjs_core).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return _faasjs_func[k]; }
+    get: function () { return _faasjs_core[k]; }
   });
 });

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-import { n as __reExport, t as __exportAll } from "./chunk-CtajNgzt.mjs";
-import { Logger } from "@faasjs/logger";
-import { streamToObject, streamToString, streamToText } from "@faasjs/node-utils";
-import { Config, Func, Plugin } from "@faasjs/func";
+import { n as __reExport, t as __exportAll } from "./chunk-D8kEL_kv.mjs";
+import { Config, Func, Plugin } from "@faasjs/core";
+import { Logger, streamToObject, streamToString, streamToText } from "@faasjs/node-utils";
 import { Plugin as Plugin$1 } from "vite";
-export * from "@faasjs/func";
+export * from "@faasjs/core";
 
 //#region src/test.d.ts
 /**
@@ -96,7 +95,7 @@ declare function generateFaasTypes(options?: GenerateFaasTypesOptions): Promise<
  * 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`.
+ * request URL before forwarding to `@faasjs/core`.
  */
 declare function viteFaasJsServer(): Plugin$1;
 declare namespace index_d_exports {

package/dist/index.mjs

@@ -1,13 +1,11 @@
-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 { n as __reExport, t as __exportAll } from "./chunk-D8kEL_kv.mjs";
+import { n as isTypegenSourceFile, r as resolveServerConfig, t as generateFaasTypes } from "./typegen-BNWmP5Qp.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 { Http, Server } from "@faasjs/core";
+import { Logger, deepMerge, loadConfig, streamToObject, streamToString, streamToText } from "@faasjs/node-utils";
 import { join } from "node:path";
-import { Server } from "@faasjs/server";
 
-export * from "@faasjs/func"
+export * from "@faasjs/core"
 
 //#region src/test.ts
 /**
@@ -190,7 +188,7 @@ function stripBase(url, base) {
 * 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`.
+* request URL before forwarding to `@faasjs/core`.
 */
 function viteFaasJsServer() {
 	let config;
@@ -200,10 +198,10 @@ function viteFaasJsServer() {
 		name: "vite:faasjs",
 		enforce: "pre",
 		configResolved(resolvedConfig) {
-			const serverConfig = resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
+			const { root, base } = resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
 			config = {
-				root: serverConfig.root,
-				base: normalizeBase(serverConfig.base)
+				root,
+				base: normalizeBase(base)
 			};
 		},
 		configureServer: async ({ middlewares, watcher }) => {
@@ -216,30 +214,17 @@ function viteFaasJsServer() {
 			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);
+					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();
+					logger.error("[faas types] %s", error.message);
 				}
 			};
+			let timer;
+			let typegenChain = Promise.resolve();
 			const scheduleTypegen = () => {
-				pendingTypegen = true;
 				if (timer) clearTimeout(timer);
 				timer = setTimeout(() => {
-					flushTypegen();
+					typegenChain = typegenChain.then(runTypegen);
 				}, TYPEGEN_DEBOUNCE);
 			};
 			await runTypegen();

package/dist/{typegen-D5s91_xL.mjs → typegen-BNWmP5Qp.mjs}

@@ -1,5 +1,4 @@
-import { Logger } from "@faasjs/logger";
-import { loadConfig } from "@faasjs/node-utils";
+import { Logger, loadConfig } from "@faasjs/node-utils";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
@@ -15,24 +14,24 @@ function resolveServerConfig(root, logger, defaultBase = "/") {
 	const config = loadConfig(srcRoot, join(srcRoot, "index.func.ts"), staging, logger);
 	const server = config && typeof config === "object" ? config.server : void 0;
 	return {
-		root: server && typeof server.root === "string" && server.root.length ? resolve(projectRoot, server.root) : projectRoot,
-		base: server && typeof server.base === "string" && server.base.length ? server.base : defaultBase,
+		root: typeof server?.root === "string" && server.root.length ? resolve(projectRoot, server.root) : projectRoot,
+		base: typeof server?.base === "string" && server.base.length ? server.base : defaultBase,
 		staging
 	};
 }
 
 //#endregion
 //#region src/typegen.ts
-function normalizeSlashes(path) {
-	return path.replace(/\\/g, "/");
-}
 function normalizeRoute(path) {
-	const normalized = path.replace(/\/+/g, "/");
+	const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
 	if (!normalized.length || normalized === "/") return "/";
 	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
 }
+function toTypegenRoute(route) {
+	return route === "/" ? "/" : route.replace(/^\/+/, "");
+}
 function toRoute(srcRoot, file) {
-	const noTsPath = normalizeSlashes(relative(srcRoot, file)).replace(/\.ts$/, "");
+	const noTsPath = relative(srcRoot, file).replace(/\\/g, "/").replace(/\.ts$/, "");
 	if (noTsPath === "index.func") return {
 		route: "/",
 		priority: 2
@@ -53,10 +52,10 @@ function toRoute(srcRoot, file) {
 		route: normalizeRoute(`/${noTsPath.slice(0, -5)}`),
 		priority: 3
 	};
-	throw Error(`[faas-types] Invalid func filename: ${file}`);
+	throw Error(`[faas types] Invalid func filename: ${file}`);
 }
 function toImportPath(fromFile, targetFile) {
-	const importPath = normalizeSlashes(relative(dirname(fromFile), targetFile)).replace(/\.ts$/, "");
+	const importPath = relative(dirname(fromFile), targetFile).replace(/\\/g, "/").replace(/\.ts$/, "");
 	if (importPath.startsWith(".")) return importPath;
 	return `./${importPath}`;
 }
@@ -81,35 +80,36 @@ function parsePluginTypes(config) {
 }
 async function readFuncFiles(dir) {
 	const result = [];
-	async function walk(currentDir) {
+	const pendingDirs = [dir];
+	while (pendingDirs.length) {
+		const currentDir = pendingDirs.pop();
 		const entries = await readdir(currentDir, { withFileTypes: true });
 		for (const entry of entries) {
 			if (entry.name === ".faasjs" || entry.name === "node_modules") continue;
 			const filePath = join(currentDir, entry.name);
 			if (entry.isDirectory()) {
-				await walk(filePath);
+				pendingDirs.push(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)}: InferFaasAction<InferFaasFunc<typeof import(${JSON.stringify(item.importPath)})>>`;
+		return `    ${JSON.stringify(toTypegenRoute(item.route))}: InferFaasAction<InferFaasFunc<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 `    ${JSON.stringify(toTypegenRoute(item.route))}: InferPluginEvent<${plugins}>`;
 	});
 	return `/**
  * Generated by @faasjs/dev.
  *
  * Do not edit this file manually.
  */
-import type { Func, InferPluginEvent } from '@faasjs/func'
+import type { Func, InferPluginEvent } from '@faasjs/core'
 import type { InferFaasAction, InferFaasFunc } from '@faasjs/types'
 
 declare module '@faasjs/types' {
@@ -122,25 +122,24 @@ ${eventLines.length ? `${eventLines.join("\n")}\n` : ""}  }
 `;
 }
 function isTypegenSourceFile(filePath) {
-	return /\.func\.ts$/.test(filePath) || /(^|[\\/])faas\.ya?ml$/.test(filePath);
+	return filePath.endsWith(".func.ts") || /(^|[\\/])faas\.ya?ml$/.test(filePath);
 }
 async function generateFaasTypes(options = {}) {
-	const logger = options.logger || new Logger("FaasJs:Typegen");
-	const { root: projectRoot, staging } = resolveServerConfig(options.root || process.cwd(), logger);
+	const logger = options.logger ?? new Logger("FaasJs:Typegen");
+	const { root: projectRoot, staging } = resolveServerConfig(options.root ?? process.cwd(), logger);
 	const srcRoot = join(projectRoot, "src");
 	const output = join(srcRoot, ".faasjs", "types.d.ts");
-	if (!existsSync(srcRoot)) throw Error(`[faas-types] Source directory not found: ${srcRoot}`);
+	if (!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 pluginTypes = parsePluginTypes(loadConfig(srcRoot, file, staging, logger));
-		const importPath = toImportPath(output, file);
 		const prev = routeMap.get(route);
-		if (!prev || priority > prev.priority) routeMap.set(route, {
+		if (prev && priority <= prev.priority) continue;
+		routeMap.set(route, {
 			route,
-			importPath,
-			pluginTypes,
+			importPath: toImportPath(output, file),
+			pluginTypes: parsePluginTypes(loadConfig(srcRoot, file, staging, logger)),
 			priority
 		});
 	}
@@ -149,7 +148,7 @@ async function generateFaasTypes(options = {}) {
 	let changed = true;
 	try {
 		if (await readFile(output, "utf8") === content) changed = false;
-	} catch (_error) {}
+	} catch {}
 	if (changed) {
 		await mkdir(dirname(output), { recursive: true });
 		await writeFile(output, content);