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

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

@@ -1,31 +1,9 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
+
+var logger = require('@faasjs/logger');
+var crypto = require('crypto');
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Func: () => Func,
-  useFunc: () => useFunc,
-  usePlugin: () => usePlugin
-});
-module.exports = __toCommonJS(src_exports);
-var import_logger = require("@faasjs/logger");
 
 // src/plugins/run_handler/index.ts
 var RunHandler = class {
@@ -56,10 +34,13 @@ var RunHandler = class {
     await next();
   }
 };
-
-// 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 || [];
@@ -73,7 +54,7 @@ var Func = class {
     try {
       this.filename = new Error().stack.split("\n").find((s) => /[^/]\.func\.ts/.test(s)).match(/\((.*\.func\.ts).*\)/)[1];
     } catch (error) {
-      new import_logger.Logger("Func").warn(error.message);
+      new logger.Logger("Func").warn(error.message);
     }
   }
   compose(key) {
@@ -93,7 +74,7 @@ var Func = class {
     }
     return async function(data, next) {
       let index = -1;
-      const logger = (data == null ? void 0 : data.logger) || new import_logger.Logger();
+      const logger$1 = (data == null ? void 0 : data.logger) || new logger.Logger();
       const dispatch = async function(i) {
         if (i <= index)
           return Promise.reject(Error("next() called multiple times"));
@@ -105,31 +86,41 @@ var Func = class {
           return Promise.resolve();
         if (typeof fn.key === "undefined")
           fn.key = `UnNamedPlugin#${i}`;
-        logger.debug("[%s][%s] begin", fn.key, key);
-        logger.time(fn.key);
+        logger$1.debug("[%s][%s] begin", fn.key, key);
+        logger$1.time(fn.key);
         try {
           const res = await Promise.resolve(fn.handler(data, dispatch.bind(null, i + 1)));
-          logger.timeEnd(fn.key, "[%s][%s] end", fn.key, key);
+          logger$1.timeEnd(fn.key, "[%s][%s] end", fn.key, key);
           return res;
         } catch (err) {
-          logger.timeEnd(fn.key, "[%s][%s] failed", fn.key, key);
-          logger.error(err);
+          logger$1.timeEnd(fn.key, "[%s][%s] failed", fn.key, key);
+          logger$1.error(err);
           return Promise.reject(err);
         }
       };
       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");
+      data.logger = new logger.Logger("Func");
     data.logger.debug("onDeploy");
     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");
+      data.logger = new logger.Logger("Func");
     data.logger.debug("onMount");
     if (this.mounted) {
       data.logger.warn("mount() has been called, skipped.");
@@ -146,6 +137,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,25 +156,28 @@ var Func = class {
       data.response = error;
     }
   }
+  /**
+   * Export the function
+   */
   export() {
     const handler = async (event, context, callback) => {
       if (typeof context === "undefined")
         context = {};
       if (!context.request_id)
-        context.request_id = (0, import_crypto.randomBytes)(16).toString("hex");
+        context.request_id = 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);
-      logger.debug("context: %j", context);
+      const logger$1 = new logger.Logger(context.request_id);
+      logger$1.debug("event: %j", event);
+      logger$1.debug("context: %j", context);
       const data = {
         event,
         context,
         callback,
         response: void 0,
         handler: this.handler,
-        logger,
+        logger: logger$1,
         config: this.config
       };
       await this.invoke(data);
@@ -202,7 +200,7 @@ function usePlugin(plugin) {
           config: (data == null ? void 0 : data.config) || /* @__PURE__ */ Object.create(null),
           event: /* @__PURE__ */ Object.create(null),
           context: /* @__PURE__ */ Object.create(null),
-          logger: new import_logger.Logger(plugin.name)
+          logger: new logger.Logger(plugin.name)
         }, async () => Promise.resolve());
       return plugin;
     };
@@ -218,9 +216,7 @@ function useFunc(handler) {
   plugins = [];
   return func;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Func,
-  useFunc,
-  usePlugin
-});
+
+exports.Func = Func;
+exports.useFunc = useFunc;
+exports.usePlugin = usePlugin;

package/dist/index.mjs

@@ -1,5 +1,7 @@
+import { Logger } from '@faasjs/logger';
+import { randomBytes } from 'crypto';
+
 // src/index.ts
-import { Logger } from "@faasjs/logger";
 
 // src/plugins/run_handler/index.ts
 var RunHandler = class {
@@ -30,10 +32,13 @@ var RunHandler = class {
     await next();
   }
 };
-
-// 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 +99,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 +113,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 +135,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 +154,9 @@ var Func = class {
       data.response = error;
     }
   }
+  /**
+   * Export the function
+   */
   export() {
     const handler = async (event, context, callback) => {
       if (typeof context === "undefined")
@@ -142,7 +164,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);
@@ -192,8 +214,5 @@ function useFunc(handler) {
   plugins = [];
   return func;
 }
-export {
-  Func,
-  useFunc,
-  usePlugin
-};
+
+export { Func, useFunc, usePlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faasjs/func",
-  "version": "0.0.3-beta.86",
+  "version": "0.0.3-beta.88",
   "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.88",
+    "@faasjs/logger": "^0.0.3-beta.88"
   },
   "engines": {
     "npm": ">=8.0.0",