@faasjs/func 0.0.2-beta.99 → 0.0.3-beta.2

package/dist/index.mjs

@@ -0,0 +1,198 @@
+// src/index.ts
+import { Logger } from "@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
+import { randomBytes } from "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 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 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 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 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 = randomBytes(16).toString("hex");
+      if (!context.request_at)
+        context.request_at = Math.round(new Date().getTime() / 1e3);
+      context.callbackWaitsForEmptyEventLoop = false;
+      const logger = new 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 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;
+}
+export {
+  Func,
+  useFunc,
+  usePlugin
+};

package/package.json

@@ -1,29 +1,32 @@
 {
   "name": "@faasjs/func",
-  "version": "0.0.2-beta.99",
+  "version": "0.0.3-beta.2",
   "license": "MIT",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "module": "lib/index.es.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "homepage": "https://faasjs.com/docs/func",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faasjs/faasjs.git",
+    "directory": "packages/func"
+  },
+  "bugs": {
+    "url": "https://github.com/faasjs/faasjs/issues"
+  },
+  "funding": "https://github.com/sponsors/faasjs",
   "scripts": {
-    "lint": "eslint --ext .ts src",
-    "prepack": "rm -rf ./lib && rollup -c && mv lib/*/src/* lib/",
-    "ci": "yarn lint && jest --silent"
+    "build": "tsup-node src/index.ts --format esm,cjs",
+    "build:types": "tsup-node src/index.ts --dts-only"
   },
   "files": [
-    "lib"
+    "dist"
   ],
   "dependencies": {
-    "@faasjs/deep_merge": "^0.0.2-beta.54",
-    "@faasjs/logger": "^0.0.2-beta.69"
-  },
-  "devDependencies": {
-    "@types/debug": "*",
-    "@types/jest": "*",
-    "@types/node": "*",
-    "rollup": "*",
-    "rollup-plugin-typescript2": "*",
-    "typescript": "*"
+    "@faasjs/deep_merge": "^0.0.3-beta.2",
+    "@faasjs/logger": "^0.0.3-beta.2"
   },
-  "gitHead": "8c2bc1591c90b91123b6295845f43e09fac3e53b"
+  "engines": {
+    "npm": ">=8.0.0",
+    "node": ">=16.0.0"
+  }
 }

package/lib/index.d.ts

@@ -1,130 +0,0 @@
-import Logger from '@faasjs/logger';
-export declare type Handler<TEvent = any, TContext = any, RESULT = any> = (data: InvokeData<TEvent, TContext>) => RESULT;
-export declare type Next = () => Promise<void>;
-export declare type ExportedHandler<TEvent = any, TContext = any, RESULT = any> = (event: TEvent, context?: TContext, callback?: (...args: any) => any) => Promise<RESULT>;
-export interface Plugin {
-    [key: string]: any;
-    readonly type: string;
-    readonly name: string;
-    onDeploy?: (data: DeployData, next: Next) => void;
-    onMount?: (data: MountData, next: Next) => void;
-    onInvoke?: (data: InvokeData, next: Next) => void;
-}
-export interface Config {
-    [key: string]: any;
-    providers: {
-        [key: string]: {
-            type: string;
-            config: {
-                [key: string]: any;
-            };
-        };
-    };
-    plugins: {
-        [key: string]: {
-            [key: string]: any;
-            provider?: string;
-            type: string;
-            config?: {
-                [key: string]: any;
-            };
-        };
-    };
-}
-export interface 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;
-}
-export interface MountData {
-    [key: string]: any;
-    config: Config;
-    event: any;
-    context: any;
-}
-export interface InvokeData<TEvent = any, TContext = any, RESULT = any> {
-    [key: string]: any;
-    event: TEvent;
-    context: TContext;
-    callback: any;
-    response: any;
-    logger: Logger;
-    handler: Handler<TEvent, TContext, RESULT>;
-    config: Config;
-}
-export declare type LifeCycleKey = 'onDeploy' | 'onMount' | 'onInvoke';
-export interface FuncConfig<TEvent = any, TContext = any, RESULT = any> {
-    plugins?: Plugin[];
-    handler?: Handler<TEvent, TContext, RESULT>;
-}
-export declare class Func<TEvent = any, TContext = any, RESULT = any> {
-    [key: string]: any;
-    plugins: Plugin[];
-    handler?: Handler<TEvent, TContext, RESULT>;
-    logger: Logger;
-    config: Config;
-    mounted: boolean;
-    private cachedFunctions;
-    /**
-     * 新建流程
-     * @param config {object} 配置项
-     * @param config.plugins {Plugin[]} 插件
-     * @param config.handler {Handler} 业务函数
-     */
-    constructor(config: FuncConfig<TEvent, TContext>);
-    compose(key: LifeCycleKey): (data: any, next?: () => void) => any;
-    /**
-     * 发布云资源
-     * @param data {object} 代码包信息
-     * @param data.root {string} 项目根目录
-     * @param data.filename {string} 包括完整路径的流程文件名
-     * @param data.env {string} 环境
-     */
-    deploy(data: DeployData): any;
-    /**
-     * 启动云实例
-     */
-    mount(data: {
-        event: TEvent;
-        context: TContext;
-        config?: Config;
-    }): Promise<void>;
-    /**
-     * 执行云函数
-     * @param data {object} 执行信息
-     */
-    invoke(data: InvokeData<TEvent, TContext, RESULT>): Promise<void>;
-    /**
-     * 创建触发函数
-     */
-    export(): {
-        handler: ExportedHandler<TEvent, TContext, RESULT>;
-    };
-}
-export interface UseifyPlugin {
-    mount?({ config: Config }: {
-        config: any;
-    }): Promise<void>;
-}
-export declare function usePlugin<T extends Plugin>(plugin: T & UseifyPlugin): T & UseifyPlugin;
-export declare function useFunc<TEvent = any, TContext = any, RESULT = any>(handler: () => Handler<TEvent, TContext, RESULT>): Func<TEvent, TContext, RESULT>;

