@faasjs/http 0.0.3-beta.68 → 0.0.3-beta.69

package/dist/index.mjs

@@ -1,3 +1,9 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -5,41 +11,722 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
 });
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
-// src/index.ts
-import {
-  usePlugin
-} from "@faasjs/func";
+// ../func/dist/index.js
+var require_dist = __commonJS({
+  "../func/dist/index.js"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __commonJS2 = (cb, mod) => function __require2() {
+      return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var require_dist4 = __commonJS2({
+      "../logger/dist/index.js"(exports2, module2) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export2 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS2 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var src_exports2 = {};
+        __export2(src_exports2, {
+          Color: () => Color,
+          Logger: () => Logger2
+        });
+        module2.exports = __toCommonJS2(src_exports2);
+        var import_util = __require("util");
+        var Color = /* @__PURE__ */ ((Color2) => {
+          Color2[Color2["DEFAULT"] = 39] = "DEFAULT";
+          Color2[Color2["BLACK"] = 30] = "BLACK";
+          Color2[Color2["RED"] = 31] = "RED";
+          Color2[Color2["GREEN"] = 32] = "GREEN";
+          Color2[Color2["ORANGE"] = 33] = "ORANGE";
+          Color2[Color2["BLUE"] = 34] = "BLUE";
+          Color2[Color2["MAGENTA"] = 35] = "MAGENTA";
+          Color2[Color2["CYAN"] = 36] = "CYAN";
+          Color2[Color2["GRAY"] = 90] = "GRAY";
+          return Color2;
+        })(Color || {});
+        var LevelColor = ((LevelColor2) => {
+          LevelColor2[
+            LevelColor2["debug"] = 90
+            /* GRAY */
+          ] = "debug";
+          LevelColor2[
+            LevelColor2["info"] = 32
+            /* GREEN */
+          ] = "info";
+          LevelColor2[
+            LevelColor2["warn"] = 33
+            /* ORANGE */
+          ] = "warn";
+          LevelColor2[
+            LevelColor2["error"] = 31
+            /* RED */
+          ] = "error";
+          return LevelColor2;
+        })(LevelColor || {});
+        var LevelPriority = {
+          debug: 0,
+          info: 1,
+          warn: 2,
+          error: 3
+        };
+        var Logger2 = class {
+          /**
+           * @param label {string} Prefix label
+           */
+          constructor(label) {
+            this.colorfyOutput = true;
+            if (label)
+              this.label = label;
+            this.silent = !process.env.FaasLog && process.env.npm_config_argv && JSON.parse(process.env.npm_config_argv).original.includes("--silent");
+            if (["remote", "mono"].includes(process.env.FaasMode))
+              this.colorfyOutput = false;
+            this.level = process.env.FaasLog ? LevelPriority[process.env.FaasLog.toLowerCase()] : 0;
+            this.cachedTimers = {};
+            this.size = 1e3;
+            this.stdout = console.log;
+            this.stderr = console.error;
+          }
+          /**
+           * @param message {string} message
+           * @param args {...any=} arguments
+           */
+          debug(message, ...args) {
+            this.log("debug", message, ...args);
+            return this;
+          }
+          /**
+           * @param message {string} message
+           * @param args {...any=} arguments
+           */
+          info(message, ...args) {
+            this.log("info", message, ...args);
+            return this;
+          }
+          /**
+           * @param message {string} message
+           * @param args {...any=} arguments
+           */
+          warn(message, ...args) {
+            this.log("warn", message, ...args);
+            return this;
+          }
+          /**
+           * @param message {any} message or Error object
+           * @param args {...any=} arguments
+           */
+          error(message, ...args) {
+            let stack = false;
+            [message].concat(Array.from(args)).forEach((e) => {
+              if (e.stack) {
+                stack = true;
+                this.log("error", e.stack);
+              }
+            });
+            if (!stack)
+              this.log("error", message, ...args);
+            return this;
+          }
+          /**
+           * @param key {string} timer's label
+           * @param level [string=debug] 日志级别，支持 debug、info、warn、error
+           */
+          time(key, level = "debug") {
+            this.cachedTimers[key] = {
+              level,
+              time: (/* @__PURE__ */ new Date()).getTime()
+            };
+            return this;
+          }
+          /**
+           * @param key {string} timer's label
+           * @param message {string} message
+           * @param args {...any=} arguments
+           */
+          timeEnd(key, message, ...args) {
+            if (this.cachedTimers[key]) {
+              const timer = this.cachedTimers[key];
+              message = message + " +%ims";
+              args.push((/* @__PURE__ */ new Date()).getTime() - timer.time);
+              this[timer.level](message, ...args);
+              delete this.cachedTimers[key];
+            } else {
+              this.warn("timeEnd not found key %s", key);
+              this.debug(message);
+            }
+            return this;
+          }
+          /**
+           * @param message {string} message
+           * @param args {...any=} arguments
+           */
+          raw(message, ...args) {
+            if (this.silent)
+              return this;
+            this.stdout((0, import_util.format)(message, ...args));
+            return this;
+          }
+          /**
+           * @param color {number} color code
+           * @param message {string} message
+           */
+          colorfy(color, message) {
+            return `\x1B[0${color}m${message}\x1B[39m`;
+          }
+          log(level, message, ...args) {
+            if (this.silent)
+              return this;
+            if (LevelPriority[level] < this.level)
+              return this;
+            let output = level.toUpperCase() + " " + (this.label ? `[${this.label}] ` : "") + (0, import_util.format)(message, ...args);
+            if (this.colorfyOutput && level !== "error")
+              output = this.colorfy(LevelColor[level], output);
+            else if (!this.colorfyOutput)
+              output = output.replace(/\n/g, "");
+            if (!output)
+              return this;
+            if (output.length > this.size && !["error", "warn"].includes(level))
+              output = output.slice(0, this.size - 100) + "..." + output.slice(output.length - 100);
+            if (level === "error")
+              this.stderr(output);
+            else
+              this.stdout(output);
+            return this;
+          }
+        };
+      }
+    });
+    var src_exports = {};
+    __export(src_exports, {
+      Func: () => Func,
+      useFunc: () => useFunc,
+      usePlugin: () => usePlugin2
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_logger2 = __toESM2(require_dist4());
+    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();
+      }
+    };
+    var import_crypto2 = __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 || [];
+        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_logger2.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_logger2.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 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_logger2.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_logger2.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");
+        }
+      }
+      /**
+       * Invoke the function
+       * @param data {object} data
+       */
+      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 the function
+       */
+      export() {
+        const handler = async (event, context, callback) => {
+          if (typeof context === "undefined")
+            context = {};
+          if (!context.request_id)
+            context.request_id = (0, import_crypto2.randomBytes)(16).toString("hex");
+          if (!context.request_at)
+            context.request_at = Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3);
+          context.callbackWaitsForEmptyEventLoop = false;
+          const logger = new import_logger2.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 usePlugin2(plugin) {
+      if (!plugins.find((p) => p.name === plugin.name))
+        plugins.push(plugin);
+      if (!plugin.mount)
+        plugin.mount = async function(data) {
+          if (plugin.onMount)
+            await plugin.onMount({
+              config: (data == null ? void 0 : data.config) || /* @__PURE__ */ Object.create(null),
+              event: /* @__PURE__ */ Object.create(null),
+              context: /* @__PURE__ */ Object.create(null),
+              logger: new import_logger2.Logger(plugin.name)
+            }, async () => Promise.resolve());
+          return plugin;
+        };
+      return plugin;
+    }
+    function useFunc(handler) {
+      plugins = [];
+      const invokeHandler = handler();
+      const func = new Func({
+        plugins,
+        handler: invokeHandler
+      });
+      plugins = [];
+      return func;
+    }
+  }
+});
 
