@faasjs/dev 8.0.0-beta.10

package/dist/cli/index.mjs

@@ -0,0 +1,290 @@
+import { r as resolveServerConfig, t as generateFaasTypes } from "../typegen-BNWmP5Qp.mjs";
+import { createRequire } from "node:module";
+import { KnexSchema, useKnex } from "@faasjs/core";
+import { loadConfig, loadEnvFileIfExists } 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.9";
+
+//#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 envRoot = parsed.options.root ?? process.cwd();
+	loadEnvFileIfExists({ cwd: envRoot });
+	const { root: projectRoot, staging } = resolveServerConfig(envRoot);
+	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();
+	loadEnvFileIfExists({ cwd: projectRoot });
+	runNodeBin(projectRoot, "oxlint", resolveBinPath(projectRoot, "oxlint", "oxlint"), [
+		"-c",
+		resolveSharedConfigPath(projectRoot, "oxlint.base.json"),
+		"--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]}`);
+	loadEnvFileIfExists({ cwd: options.root ?? process.cwd() });
+	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

@@ -0,0 +1,318 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+//#endregion
+const require_typegen = require('./typegen-HX5QyuhP.cjs');
+let node_zlib = require("node:zlib");
+let _faasjs_core = require("@faasjs/core");
+let _faasjs_node_utils = require("@faasjs/node-utils");
+let node_path = require("node:path");
+
+//#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 ?? "default";
+		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 || "";
+		this.config = this.func.config;
+		this.plugins = this.func.plugins || [];
+		for (const plugin of this.plugins) {
+			if ([
+				"handler",
+				"config",
+				"plugins",
+				"logger",
+				"mount"
+			].includes(plugin.type)) continue;
+			this[plugin.type] = plugin;
+		}
+		this._handler = this.func.export().handler;
+	}
+	async mount(handler) {
+		if (!this.func.mounted) await this.func.mount();
+		if (handler) await handler(this);
+	}
+	async handler(event = Object.create(null), context = Object.create(null)) {
+		await this.mount();
+		const response = await this._handler(event, context);
+		this.logger.debug("response: %j", response);
+		return response;
+	}
+	async JSONhandler(body, options = Object.create(null)) {
+		await this.mount();
+		const headers = options.headers || Object.create(null);
+		if (this.http && this.http instanceof _faasjs_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]);
+				this.http.session.update();
+			}
+			const cookie = this.http.cookie.headers()["Set-Cookie"]?.map((c) => c.split(";")[0]).join(";");
+			if (cookie) if (headers.cookie) headers.cookie += `;${cookie}`;
+			else headers.cookie = cookie;
+		}
+		const response = await this._handler({
+			httpMethod: "POST",
+			headers: Object.assign({ "content-type": "application/json" }, headers),
+			body: typeof body === "string" ? body : JSON.stringify(body)
+		});
+		if (response?.body instanceof ReadableStream) {
+			let stream = response.body;
+			const encoding = response.headers?.["Content-Encoding"] || response.headers?.["content-encoding"];
+			if (encoding) {
+				const chunks = [];
+				const reader = stream.getReader();
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value) chunks.push(value);
+					}
+				} catch (error) {
+					this.logger.error("Failed to read ReadableStream: %s", error);
+					response.body = JSON.stringify({ error: { message: error.message } });
+					response.error = { message: error.message };
+					response.statusCode = 500;
+					reader.releaseLock();
+					return response;
+				}
+				reader.releaseLock();
+				const compressedBuffer = Buffer.concat(chunks);
+				try {
+					let decompressed;
+					if (encoding === "br") decompressed = (0, node_zlib.brotliDecompressSync)(compressedBuffer);
+					else if (encoding === "gzip") decompressed = (0, node_zlib.gunzipSync)(compressedBuffer);
+					else if (encoding === "deflate") decompressed = (0, node_zlib.inflateSync)(compressedBuffer);
+					else throw new Error(`Unsupported encoding: ${encoding}`);
+					stream = new ReadableStream({ start(controller) {
+						controller.enqueue(new Uint8Array(decompressed));
+						controller.close();
+					} });
+				} catch (error) {
+					this.logger.error("Failed to decompress: %s", error);
+					response.body = JSON.stringify({ error: { message: error.message } });
+					response.error = { message: error.message };
+					response.statusCode = 500;
+					return response;
+				}
+			}
+			try {
+				response.body = await (0, _faasjs_node_utils.streamToText)(stream);
+			} catch (error) {
+				this.logger.error("Failed to decode ReadableStream: %s", error);
+				response.body = JSON.stringify({ error: { message: error.message } });
+				response.error = { message: error.message };
+				response.statusCode = 500;
+			}
+		}
+		if (response?.headers && response.body && response.headers["content-type"]?.includes("json")) {
+			const parsedBody = JSON.parse(response.body);
+			response.data = parsedBody.data;
+			response.error = parsedBody.error;
+		}
+		if (this.http) {
+			response.cookie = this.http.cookie.content;
+			response.session = this.http.session.content;
+		}
+		this.logger.debug("response: %j", response);
+		return response;
+	}
+};
+/**
+* A simple way to wrap a FaasJS function.
+* @param initBy {Func} Full file path or a FaasJs function
+*
+* ```ts
+* import { test } from '@faasjs/dev'
+* import Func from '../demo.func.ts'
+*
+* const func = test(Func)
+*
+* expect(await func.handler()).toEqual('Hello, world')
+* ```
+*/
+function test(initBy) {
+	const warper = new FuncWarper(initBy);
+	warper.mount = warper.mount.bind(warper);
+	warper.handler = warper.handler.bind(warper);
+	warper.JSONhandler = warper.JSONhandler.bind(warper);
+	return warper;
+}
+
+//#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;
+}
+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;
+}
+/**
+* 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/core`.
+*/
+function viteFaasJsServer() {
+	let config;
+	let server = null;
+	const logger = new _faasjs_node_utils.Logger("FaasJs:Vite");
+	return {
+		name: "vite:faasjs",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			const { root, base } = require_typegen.resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
+			config = {
+				root,
+				base: normalizeBase(base)
+			};
+		},
+		configureServer: async ({ middlewares, watcher }) => {
+			if (process.env.VITEST) {
+				logger.debug("Skipping faas server in vitest environment");
+				return;
+			}
+			if (!config) throw new Error("viteFaasJsServer: config is not resolved");
+			server = new _faasjs_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);
+				} catch (error) {
+					logger.error("[faas types] %s", error.message);
+				}
+			};
+			let timer;
+			let typegenChain = Promise.resolve();
+			const scheduleTypegen = () => {
+				if (timer) clearTimeout(timer);
+				timer = setTimeout(() => {
+					typegenChain = typegenChain.then(runTypegen);
+				}, TYPEGEN_DEBOUNCE);
+			};
+			await runTypegen();
+			watcher.on("all", (_eventName, filePath) => {
+				if (!require_typegen.isTypegenSourceFile(filePath)) return;
+				scheduleTypegen();
+			});
+			middlewares.use(async (req, res, next) => {
+				if (!req.url || req.method !== "POST" || !server) return next();
+				const originalUrl = req.url;
+				req.url = stripBase(req.url, config.base);
+				try {
+					logger.debug(`Request ${req.url}`);
+					await server.handle(req, res, { requestedAt: Date.now() });
+				} catch (error) {
+					logger.error(error);
+					if (!res.headersSent && !res.writableEnded) {
+						res.writeHead(500, { "Content-Type": "application/json" });
+						res.write(JSON.stringify({ error: { message: "Internal Server Error" } }));
+						res.end();
+					}
+				} finally {
+					req.url = originalUrl;
+				}
+				if (!res.writableEnded) next();
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	FuncWarper: () => FuncWarper,
+	generateFaasTypes: () => require_typegen.generateFaasTypes,
+	isTypegenSourceFile: () => require_typegen.isTypegenSourceFile,
+	streamToObject: () => _faasjs_node_utils.streamToObject,
+	streamToString: () => _faasjs_node_utils.streamToString,
+	streamToText: () => _faasjs_node_utils.streamToText,
+	test: () => test,
+	viteFaasJsServer: () => viteFaasJsServer
+});
+
+//#endregion
+exports.FuncWarper = FuncWarper;
+exports.generateFaasTypes = require_typegen.generateFaasTypes;
+exports.isTypegenSourceFile = require_typegen.isTypegenSourceFile;
+exports.streamToObject = _faasjs_node_utils.streamToObject;
+exports.streamToString = _faasjs_node_utils.streamToString;
+exports.streamToText = _faasjs_node_utils.streamToText;
+exports.test = test;
+exports.viteFaasJsServer = viteFaasJsServer;
+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_core[k]; }
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+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/core";
+
+//#region src/test.d.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')
+ * ```
+ */
+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 initBy {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?: Record<string, any> | string | null, 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;
+//#endregion
+//#region src/typegen.d.ts
+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>;
+//#endregion
+//#region src/vite.d.ts
+/**
+ * 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/core`.
+ */
+declare function viteFaasJsServer(): Plugin$1;
+declare namespace index_d_exports {
+  export { FuncWarper, GenerateFaasTypesOptions, GenerateFaasTypesResult, generateFaasTypes, isTypegenSourceFile, streamToObject, streamToString, streamToText, test, viteFaasJsServer };
+}
+//#endregion
+export { FuncWarper, GenerateFaasTypesOptions, GenerateFaasTypesResult, generateFaasTypes, isTypegenSourceFile, streamToObject, streamToString, streamToText, test, viteFaasJsServer };