@faasjs/func 0.0.2-beta.42 → 0.0.2-beta.421

package/README.md

@@ -1,9 +1,336 @@
 # @faasjs/func
 
-云函数模块。
-
-[![License: MIT](https://img.shields.io/npm/l/@faasjs/func.svg)](https://github.com/faasjs/faasjs/blob/master/packages/faasjs/func/LICENSE)
+[![License: MIT](https://img.shields.io/npm/l/@faasjs/func.svg)](https://github.com/faasjs/faasjs/blob/main/packages/faasjs/func/LICENSE)
 [![NPM Stable Version](https://img.shields.io/npm/v/@faasjs/func/stable.svg)](https://www.npmjs.com/package/@faasjs/func)
 [![NPM Beta Version](https://img.shields.io/npm/v/@faasjs/func/beta.svg)](https://www.npmjs.com/package/@faasjs/func)
 
-https://faasjs.com/doc/
+FaasJS's function module.
+
+## Install
+
+    npm install @faasjs/func
+
+## Modules
+
+### Classes
+
+- [Func](classes/Func.md)
+
+### Type Aliases
+
+- [Config](#config)
+- [DeployData](#deploydata)
+- [ExportedHandler](#exportedhandler)
+- [FuncConfig](#funcconfig)
+- [Handler](#handler)
+- [InvokeData](#invokedata)
+- [LifeCycleKey](#lifecyclekey)
+- [MountData](#mountdata)
+- [Next](#next)
+- [Plugin](#plugin)
+- [ProviderConfig](#providerconfig)
+- [UseifyPlugin](#useifyplugin)
+
+### Functions
+
+- [useFunc](#usefunc)
+- [usePlugin](#useplugin)
+
+## Type Aliases
+
+### Config
+
+Ƭ **Config**: `Object`
+
+#### Index signature
+
+▪ [key: `string`]: `any`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `plugins?` | { `[key: string]`: { `[key: string]`: `any`; `config?`: { `[key: string]`: `any`;  } ; `provider?`: `string` \| [`ProviderConfig`](#providerconfig) ; `type`: `string`  };  } |
+| `providers?` | { `[key: string]`: [`ProviderConfig`](#providerconfig);  } |
+
+___
+
+### DeployData
+
+Ƭ **DeployData**: `Object`
+
+#### Index signature
+
+▪ [key: `string`]: `any`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `config?` | [`Config`](#config) |
+| `dependencies` | { `[name: string]`: `string`;  } |
+| `env?` | `string` |
+| `filename` | `string` |
+| `logger?` | `Logger` |
+| `name?` | `string` |
+| `plugins?` | { `[name: string]`: { `[key: string]`: `any`; `config`: { `[key: string]`: `any`;  } ; `name?`: `string` ; `plugin`: [`Plugin`](#plugin) ; `provider?`: `string` ; `type`: `string`  };  } |
+| `root` | `string` |
+| `version?` | `string` |
+
+___
+
+### ExportedHandler
+
+Ƭ **ExportedHandler**<`TEvent`, `TContext`, `TResult`\>: (`event`: `TEvent`, `context?`: `TContext`, `callback?`: (...`args`: `any`) => `any`) => `Promise`<`TResult`\>
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `TEvent` | `any` |
+| `TContext` | `any` |
+| `TResult` | `any` |
+
+#### Type declaration
+
+▸ (`event`, `context?`, `callback?`): `Promise`<`TResult`\>
+
+##### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `event` | `TEvent` |
+| `context?` | `TContext` |
+| `callback?` | (...`args`: `any`) => `any` |
+
+##### Returns
+
+`Promise`<`TResult`\>
+
+___
+
+### FuncConfig
+
+Ƭ **FuncConfig**<`TEvent`, `TContext`, `TResult`\>: `Object`
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `TEvent` | `any` |
+| `TContext` | `any` |
+| `TResult` | `any` |
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `handler?` | [`Handler`](#handler)<`TEvent`, `TContext`, `TResult`\> |
+| `plugins?` | [`Plugin`](#plugin)[] |
+
+___
+
+### Handler
+
+Ƭ **Handler**<`TEvent`, `TContext`, `TResult`\>: (`data`: [`InvokeData`](#invokedata)<`TEvent`, `TContext`\>) => `Promise`<`TResult`\>
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `TEvent` | `any` |
+| `TContext` | `any` |
+| `TResult` | `any` |
+
+#### Type declaration
+
+▸ (`data`): `Promise`<`TResult`\>
+
+##### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `data` | [`InvokeData`](#invokedata)<`TEvent`, `TContext`\> |
+
+##### Returns
+
+`Promise`<`TResult`\>
+
+___
+
+### InvokeData
+
+Ƭ **InvokeData**<`TEvent`, `TContext`, `TResult`\>: `Object`
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `TEvent` | `any` |
+| `TContext` | `any` |
+| `TResult` | `any` |
+
+#### Index signature
+
+▪ [key: `string`]: `any`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `callback` | `any` |
+| `config` | [`Config`](#config) |
+| `context` | `TContext` |
+| `event` | `TEvent` |
+| `handler?` | [`Handler`](#handler)<`TEvent`, `TContext`, `TResult`\> |
+| `logger` | `Logger` |
+| `response` | `any` |
+
+___
+
+### LifeCycleKey
+
+Ƭ **LifeCycleKey**: ``"onDeploy"`` \| ``"onMount"`` \| ``"onInvoke"``
+
+___
+
+### MountData
+
+Ƭ **MountData**: `Object`
+
+#### Index signature
+
+▪ [key: `string`]: `any`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `config` | [`Config`](#config) |
+| `context` | `any` |
+| `event` | `any` |
+
+___
+
+### Next
+
+Ƭ **Next**: () => `Promise`<`void`\>
+
+#### Type declaration
+
+▸ (): `Promise`<`void`\>
+
+##### Returns
+
+`Promise`<`void`\>
+
+___
+
+### Plugin
+
+Ƭ **Plugin**: `Object`
+
+#### Index signature
+
+▪ [key: `string`]: `any`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `name` | `string` |
+| `onDeploy?` | (`data`: [`DeployData`](#deploydata), `next`: [`Next`](#next)) => `void` \| `Promise`<`void`\> |
+| `onInvoke?` | (`data`: [`InvokeData`](#invokedata), `next`: [`Next`](#next)) => `void` \| `Promise`<`void`\> |
+| `onMount?` | (`data`: [`MountData`](#mountdata), `next`: [`Next`](#next)) => `void` \| `Promise`<`void`\> |
+| `type` | `string` |
+
+___
+
+### ProviderConfig
+
+Ƭ **ProviderConfig**: `Object`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `config` | { `[key: string]`: `any`;  } |
+| `type` | `string` |
+
+___
+
+### UseifyPlugin
+
+Ƭ **UseifyPlugin**: `Object`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `mount?` | (`data`: { `config`: [`Config`](#config)  }) => `Promise`<`void`\> |
+
+## Functions
+
+### useFunc
+
+▸ **useFunc**<`TEvent`, `TContext`, `TResult`\>(`handler`): [`Func`](classes/Func.md)<`TEvent`, `TContext`, `TResult`\>
+
+```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}`
+  }
+})
+```
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `TEvent` | `any` |
+| `TContext` | `any` |
+| `TResult` | `any` |
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `handler` | () => [`Handler`](#handler)<`TEvent`, `TContext`, `TResult`\> |
+
+#### Returns
+
+[`Func`](classes/Func.md)<`TEvent`, `TContext`, `TResult`\>
+
+___
+
+### usePlugin
+
+▸ **usePlugin**<`T`\>(`plugin`): `T` & [`UseifyPlugin`](#useifyplugin)
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `T` | extends [`Plugin`](#plugin) |
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `plugin` | `T` & [`UseifyPlugin`](#useifyplugin) |
+
+#### Returns
+
+`T` & [`UseifyPlugin`](#useifyplugin)

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+import { Logger } from '@faasjs/logger';
+
+declare type Handler<TEvent = any, TContext = any, TResult = any> = (data: InvokeData<TEvent, TContext>) => Promise<TResult>;
+declare type Next = () => Promise<void>;
+declare type ExportedHandler<TEvent = any, TContext = any, TResult = any> = (event: TEvent, context?: TContext, callback?: (...args: any) => any) => Promise<TResult>;
+declare 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>;
+};
+declare type ProviderConfig = {
+    type: string;
+    config: {
+        [key: string]: any;
+    };
+};
+declare type Config = {
+    [key: string]: any;
+    providers?: {
+        [key: string]: ProviderConfig;
+    };
+    plugins?: {
+        [key: string]: {
+            [key: string]: any;
+            provider?: string | ProviderConfig;
+            type: string;
+            config?: {
+                [key: string]: any;
+            };
+        };
+    };
+};
+declare 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;
+};
+declare type MountData = {
+    [key: string]: any;
+    config: Config;
+    event: any;
+    context: any;
+};
+declare 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;
+};
+declare type LifeCycleKey = 'onDeploy' | 'onMount' | 'onInvoke';
+declare 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>;
+    };
+}
+declare type UseifyPlugin = {
+    mount?: (data: {
+        config: Config;
+    }) => Promise<void>;
+};
+declare function usePlugin<T extends Plugin>(plugin: T & UseifyPlugin): T & UseifyPlugin;
+/**
+ * ```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

@@ -0,0 +1,225 @@
+"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);
+
+// 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 {
+  constructor() {
+    this.type = "handler";
+    this.name = "handler";
+  }
+  async onInvoke(data, next) {
+    if (data.handler)
+      if (!data.runHandler) {
+        try {
+          data.response = await new Promise(function(resolve, reject) {
+            data.callback = function(error, result) {
+              if (error)
+                reject(error);
+              else
+                resolve(result);
+            };
+            Promise.resolve(data.handler(data)).then(resolve).catch(reject);
+          });
+        } catch (error) {
+          data.logger.error(error);
+          data.response = error;
+        }
+        data.runHandler = true;
+      } else
+        data.logger.warn("[RunHandler] handler has been run");
+    await next();
+  }
+};
+
+// src/index.ts
+var import_crypto = require("crypto");
+var Func = class {
+  constructor(config) {
+    this.handler = config.handler;
+    this.plugins = config.plugins || [];
+    this.plugins.push(new RunHandler());
+    this.config = {
+      providers: /* @__PURE__ */ Object.create(null),
+      plugins: /* @__PURE__ */ Object.create(null)
+    };
+    this.mounted = false;
+    this.cachedFunctions = /* @__PURE__ */ Object.create(null);
+    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);
+    }
+  }
+  compose(key) {
+    let list = [];
+    if (this.cachedFunctions[key])
+      list = this.cachedFunctions[key];
+    else {
+      for (const plugin of this.plugins) {
+        const handler = plugin[key];
+        if (typeof handler === "function")
+          list.push({
+            key: plugin.name,
+            handler: handler.bind(plugin)
+          });
+      }
+      this.cachedFunctions[key] = list;
+    }
+    return async function(data, next) {
+      let index = -1;
+      const logger = (data == null ? void 0 : data.logger) || new import_logger.Logger();
+      const dispatch = async function(i) {
+        if (i <= index)
+          return Promise.reject(Error("next() called multiple times"));
+        index = i;
+        let fn = list[i];
+        if (i === list.length)
+          fn = next;
+        if (!fn)
+          return Promise.resolve();
+        if (typeof fn.key === "undefined")
+          fn.key = `UnNamedPlugin#${i}`;
+        logger.debug("[%s][%s] begin", fn.key, key);
+        logger.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);
+          return res;
+        } catch (err) {
+          logger.timeEnd(fn.key, "[%s][%s] failed", fn.key, key);
+          logger.error(err);
+          return Promise.reject(err);
+        }
+      };
+      return await dispatch(0);
+    };
+  }
+  deploy(data) {
+    if (!data.logger)
+      data.logger = new import_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);
+  }
+  async mount(data) {
+    if (!data.logger)
+      data.logger = new import_logger.Logger("Func");
+    data.logger.debug("onMount");
+    if (this.mounted) {
+      data.logger.warn("mount() has been called, skipped.");
+      return;
+    }
+    if (!data.config)
+      data.config = this.config;
+    try {
+      data.logger.time("mount");
+      data.logger.debug("Plugins: " + this.plugins.map((p) => `${p.type}#${p.name}`).join(","));
+      await this.compose("onMount")(data);
+      this.mounted = true;
+    } finally {
+      data.logger.timeEnd("mount", "mounted");
+    }
+  }
+  async invoke(data) {
+    if (!this.mounted)
+      await this.mount({
+        event: data.event,
+        context: data.context,
+        config: data.config,
+        logger: data.logger
+      });
+    try {
+      await this.compose("onInvoke")(data);
+    } catch (error) {
+      data.logger.error(error);
+      data.response = error;
+    }
+  }
+  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");
+      if (!context.request_at)
+        context.request_at = Math.round(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 data = {
+        event,
+        context,
+        callback,
+        response: void 0,
+        handler: this.handler,
+        logger,
+        config: this.config
+      };
+      await this.invoke(data);
+      if (Object.prototype.toString.call(data.response) === "[object Error]")
+        throw data.response;
+      return data.response;
+    };
+    handler.bind(this);
+    return { handler };
+  }
+};
+var plugins = [];
+function usePlugin(plugin) {
+  if (!plugins.find((p) => p.name === plugin.name))
+    plugins.push(plugin);
+  if (!plugin.mount)
+    plugin.mount = async function({ config }) {
+      if (plugin.onMount)
+        await plugin.onMount({
+          config,
+          event: {},
+          context: {},
+          logger: new import_logger.Logger(plugin.name)
+        }, async () => Promise.resolve());
+    };
+  return plugin;
+}
+function useFunc(handler) {
+  plugins = [];
+  const invokeHandler = handler();
+  const func = new Func({
+    plugins,
+    handler: invokeHandler
+  });
+  plugins = [];
+  return func;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Func,
+  useFunc,
+  usePlugin
+});