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

package/README.md

@@ -46,21 +46,43 @@ expect(response.data).toEqual({ message: 'Hello, FaasJS' })
 
 ## Functions
 
+- [closeAll](functions/closeAll.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)
+- [mountFaasKnex](functions/mountFaasKnex.md)
 - [nameFunc](functions/nameFunc.md)
 - [parseFuncFilenameFromStack](functions/parseFuncFilenameFromStack.md)
+- [query](functions/query.md)
+- [raw](functions/raw.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)
 - [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
 
@@ -69,6 +91,9 @@ expect(response.data).toEqual({ message: 'Hello, FaasJS' })
 ## Type Aliases
 
 - [Config](type-aliases/Config.md)
+- [CookieOptions](type-aliases/CookieOptions.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)
@@ -76,18 +101,33 @@ expect(response.data).toEqual({ message: 'Hello, FaasJS' })
 - [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/oxfmt.base.json

@@ -0,0 +1,16 @@
+{
+  "singleQuote": true,
+  "jsxSingleQuote": true,
+  "semi": false,
+  "ignorePatterns": [
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/.vercel/**",
+    "**/.nuxt/**",
+    "**/.output/**",
+    "**/.vuepress/**",
+    "**/.vitepress/**",
+    "**/.turbo/**"
+  ]
+}

package/configs/oxlint.base.json

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

package/dist/{chunk-CtajNgzt.mjs → chunk-D8kEL_kv.mjs}

@@ -1,3 +1,5 @@
+import { createRequire } from "node:module";
+
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

package/dist/cli/index.cjs

@@ -0,0 +1,297 @@
+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.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 } = require_typegen.resolveServerConfig(parsed.options.root ?? process.cwd());
+	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();
+	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 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 };