@faasjs/func 0.0.3-beta.86 → 0.0.3-beta.87

package/dist/index.d.mts

@@ -0,0 +1,156 @@
+import { Logger } from '@faasjs/logger';
+
+type Handler<TEvent = any, TContext = any, TResult = any> = (data: InvokeData<TEvent, TContext>) => Promise<TResult>;
+type Next = () => Promise<void>;
+type ExportedHandler<TEvent = any, TContext = any, TResult = any> = (event: TEvent, context?: TContext, callback?: (...args: any) => any) => Promise<TResult>;
+type Plugin = {
+    [key: string]: any;
+    readonly type: string;
+    readonly name: string;
+    onDeploy?: (data: DeployData, next: Next) => void | Promise<void>;
+    onMount?: (data: MountData, next: Next) => void | Promise<void>;
+    onInvoke?: (data: InvokeData, next: Next) => void | Promise<void>;
+};
+type ProviderConfig = {
+    type: string;
+    config: {
+        [key: string]: any;
+    };
+};
+type Config = {
+    [key: string]: any;
+    providers?: {
+        [key: string]: ProviderConfig;
+    };
+    plugins?: {
+        [key: string]: {
+            [key: string]: any;
+            provider?: string | ProviderConfig;
+            type: string;
+            config?: {
+                [key: string]: any;
+            };
+        };
+    };
+};
+type DeployData = {
+    [key: string]: any;
+    root: string;
+    filename: string;
+    env?: string;
+    name?: string;
+    config?: Config;
+    version?: string;
+    dependencies: {
+        [name: string]: string;
+    };
+    plugins?: {
+        [name: string]: {
+            [key: string]: any;
+            name?: string;
+            type: string;
+            provider?: string;
+            config: {
+                [key: string]: any;
+            };
+            plugin: Plugin;
+        };
+    };
+    logger?: Logger;
+};
+type MountData = {
+    [key: string]: any;
+    config: Config;
+    event: any;
+    context: any;
+};
+type InvokeData<TEvent = any, TContext = any, TResult = any> = {
+    [key: string]: any;
+    event: TEvent;
+    context: TContext;
+    callback: any;
+    response: any;
+    logger: Logger;
+    handler?: Handler<TEvent, TContext, TResult>;
+    config: Config;
+};
+type LifeCycleKey = 'onDeploy' | 'onMount' | 'onInvoke';
+type FuncConfig<TEvent = any, TContext = any, TResult = any> = {
+    plugins?: Plugin[];
+    handler?: Handler<TEvent, TContext, TResult>;
+};
+declare class Func<TEvent = any, TContext = any, TResult = any> {
+    [key: string]: any;
+    plugins: Plugin[];
+    handler?: Handler<TEvent, TContext, TResult>;
+    config: Config;
+    mounted: boolean;
+    filename?: string;
+    private cachedFunctions;
+    /**
+     * Create a cloud function
+     * @param config {object} config
+     * @param config.plugins {Plugin[]} plugins list
+     * @param config.handler {Handler} business logic
+     */
+    constructor(config: FuncConfig<TEvent, TContext>);
+    private compose;
+    /**
+     * Deploy the function
+     * @param data {object} data
+     * @param data.root {string} root path
+     * @param data.filename {string} filename
+     * @param data.env {string} environment
+     */
+    deploy(data: DeployData): any;
+    /**
+     * First time mount the function
+     */
+    mount(data: {
+        event: TEvent;
+        context: TContext;
+        config?: Config;
+        logger?: Logger;
+    }): Promise<void>;
+    /**
+     * Invoke the function
+     * @param data {object} data
+     */
+    invoke(data: InvokeData<TEvent, TContext, TResult>): Promise<void>;
+    /**
+     * Export the function
+     */
+    export(): {
+        handler: ExportedHandler<TEvent, TContext, TResult>;
+    };
+}
+type UseifyPlugin<T> = T & {
+    mount?: (data?: {
+        config?: Config;
+    }) => Promise<T>;
+};
+declare function usePlugin<T extends Plugin>(plugin: UseifyPlugin<T>): UseifyPlugin<T>;
+/**
+ * ```ts
+ * // pure function
+ * export default useFunc(() => {
+ *   return () => {
+ *     return 'Hello World'
+ *   }
+ * })
+ *
+ * // with http
+ * import { useHttp } from '@faasjs/http'
+ *
+ * export default useFunc(() => {
+ *   const http = useHttp<{ name: string }>()
+ *
+ *   return () => {
+ *     return `Hello ${http.params.name}`
+ *   }
+ * })
+ * ```
+ */
+declare function useFunc<TEvent = any, TContext = any, TResult = any>(handler: () => Handler<TEvent, TContext, TResult>): Func<TEvent, TContext, TResult>;
+
+export { Config, DeployData, ExportedHandler, Func, FuncConfig, Handler, InvokeData, LifeCycleKey, MountData, Next, Plugin, ProviderConfig, UseifyPlugin, useFunc, usePlugin };

