@faasjs/dev 8.0.0-beta.10

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,141 @@
+# @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.
+- Test helpers to invoke and assert FaasJS functions.
+
+## Usage: Vite integration
+
+```ts
+import { viteFaasJsServer } from '@faasjs/dev'
+
+export default defineConfig({
+  plugins: [viteFaasJsServer()],
+})
+```
+
+## 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)
+- Test: [test](functions/test.md), [FuncWarper](classes/FuncWarper.md), [streamToText](functions/streamToText.md), [streamToObject](functions/streamToObject.md), [streamToString](variables/streamToString.md)
+
+## Functions
+
+- [closeAll](functions/closeAll.md)
+- [createCronJob](functions/createCronJob.md)
+- [createPgliteKnex](functions/createPgliteKnex.md)
+- [defineApi](functions/defineApi.md)
+- [generateFaasTypes](functions/generateFaasTypes.md)
+- [getAll](functions/getAll.md)
+- [initPostgresTypeParsers](functions/initPostgresTypeParsers.md)
+- [isTypegenSourceFile](functions/isTypegenSourceFile.md)
+- [listCronJobs](functions/listCronJobs.md)
+- [mountFaasKnex](functions/mountFaasKnex.md)
+- [nameFunc](functions/nameFunc.md)
+- [parseFuncFilenameFromStack](functions/parseFuncFilenameFromStack.md)
+- [query](functions/query.md)
+- [raw](functions/raw.md)
+- [removeCronJob](functions/removeCronJob.md)
+- [staticHandler](functions/staticHandler.md)
+- [streamToObject](functions/streamToObject.md)
+- [streamToText](functions/streamToText.md)
+- [test](functions/test.md)
+- [transaction](functions/transaction.md)
+- [unmountFaasKnex](functions/unmountFaasKnex.md)
+- [useFunc](functions/useFunc.md)
+- [useHttp](functions/useHttp.md)
+- [useKnex](functions/useKnex.md)
+- [useMiddleware](functions/useMiddleware.md)
+- [useMiddlewares](functions/useMiddlewares.md)
+- [usePlugin](functions/usePlugin.md)
+- [viteFaasJsServer](functions/viteFaasJsServer.md)
+
+## Classes
+
+- [Cookie](classes/Cookie.md)
+- [CronJob](classes/CronJob.md)
+- [Func](classes/Func.md)
+- [FuncWarper](classes/FuncWarper.md)
+- [Http](classes/Http.md)
+- [HttpError](classes/HttpError.md)
+- [Knex](classes/Knex.md)
+- [KnexSchema](classes/KnexSchema.md)
+- [Server](classes/Server.md)
+- [Session](classes/Session.md)
+
+## Interfaces
+
+- [FaasPluginEventMap](interfaces/FaasPluginEventMap.md)
+
+## Type Aliases
+
+- [Config](type-aliases/Config.md)
+- [CookieOptions](type-aliases/CookieOptions.md)
+- [CronJobContext](type-aliases/CronJobContext.md)
+- [CronJobErrorHandler](type-aliases/CronJobErrorHandler.md)
+- [CronJobHandler](type-aliases/CronJobHandler.md)
+- [CronJobOptions](type-aliases/CronJobOptions.md)
+- [DefineApiData](type-aliases/DefineApiData.md)
+- [DefineApiOptions](type-aliases/DefineApiOptions.md)
+- [ExportedHandler](type-aliases/ExportedHandler.md)
+- [FuncConfig](type-aliases/FuncConfig.md)
+- [FuncEventType](type-aliases/FuncEventType.md)
+- [FuncReturnType](type-aliases/FuncReturnType.md)
+- [GenerateFaasTypesOptions](type-aliases/GenerateFaasTypesOptions.md)
+- [GenerateFaasTypesResult](type-aliases/GenerateFaasTypesResult.md)
+- [Handler](type-aliases/Handler.md)
+- [HttpConfig](type-aliases/HttpConfig.md)
+- [InferPluginEvent](type-aliases/InferPluginEvent.md)
+- [InvokeData](type-aliases/InvokeData.md)
+- [KnexConfig](type-aliases/KnexConfig.md)
+- [LifeCycleKey](type-aliases/LifeCycleKey.md)
+- [Middleware](type-aliases/Middleware.md)
+- [MiddlewareContext](type-aliases/MiddlewareContext.md)
+- [MiddlewareEvent](type-aliases/MiddlewareEvent.md)
+- [MountData](type-aliases/MountData.md)
+- [MountedKnexAdapter](type-aliases/MountedKnexAdapter.md)
+- [MountFaasKnexOptions](type-aliases/MountFaasKnexOptions.md)
+- [Next](type-aliases/Next.md)
+- [NormalizePluginType](type-aliases/NormalizePluginType.md)
+- [Plugin](type-aliases/Plugin.md)
+- [ResolvePluginEvent](type-aliases/ResolvePluginEvent.md)
+- [Response](type-aliases/Response.md)
+- [ServerHandlerOptions](type-aliases/ServerHandlerOptions.md)
+- [ServerOptions](type-aliases/ServerOptions.md)
+- [SessionContent](type-aliases/SessionContent.md)
+- [SessionOptions](type-aliases/SessionOptions.md)
+- [Simplify](type-aliases/Simplify.md)
+- [StaticHandlerOptions](type-aliases/StaticHandlerOptions.md)
+- [UnionToIntersection](type-aliases/UnionToIntersection.md)
+- [UseifyPlugin](type-aliases/UseifyPlugin.md)
+
+## Variables
+
+- [ContentType](variables/ContentType.md)
+- [originKnex](variables/originKnex.md)
+- [streamToString](variables/streamToString.md)