-// ../deep_merge/src/index.ts
-var shouldMerge = function(item) {
-  const type = Object.prototype.toString.call(item);
-  return type === "[object Object]" || type === "[object Array]";
-};
-function deepMerge(...sources) {
-  let acc = /* @__PURE__ */ Object.create(null);
-  for (const source of sources)
-    if (source instanceof Array) {
-      if (!(acc instanceof Array))
-        acc = [];
-      acc = [...new Set(source.concat(...acc))];
-    } else if (shouldMerge(source))
-      for (const [key, value] of Object.entries(source)) {
-        let val;
-        if (shouldMerge(value))
-          val = deepMerge(acc[key], value);
-        else
-          val = value;
-        acc = {
-          ...acc,
-          [key]: val
+// ../deep_merge/dist/index.js
+var require_dist2 = __commonJS({
+  "../deep_merge/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export(src_exports, {
+      deepMerge: () => deepMerge3
+    });
+    module.exports = __toCommonJS(src_exports);
+    var shouldMerge = function(item) {
+      const type = Object.prototype.toString.call(item);
+      return type === "[object Object]" || type === "[object Array]";
+    };
+    function deepMerge3(...sources) {
+      let acc = /* @__PURE__ */ Object.create(null);
+      for (const source of sources)
+        if (source instanceof Array) {
+          if (!(acc instanceof Array))
+            acc = [];
+          acc = [...new Set(source.concat(...acc))];
+        } else if (shouldMerge(source))
+          for (const [key, value] of Object.entries(source)) {
+            let val;
+            if (shouldMerge(value))
+              val = deepMerge3(acc[key], value);
+            else
+              val = value;
+            acc = {
+              ...acc,
+              [key]: val
+            };
+          }
+      return acc;
+    }
+  }
+});
+
+// ../logger/dist/index.js
+var require_dist3 = __commonJS({
+  "../logger/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export(src_exports, {
+      Color: () => Color,
+      Logger: () => Logger2
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_util = __require("util");
+    var Color = /* @__PURE__ */ ((Color2) => {
+      Color2[Color2["DEFAULT"] = 39] = "DEFAULT";
+      Color2[Color2["BLACK"] = 30] = "BLACK";
+      Color2[Color2["RED"] = 31] = "RED";
+      Color2[Color2["GREEN"] = 32] = "GREEN";
+      Color2[Color2["ORANGE"] = 33] = "ORANGE";
+      Color2[Color2["BLUE"] = 34] = "BLUE";
+      Color2[Color2["MAGENTA"] = 35] = "MAGENTA";
+      Color2[Color2["CYAN"] = 36] = "CYAN";
+      Color2[Color2["GRAY"] = 90] = "GRAY";
+      return Color2;
+    })(Color || {});
+    var LevelColor = ((LevelColor2) => {
+      LevelColor2[
+        LevelColor2["debug"] = 90
+        /* GRAY */
+      ] = "debug";
+      LevelColor2[
+        LevelColor2["info"] = 32
+        /* GREEN */
+      ] = "info";
+      LevelColor2[
+        LevelColor2["warn"] = 33
+        /* ORANGE */
+      ] = "warn";
+      LevelColor2[
+        LevelColor2["error"] = 31
+        /* RED */
+      ] = "error";
+      return LevelColor2;
+    })(LevelColor || {});
+    var LevelPriority = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    var Logger2 = class {
+      /**
+       * @param label {string} Prefix label
+       */
+      constructor(label) {
+        this.colorfyOutput = true;
+        if (label)
+          this.label = label;
+        this.silent = !process.env.FaasLog && process.env.npm_config_argv && JSON.parse(process.env.npm_config_argv).original.includes("--silent");
+        if (["remote", "mono"].includes(process.env.FaasMode))
+          this.colorfyOutput = false;
+        this.level = process.env.FaasLog ? LevelPriority[process.env.FaasLog.toLowerCase()] : 0;
+        this.cachedTimers = {};
+        this.size = 1e3;
+        this.stdout = console.log;
+        this.stderr = console.error;
+      }
+      /**
+       * @param message {string} message
+       * @param args {...any=} arguments
+       */
+      debug(message, ...args) {
+        this.log("debug", message, ...args);
+        return this;
+      }
+      /**
+       * @param message {string} message
+       * @param args {...any=} arguments
+       */
+      info(message, ...args) {
+        this.log("info", message, ...args);
+        return this;
+      }
+      /**
+       * @param message {string} message
+       * @param args {...any=} arguments
+       */
+      warn(message, ...args) {
+        this.log("warn", message, ...args);
+        return this;
+      }
+      /**
+       * @param message {any} message or Error object
+       * @param args {...any=} arguments
+       */
+      error(message, ...args) {
+        let stack = false;
+        [message].concat(Array.from(args)).forEach((e) => {
+          if (e.stack) {
+            stack = true;
+            this.log("error", e.stack);
+          }
+        });
+        if (!stack)
+          this.log("error", message, ...args);
+        return this;
+      }
+      /**
+       * @param key {string} timer's label
+       * @param level [string=debug] 日志级别，支持 debug、info、warn、error
+       */
+      time(key, level = "debug") {
+        this.cachedTimers[key] = {
+          level,
+          time: (/* @__PURE__ */ new Date()).getTime()
         };
+        return this;
       }
-  return acc;
-}
+      /**
+       * @param key {string} timer's label
+       * @param message {string} message
+       * @param args {...any=} arguments
+       */
+      timeEnd(key, message, ...args) {
+        if (this.cachedTimers[key]) {
+          const timer = this.cachedTimers[key];
+          message = message + " +%ims";
+          args.push((/* @__PURE__ */ new Date()).getTime() - timer.time);
+          this[timer.level](message, ...args);
+          delete this.cachedTimers[key];
+        } else {
+          this.warn("timeEnd not found key %s", key);
+          this.debug(message);
+        }
+        return this;
+      }
+      /**
+       * @param message {string} message
+       * @param args {...any=} arguments
+       */
+      raw(message, ...args) {
+        if (this.silent)
+          return this;
+        this.stdout((0, import_util.format)(message, ...args));
+        return this;
+      }
+      /**
+       * @param color {number} color code
+       * @param message {string} message
+       */
+      colorfy(color, message) {
+        return `\x1B[0${color}m${message}\x1B[39m`;
+      }
+      log(level, message, ...args) {
+        if (this.silent)
+          return this;
+        if (LevelPriority[level] < this.level)
+          return this;
+        let output = level.toUpperCase() + " " + (this.label ? `[${this.label}] ` : "") + (0, import_util.format)(message, ...args);
+        if (this.colorfyOutput && level !== "error")
+          output = this.colorfy(LevelColor[level], output);
+        else if (!this.colorfyOutput)
+          output = output.replace(/\n/g, "");
+        if (!output)
+          return this;
+        if (output.length > this.size && !["error", "warn"].includes(level))
+          output = output.slice(0, this.size - 100) + "..." + output.slice(output.length - 100);
+        if (level === "error")
+          this.stderr(output);
+        else
+          this.stdout(output);
+        return this;
+      }
+    };
+  }
+});
 
 // src/index.ts