package/dist/index.js

@@ -60,6 +60,12 @@ var RunHandler = class {
 // src/index.ts
 var import_crypto = require("crypto");
 var Func = class {
+  /**
+   * Create a cloud function
+   * @param config {object} config
+   * @param config.plugins {Plugin[]} plugins list
+   * @param config.handler {Handler} business logic
+   */
   constructor(config) {
     this.handler = config.handler;
     this.plugins = config.plugins || [];
@@ -120,6 +126,13 @@ var Func = class {
       return await dispatch(0);
     };
   }
+  /**
+   * Deploy the function
+   * @param data {object} data
+   * @param data.root {string} root path
+   * @param data.filename {string} filename
+   * @param data.env {string} environment
+   */
   deploy(data) {
     if (!data.logger)
       data.logger = new import_logger.Logger("Func");
@@ -127,6 +140,9 @@ var Func = class {
     data.logger.debug("Plugins: " + this.plugins.map((p) => `${p.type}#${p.name}`).join(","));
     return this.compose("onDeploy")(data);
   }
+  /**
+   * First time mount the function
+   */
   async mount(data) {
     if (!data.logger)
       data.logger = new import_logger.Logger("Func");
@@ -146,6 +162,10 @@ var Func = class {
       data.logger.timeEnd("mount", "mounted");
     }
   }
+  /**
+   * Invoke the function
+   * @param data {object} data
+   */
   async invoke(data) {
     if (!this.mounted)
       await this.mount({
@@ -161,6 +181,9 @@ var Func = class {
       data.response = error;
     }
   }
+  /**
+   * Export the function
+   */
   export() {
     const handler = async (event, context, callback) => {
       if (typeof context === "undefined")
@@ -168,7 +191,7 @@ var Func = class {
       if (!context.request_id)
         context.request_id = (0, import_crypto.randomBytes)(16).toString("hex");
       if (!context.request_at)
-        context.request_at = Math.round(new Date().getTime() / 1e3);
+        context.request_at = Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3);
       context.callbackWaitsForEmptyEventLoop = false;
       const logger = new import_logger.Logger(context.request_id);
       logger.debug("event: %j", event);

package/dist/index.mjs

@@ -34,6 +34,12 @@ var RunHandler = class {
 // src/index.ts
 import { randomBytes } from "crypto";
 var Func = class {
+  /**
+   * Create a cloud function
+   * @param config {object} config
+   * @param config.plugins {Plugin[]} plugins list
+   * @param config.handler {Handler} business logic
+   */
   constructor(config) {
     this.handler = config.handler;
     this.plugins = config.plugins || [];
@@ -94,6 +100,13 @@ var Func = class {
       return await dispatch(0);
     };
   }
+  /**
+   * Deploy the function
+   * @param data {object} data
+   * @param data.root {string} root path
+   * @param data.filename {string} filename
+   * @param data.env {string} environment
+   */
   deploy(data) {
     if (!data.logger)
       data.logger = new Logger("Func");
@@ -101,6 +114,9 @@ var Func = class {
     data.logger.debug("Plugins: " + this.plugins.map((p) => `${p.type}#${p.name}`).join(","));
     return this.compose("onDeploy")(data);
   }
+  /**
+   * First time mount the function
+   */
   async mount(data) {
     if (!data.logger)
       data.logger = new Logger("Func");
@@ -120,6 +136,10 @@ var Func = class {
       data.logger.timeEnd("mount", "mounted");
     }
   }
+  /**
+   * Invoke the function
+   * @param data {object} data
+   */
   async invoke(data) {
     if (!this.mounted)
       await this.mount({
@@ -135,6 +155,9 @@ var Func = class {
       data.response = error;
     }
   }
+  /**
+   * Export the function
+   */
   export() {
     const handler = async (event, context, callback) => {
       if (typeof context === "undefined")
@@ -142,7 +165,7 @@ var Func = class {
       if (!context.request_id)
         context.request_id = randomBytes(16).toString("hex");
       if (!context.request_at)
-        context.request_at = Math.round(new Date().getTime() / 1e3);
+        context.request_at = Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3);
       context.callbackWaitsForEmptyEventLoop = false;
       const logger = new Logger(context.request_id);
       logger.debug("event: %j", event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faasjs/func",
-  "version": "0.0.3-beta.86",
+  "version": "0.0.3-beta.87",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,14 +15,14 @@
   },
   "funding": "https://github.com/sponsors/faasjs",
   "scripts": {
-    "build": "tsup-node src/index.ts --format esm,cjs --dts --clean"
+    "build": "tsup-node src/index.ts --config ../../tsup.config.json"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@faasjs/deep_merge": "^0.0.3-beta.86",
-    "@faasjs/logger": "^0.0.3-beta.86"
+    "@faasjs/deep_merge": "^0.0.3-beta.87",
+    "@faasjs/logger": "^0.0.3-beta.87"
   },
   "engines": {
     "npm": ">=8.0.0",