package/configs/oxlint.base.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "typescript/no-explicit-any": "warn"
+  }
+}

package/dist/chunk-D8kEL_kv.mjs

@@ -0,0 +1,38 @@
+import { createRequire } from "node: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
+export { __reExport as n, __exportAll as t };

package/dist/cli/index.cjs

@@ -0,0 +1,292 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_typegen = require('../typegen-HX5QyuhP.cjs');
+let _faasjs_core = require("@faasjs/core");
+let _faasjs_node_utils = require("@faasjs/node-utils");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_child_process = require("node:child_process");
+let node_module = require("node:module");
+
+//#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();
+	(0, _faasjs_node_utils.loadEnvFileIfExists)({ cwd: envRoot });
+	const { root: projectRoot, staging } = require_typegen.resolveServerConfig(envRoot);
+	const srcRoot = (0, node_path.join)(projectRoot, "src");
+	const knex = (0, _faasjs_core.useKnex)({ config: (0, _faasjs_node_utils.loadConfig)(srcRoot, (0, node_path.join)(srcRoot, "index.func.ts"), staging).plugins?.knex?.config });
+	await knex.mount();
+	const schema = new _faasjs_core.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 = (0, node_module.createRequire)((0, node_path.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 = (0, node_path.dirname)(packageEntryPath);
+	let packageJsonPath = "";
+	while (true) {
+		const candidate = (0, node_path.join)(currentPath, "package.json");
+		if ((0, node_fs.existsSync)(candidate)) {
+			packageJsonPath = candidate;
+			break;
+		}
+		const parentPath = (0, node_path.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((0, node_fs.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 (0, node_path.resolve)((0, node_path.dirname)(packageJsonPath), bin);
+}
+function resolveSharedConfigPath(projectRoot, configFileName) {
+	const configPath = (0, node_path.resolve)((0, node_path.dirname)(resolvePackageJsonPath(projectRoot, "@faasjs/dev")), "configs", configFileName);
+	if (!(0, node_fs.existsSync)(configPath)) throw Error(`[faas lint] Missing shared config: ${configPath}`);
+	return configPath;
+}
+function runNodeBin(projectRoot, command, binPath, args) {
+	try {
+		(0, node_child_process.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();
+	(0, _faasjs_node_utils.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]}`);
+	(0, _faasjs_node_utils.loadEnvFileIfExists)({ cwd: options.root ?? process.cwd() });
+	const result = await require_typegen.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
+exports.main = main;
+exports.run = run;

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+//#region src/cli/index.d.ts
+declare function run(args: string[]): Promise<number>;
+declare const main: (argv?: string[]) => Promise<number>;
+//#endregion
+export { main, run };