package/lib/index.es.js

@@ -1,212 +0,0 @@
-import Logger from '@faasjs/logger';
-
-class RunHandler {
-    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(function (result) {
-                            resolve(result);
-                        }).catch(function (error) {
-                            reject(error);
-                        });
-                    });
-                }
-                catch (error) {
-                    data.logger.error(error);
-                    data.response = error;
-                }
-                data.runHandler = true;
-            }
-            else
-                data.logger.warn('[RunHandler] handler has been run');
-        await next();
-    }
-}
-
-/* eslint-disable @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
-class Func {
-    /**
-     * 新建流程
-     * @param config {object} 配置项
-     * @param config.plugins {Plugin[]} 插件
-     * @param config.handler {Handler} 业务函数
-     */
-    constructor(config) {
-        this.logger = new Logger('Func');
-        this.handler = config.handler;
-        this.plugins = config.plugins || [];
-        this.plugins.push(new RunHandler());
-        this.config = {
-            providers: Object.create(null),
-            plugins: Object.create(null)
-        };
-        this.mounted = false;
-        this.cachedFunctions = Object.create(null);
-    }
-    compose(key) {
-        const logger = new Logger(key);
-        let list = [];
-        if (this.cachedFunctions[key])
-            list = this.cachedFunctions[key];
-        else {
-            for (const plugin of this.plugins)
-                if (typeof plugin[key] === 'function')
-                    list.push({
-                        key: plugin.name,
-                        handler: plugin[key].bind(plugin)
-                    });
-            this.cachedFunctions[key] = list;
-        }
-        return function (data, next) {
-            let index = -1;
-            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 (fn.key) {
-                    logger.debug(`[${fn.key}] begin`);
-                    logger.time(fn.key);
-                }
-                try {
-                    const res = await Promise.resolve(fn.handler(data, dispatch.bind(null, i + 1)));
-                    if (fn.key)
-                        logger.timeEnd(fn.key, `[${fn.key}] end`);
-                    return res;
-                }
-                catch (err) {
-                    if (fn.key)
-                        logger.timeEnd(fn.key, `[${fn.key}] failed`);
-                    console.error(err);
-                    return Promise.reject(err);
-                }
-            };
-            return dispatch(0);
-        };
-    }
-    /**
-     * 发布云资源
-     * @param data {object} 代码包信息
-     * @param data.root {string} 项目根目录
-     * @param data.filename {string} 包括完整路径的流程文件名
-     * @param data.env {string} 环境
-     */
-    deploy(data) {
-        this.logger.debug('onDeploy');
-        return this.compose('onDeploy')(data);
-    }
-    /**
-     * 启动云实例
-     */
-    async mount(data) {
-        this.logger.debug('onMount');
-        if (this.mounted) {
-            this.logger.warn('mount() has been called, skipped.');
-            return;
-        }
-        data.config = this.config;
-        try {
-            this.logger.time('mount');
-            await this.compose('onMount')(data);
-            this.mounted = true;
-        }
-        finally {
-            this.logger.timeEnd('mount', 'mounted');
-        }
-    }
-    /**
-     * 执行云函数
-     * @param data {object} 执行信息
-     */
-    async invoke(data) {
-        // 实例未启动时执行启动函数
-        if (!this.mounted)
-            await this.mount({
-                event: data.event,
-                context: data.context,
-            });
-        try {
-            await this.compose('onInvoke')(data);
-        }
-        catch (error) {
-            // 执行异常时回传异常
-            this.logger.error(error);
-            data.response = error;
-        }
-    }
-    /**
-     * 创建触发函数
-     */
-    export() {
-        return {
-            handler: async (event, context, callback) => {
-                const logger = new Logger();
-                logger.debug('event: %O', event);
-                logger.debug('context: %O', context);
-                if (typeof context === 'undefined')
-                    context = {};
-                if (!context.request_id)
-                    context.request_id = new Date().getTime().toString();
-                if (!context.request_at)
-                    context.request_at = Math.round(new Date().getTime() / 1000);
-                context.callbackWaitsForEmptyEventLoop = false;
-                const data = {
-                    event,
-                    context,
-                    callback,
-                    response: undefined,
-                    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;
-            }
-        };
-    }
-}
-let 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: {}
-                }, async () => Promise.resolve());
-        };
-    return plugin;
-}
-function useFunc(handler) {
-    plugins = [];
-    const invokeHanlder = handler();
-    const func = new Func({
-        plugins,
-        handler: invokeHanlder
-    });
-    plugins = [];
-    return func;
-}
-
-export { Func, useFunc, usePlugin };