-import { Logger } from "@faasjs/logger";
+var import_func = __toESM(require_dist());
+var import_deep_merge2 = __toESM(require_dist2());
+var import_logger = __toESM(require_dist3());
 
 // src/session.ts
 import {
@@ -138,9 +825,10 @@ var Session = class {
 };
 
 // src/cookie.ts
+var import_deep_merge = __toESM(require_dist2());
 var Cookie = class {
   constructor(config) {
-    this.config = deepMerge({
+    this.config = (0, import_deep_merge.deepMerge)({
       path: "/",
       expires: 31536e3,
       secure: true,
@@ -427,10 +1115,10 @@ var Http = class {
     var _a;
     data.dependencies["@faasjs/http"] = "*";
     await next();
-    const logger = new Logger(this.name);
+    const logger = new import_logger.Logger(this.name);
     logger.debug("Generate api gateway's config");
     logger.debug("%j", data);
-    const config = data.config.plugins ? deepMerge(data.config.plugins[this.name || this.type], { config: this.config }) : { config: this.config };
+    const config = data.config.plugins ? (0, import_deep_merge2.deepMerge)(data.config.plugins[this.name || this.type], { config: this.config }) : { config: this.config };
     if (!config.config.path) {
       config.config.path = "/" + ((_a = data.name) == null ? void 0 : _a.replace(/_/g, "/").replace(/\/index$/, ""));
       if (config.config.path === "/index")
@@ -466,7 +1154,7 @@ var Http = class {
           this.config[key] = value;
       }
     if (data.config.plugins && data.config.plugins[this.name || this.type])
-      this.config = deepMerge(this.config, data.config.plugins[this.name || this.type].config);
+      this.config = (0, import_deep_merge2.deepMerge)(this.config, data.config.plugins[this.name || this.type].config);
     data.logger.debug("[onMount] prepare cookie & session");
     this.cookie = new Cookie(this.config.cookie || {});
     this.session = this.cookie.session;
@@ -560,10 +1248,20 @@ var Http = class {
       delete data.response.headers["Content-Encoding"];
     }
   }
+  /**
+   * set header
+   * @param key {string} key
+   * @param value {*} value
+   */
   setHeader(key, value) {
     this.response.headers[key] = value;
     return this;
   }
+  /**
+   * set Content-Type
+   * @param type {string} 类型
+   * @param charset {string} 编码
+   */
   setContentType(type, charset = "utf-8") {
     if (ContentType[type])
       this.setHeader("Content-Type", `${ContentType[type]}; charset=${charset}`);
@@ -571,17 +1269,25 @@ var Http = class {
       this.setHeader("Content-Type", `${type}; charset=${charset}`);
     return this;
   }
+  /**
+   * set status code
+   * @param code {number} 状态码
+   */
   setStatusCode(code) {
     this.response.statusCode = code;
     return this;
   }
+  /**
+   * set body
+   * @param body {*} 内容
+   */
   setBody(body) {
     this.response.body = body;
     return this;
   }
 };
 function useHttp(config) {
-  return usePlugin(new Http(config));
+  return (0, import_func.usePlugin)(new Http(config));
 }
 export {
   ContentType,