koatty 3.12.0 → 3.13.0

package/dist/index.js

@@ -1,45 +1,55 @@
 /*!
 * @Author: richen
-* @Date: 2025-03-15 23:04:17
+* @Date: 2025-04-19 23:06:49
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
-'use strict';
-
-var koatty_config = require('koatty_config');
-var koatty_container = require('koatty_container');
-var koatty_core = require('koatty_core');
-var koatty_exception = require('koatty_exception');
-var koatty_lib = require('koatty_lib');
-var koatty_router = require('koatty_router');
-var koatty_logger = require('koatty_logger');
-var koatty_loader = require('koatty_loader');
-var koatty_serve = require('koatty_serve');
-var path = require('path');
-
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
+"use strict";
+
+var e = require("koatty_config");
+
+var t = require("koatty_container");
+
+var o = require("koatty_core");
+
+var r = require("koatty_exception");
+
+var a = require("koatty_lib");
+
+var n = require("koatty_router");
+
+var s = require("koatty_logger");
+
+var i = require("koatty_loader");
+
+var l = require("koatty_serve");
+
+var c = require("path");
+
+function p(e) {
+  var t = Object.create(null);
+  if (e) Object.keys(e).forEach((function(o) {
+    if (o !== "default") {
+      var r = Object.getOwnPropertyDescriptor(e, o);
+      Object.defineProperty(t, o, r.get ? r : {
+        enumerable: !0,
+        get: function() {
+          return e[o];
+        }
+      });
+    }
+  }));
+  t.default = e;
+  return Object.freeze(t);
 }
 
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var f = p(c);
+
+var d = "3.13.0";
 
-var version = "3.12.0";
-var engines = {
-	node: ">12.0.0"
+var u = {
+  node: ">12.0.0"
 };
 
 /*
@@ -50,31 +60,16 @@ var engines = {
  * @LastEditTime: 2024-10-31 17:52:43
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
- */
-// Logger
-const Logger = koatty_logger.DefaultLogger;
-/**
- * SetLogger
- *
- * @export
- * @param {{
- *     logLevel?: LogLevelType;
- *     logFilePath?: string;
- *     sensFields?: string[];
- * }} config
- */
-function SetLogger(app, config) {
-    if (config.logLevel) {
-        koatty_logger.DefaultLogger.setLevel(config.logLevel);
-    }
-    if (config.logFilePath && !app.silent) {
-        koatty_lib.Helper.define(app, "logsPath", config.logFilePath);
-        process.env.LOGS_PATH = config.logFilePath;
-        koatty_logger.DefaultLogger.setLogFilePath(config.logFilePath);
-    }
-    if (config.sensFields) {
-        koatty_logger.DefaultLogger.setSensFields(config.sensFields);
-    }
+ */ const g = s.DefaultLogger;
+
+function h(e, t) {
+  if (t.logLevel) s.DefaultLogger.setLevel(t.logLevel);
+  if (t.logFilePath && !e.silent) {
+    a.Helper.define(e, "logsPath", t.logFilePath);
+    process.env.LOGS_PATH = t.logFilePath;
+    s.DefaultLogger.setLogFilePath(t.logFilePath);
+  }
+  if (t.sensFields) s.DefaultLogger.setSensFields(t.sensFields);
 }
 
 /*
@@ -85,75 +80,39 @@ function SetLogger(app, config) {
  * @LastEditTime: 2025-01-14 16:14:10
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
- */
-const KOATTY_VERSION = version;
-const ENGINES_VERSION = engines.node.slice(1) || '12.0.0';
-/**
- * Check class file
- * name should be always the same as class name
- * class must be unique
- *
- * @export
- * @param {string} fileName
- * @param {string} xpath
- * @param {*} target
- * @param {Set<unknown>} [exSet]
- * @returns {*}
- */
-function checkClass(fileName, xpath, target, exSet) {
-    if (koatty_lib.Helper.isClass(target) && target.name != fileName) { // export default class name{}
-        throw Error(`The file(${xpath}) name should be always the same as class name.`);
-    }
-    if (target["__esModule"]) {
-        if (target.name === undefined) { // export class name{}
-            const keys = Object.keys(target);
-            if (keys[0] != fileName && koatty_lib.Helper.isClass(target[keys[0]])) {
-                throw Error(`The file(${xpath}) name should be always the same as class name.`);
-            }
-        }
-        else if (target.name != fileName) { // export default class {}
-            throw Error(`The file(${xpath}) name should be always the same as class name.`);
-        }
-    }
-    if (!exSet) {
-        return;
-    }
-    if (exSet.has(fileName)) {
-        throw new Error(`A same class already exists. at \`${xpath}\`.`);
-    }
-    exSet.add(fileName);
-    return;
+ */ const y = d;
+
+const C = u.node.slice(1) || "12.0.0";
+
+function m(e, t, o, r) {
+  if (a.Helper.isClass(o) && o.name != e) throw Error(`The file(${t}) name should be always the same as class name.`);
+  if (o["__esModule"]) if (o.name === void 0) {
+    const r = Object.keys(o);
+    if (r[0] != e && a.Helper.isClass(o[r[0]])) throw Error(`The file(${t}) name should be always the same as class name.`);
+  } else if (o.name != e) throw Error(`The file(${t}) name should be always the same as class name.`);
+  if (!r) return;
+  if (r.has(e)) throw new Error(`A same class already exists. at \`${t}\`.`);
+  r.add(e);
+  return;
 }
-/**
- * check node version
- * @return {void} []
- */
-function checkRuntime() {
-    let nodeEngines = ENGINES_VERSION;
-    nodeEngines = nodeEngines.slice(0, nodeEngines.lastIndexOf('.'));
-    let nodeVersion = process.version;
-    if (nodeVersion[0] === 'v') {
-        nodeVersion = nodeVersion.slice(1);
-    }
-    nodeVersion = nodeVersion.slice(0, nodeVersion.lastIndexOf('.'));
-    if (koatty_lib.Helper.toNumber(nodeEngines) > koatty_lib.Helper.toNumber(nodeVersion)) {
-        Logger.Error(`Koatty need node version > ${nodeEngines}, current version is ${nodeVersion}, please upgrade it.`);
-        process.exit(-1);
-    }
+
+function L() {
+  let e = C;
+  e = e.slice(0, e.lastIndexOf("."));
+  let t = process.version;
+  if (t[0] === "v") t = t.slice(1);
+  t = t.slice(0, t.lastIndexOf("."));
+  if (a.Helper.toNumber(e) > a.Helper.toNumber(t)) {
+    g.Error(`Koatty need node version > ${e}, current version is ${t}, please upgrade it.`);
+    process.exit(-1);
+  }
 }
-/**
- * unittest running environment detection
- * only support jest
- * @returns {boolean}
- */
-const checkUTRuntime = () => {
-    let isUTRuntime = false;
-    // UT运行环境判断，暂时先只判断jest
-    const argv = JSON.stringify(process.argv[1]);
-    if (argv.indexOf('jest') > -1) {
-        isUTRuntime = true;
-    }
-    return isUTRuntime;
+
+const v = () => {
+  let e = !1;
+  const t = JSON.stringify(process.argv[1]);
+  if (t.indexOf("jest") > -1) e = !0;
+  return e;
 };
 
 /*
@@ -164,19 +123,11 @@ const checkUTRuntime = () => {
  * @LastEditTime: 2023-12-09 23:00:13
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
- */
-const COMPONENT_SCAN = 'COMPONENT_SCAN';
-const CONFIGURATION_SCAN = 'CONFIGURATION_SCAN';
-// tslint:disable: no-irregular-whitespace
-const LOGO = `
-
-┬┌─┌─┐┌─┐┌┬┐┌┬┐┬ ┬
-├┴┐│ │├─┤ │  │ └┬┘
-┴ ┴└─┘┴ ┴ ┴  ┴  ┴ 
--------------------------------------------
-https://github.com/koatty
-`;
+ */ const E = "COMPONENT_SCAN";
+
+const O = "CONFIGURATION_SCAN";
 
+const w = `\n\n┬┌─┌─┐┌─┐┌┬┐┌┬┐┬ ┬\n├┴┐│ │├─┤ │  │ └┬┘\n┴ ┴└─┘┴ ┴ ┴  ┴  ┴ \n-------------------------------------------\nhttps://github.com/koatty\n`
 /*
  * @Description: framework loader
  * @Usage:
@@ -185,423 +136,269 @@ https://github.com/koatty
  * @LastEditTime: 2025-03-13 16:44:39
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
- */
-/**
- *
- */
+ */;
+
 class Loader {
-    /**
-     * Creates an instance of Loader.
-     * @param {KoattyApplication} app
-     * @memberof Loader
-     */
-    constructor(app) {
-        this.app = app;
-    }
-    /**
-     * initialize env
-     *
-     * @static
-     * @param {KoattyApplication} app
-     * @memberof Loader
-     */
-    static initialize(app) {
-        if (app.env == 'development') {
-            Logger.setLevel("debug");
-        }
-        else {
-            Logger.setLevel("info");
-        }
-        // define path
-        const rootPath = app.rootPath || process.cwd();
-        const appPath = app.appPath || path__namespace.resolve(rootPath, app.appDebug ? 'src' : 'dist');
-        const koattyPath = path__namespace.resolve(__dirname, '..');
-        koatty_lib.Helper.define(app, 'rootPath', rootPath);
-        koatty_lib.Helper.define(app, 'appPath', appPath);
-        koatty_lib.Helper.define(app, 'koattyPath', koattyPath);
-        // 
-        if (koatty_lib.Helper.isEmpty(app.name)) {
-            const pkg = koatty_lib.Helper.safeRequire(`${path__namespace.dirname(appPath)}/package.json`);
-            if (pkg.name) {
-                app.name = pkg.name;
-                app.version = app.version || pkg.version;
-            }
-        }
-        process.env.ROOT_PATH = rootPath;
-        process.env.APP_PATH = appPath;
-        process.env.KOATTY_PATH = koattyPath;
-        // Compatible with old version, will be deprecated
-        koatty_lib.Helper.define(app, 'thinkPath', koattyPath);
-        process.env.THINK_PATH = koattyPath;
-    }
-    /**
-     * Get component metadata
-     *
-     * @static
-     * @param {KoattyApplication} app
-     * @param {*} target
-     * @returns {*}  {any[]}
-     * @memberof Loader
-     */
-    static GetComponentMeta(app, target) {
-        let componentMetas = [];
-        const componentMeta = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, target);
-        if (componentMeta) {
-            if (koatty_lib.Helper.isArray(componentMeta)) {
-                componentMetas = componentMeta;
-            }
-            else {
-                componentMetas.push(componentMeta);
-            }
-        }
-        if (componentMetas.length < 1) {
-            componentMetas = [app.appPath];
-        }
-        return componentMetas;
-    }
-    /**
-     * Get configuration metadata
-     *
-     * @static
-     * @param {KoattyApplication} app
-     * @param {*} target
-     * @returns {*}  {any[]}
-     * @memberof Loader
-     */
-    static GetConfigurationMeta(app, target) {
-        const confMeta = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, target);
-        let configurationMetas = [];
-        if (confMeta) {
-            if (koatty_lib.Helper.isArray(confMeta)) {
-                configurationMetas = confMeta;
-            }
-            else {
-                configurationMetas.push(confMeta);
-            }
-        }
-        return configurationMetas;
-    }
-    /**
-     * Load all bean, excepted config/*、App.ts
-     *
-     * @static
-     * @param {KoattyApplication} app
-     * @param {*} target
-     * @memberof Loader
-     */
-    static CheckAllComponents(app, target) {
-        // component metadata
-        const componentMetas = Loader.GetComponentMeta(app, target);
-        // configuration metadata
-        const configurationMetas = Loader.GetConfigurationMeta(app, target);
-        const exSet = new Set();
-        koatty_loader.Load(componentMetas, '', (fileName, xpath, xTarget) => {
-            checkClass(fileName, xpath, xTarget, exSet);
-        }, ['**/**.js', '**/**.ts', '!**/**.d.ts'], [...configurationMetas, `${target.name || '.no'}.ts`]);
-        exSet.clear();
-    }
-    /**
-     * Set Logger level
-     *
-     * @static
-     * @param {KoattyApplication} app
-     * @memberof Loader
-     */
-    static SetLogger(app) {
-        const data = app.getMetaData('_configs') || [];
-        const configs = data[0] || {};
-        //Logger
-        if (configs.config) {
-            const opt = configs.config;
-            let logLevel = "debug", logFilePath = "", sensFields = [];
-            if (app.env === "production") {
-                logLevel = "info";
-            }
-            if (opt.logs_level) {
-                logLevel = (opt.logs_level).toLowerCase();
-            }
-            if (opt.logs_path) {
-                logFilePath = opt.logs_path;
-            }
-            if (opt.sens_fields) {
-                sensFields = opt.sens_fields;
-            }
-            SetLogger(app, { logLevel, logFilePath, sensFields });
-        }
+  constructor(e) {
+    this.app = e;
+  }
+  static initialize(e) {
+    if (e.env == "development") g.setLevel("debug"); else g.setLevel("info");
+    const t = e.rootPath || process.cwd();
+    const o = e.appPath || f.resolve(t, e.appDebug ? "src" : "dist");
+    const r = f.resolve(__dirname, "..");
+    a.Helper.define(e, "rootPath", t);
+    a.Helper.define(e, "appPath", o);
+    a.Helper.define(e, "koattyPath", r);
+    if (a.Helper.isEmpty(e.name)) {
+      const t = a.Helper.safeRequire(`${f.dirname(o)}/package.json`);
+      if (t.name) {
+        e.name = t.name;
+        e.version = e.version || t.version;
+      }
     }
-    /**
-     * Load app event hook funcs
-     *
-     * @static
-     * @param {KoattyApplication} app
-     * @param {*} target
-     * @memberof Loader
-     */
-    static LoadAppEventHooks(app, target) {
-        const eventFuncs = new Map();
-        for (const event of koatty_core.AppEventArr) {
-            let funcs;
-            switch (event) {
-                case "appBoot" /* AppEvent.appBoot */:
-                    funcs = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, "appBoot" /* AppEvent.appBoot */, target);
-                    if (koatty_lib.Helper.isArray(funcs)) {
-                        eventFuncs.set("appBoot" /* AppEvent.appBoot */, funcs);
-                    }
-                    break;
-                case "appReady" /* AppEvent.appReady */:
-                    funcs = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, "appReady" /* AppEvent.appReady */, target);
-                    if (koatty_lib.Helper.isArray(funcs)) {
-                        eventFuncs.set("appReady" /* AppEvent.appReady */, funcs);
-                    }
-                    break;
-                case "appStart" /* AppEvent.appStart */:
-                    funcs = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, "appStart" /* AppEvent.appStart */, target);
-                    if (koatty_lib.Helper.isArray(funcs)) {
-                        eventFuncs.set("appStart" /* AppEvent.appStart */, funcs);
-                    }
-                    break;
-                case "appStop" /* AppEvent.appStop */:
-                    funcs = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, "appStop" /* AppEvent.appStop */, target);
-                    if (koatty_lib.Helper.isArray(funcs)) {
-                        eventFuncs.set("appStop" /* AppEvent.appStop */, funcs);
-                    }
-                    break;
-            }
-        }
-        // loop event emit
-        for (const [event, funcs] of eventFuncs) {
-            for (const func of funcs) {
-                app.once(event, () => func(app));
-            }
-        }
+    process.env.ROOT_PATH = t;
+    process.env.APP_PATH = o;
+    process.env.KOATTY_PATH = r;
+    a.Helper.define(e, "thinkPath", r);
+    process.env.THINK_PATH = r;
+  }
+  static GetComponentMeta(e, o) {
+    let r = [];
+    const n = t.IOC.getClassMetadata(t.TAGGED_CLS, E, o);
+    if (n) if (a.Helper.isArray(n)) r = n; else r.push(n);
+    if (r.length < 1) r = [ e.appPath ];
+    return r;
+  }
+  static GetConfigurationMeta(e, o) {
+    const r = t.IOC.getClassMetadata(t.TAGGED_CLS, O, o);
+    let n = [];
+    if (r) if (a.Helper.isArray(r)) n = r; else n.push(r);
+    return n;
+  }
+  static CheckAllComponents(e, t) {
+    const o = Loader.GetComponentMeta(e, t);
+    const r = Loader.GetConfigurationMeta(e, t);
+    const a = new Set;
+    i.Load(o, "", ((e, t, o) => {
+      m(e, t, o, a);
+    }), [ "**/**.js", "**/**.ts", "!**/**.d.ts" ], [ ...r, `${t.name || ".no"}.ts` ]);
+    a.clear();
+  }
+  static SetLogger(e) {
+    const t = e.getMetaData("_configs") || [];
+    const o = t[0] || {};
+    if (o.config) {
+      const t = o.config;
+      let r = "debug", a = "", n = [];
+      if (e.env === "production") r = "info";
+      if (t.logsLevel) r = t.logsLevel.toLowerCase();
+      if (t.logsPath) a = t.logsPath;
+      if (t.sensFields) n = t.sensFields;
+      h(e, {
+        logLevel: r,
+        logFilePath: a,
+        sensFields: n
+      });
     }
-    /**
-     * @description: Load all components
-     * @param {KoattyApplication} app
-     * @param {any} target
-     * @return {*}
-     */
-    static async LoadAllComponents(app, target) {
-        var _a;
-        // Load configuration
-        Logger.Log('Koatty', '', 'Load Configurations ...');
-        // configuration metadata
-        const configurationMeta = Loader.GetConfigurationMeta(app, target);
-        const loader = new Loader(app);
-        loader.LoadConfigs(configurationMeta);
-        // Create Server
-        const protocol = app.config('protocol');
-        const serveOpts = {
-            hostname: app.config('app_host'),
-            port: app.config('app_port'),
-            protocol: protocol,
-        };
-        koatty_lib.Helper.define(app, "server", koatty_serve.NewServe(app, serveOpts));
-        // Create router 
-        const routerOpts = (_a = app.config(undefined, 'router')) !== null && _a !== void 0 ? _a : {};
-        koatty_lib.Helper.define(app, "router", koatty_router.NewRouter(app, { protocol, ...routerOpts }));
-        // Load Components
-        Logger.Log('Koatty', '', 'Load Components ...');
-        await loader.LoadComponents();
-        // Load Middleware
-        Logger.Log('Koatty', '', 'Load Middlewares ...');
-        await loader.LoadMiddlewares();
-        // Load Services
-        Logger.Log('Koatty', '', 'Load Services ...');
-        await loader.LoadServices();
-        // Load Controllers
-        Logger.Log('Koatty', '', 'Load Controllers ...');
-        const controllers = await loader.LoadControllers();
-        // Load Routers
-        Logger.Log('Koatty', '', 'Load Routers ...');
-        loader.LoadRouter(controllers);
+  }
+  static LoadAppEventHooks(e, r) {
+    const n = new Map;
+    for (const e of o.AppEventArr) {
+      let o;
+      switch (e) {
+       case "appBoot":
+        o = t.IOC.getClassMetadata(t.TAGGED_CLS, "appBoot", r);
+        if (a.Helper.isArray(o)) n.set("appBoot", o);
+        break;
+
+       case "appReady":
+        o = t.IOC.getClassMetadata(t.TAGGED_CLS, "appReady", r);
+        if (a.Helper.isArray(o)) n.set("appReady", o);
+        break;
+
+       case "appStart":
+        o = t.IOC.getClassMetadata(t.TAGGED_CLS, "appStart", r);
+        if (a.Helper.isArray(o)) n.set("appStart", o);
+        break;
+
+       case "appStop":
+        o = t.IOC.getClassMetadata(t.TAGGED_CLS, "appStop", r);
+        if (a.Helper.isArray(o)) n.set("appStop", o);
+        break;
+      }
     }
-    /**
-     * Load configuration
-     *
-     * @param {string[]} [loadPath]
-     * @memberof Loader
-     */
-    LoadConfigs(loadPath) {
-        const frameConfig = {};
-        // Logger.Debug(`Load configuration path: ${app.thinkPath}/config`);
-        koatty_loader.Load(["./config"], this.app.koattyPath, function (name, path, exp) {
-            frameConfig[name] = exp;
+    for (const [t, o] of n) for (const r of o) e.once(t, (() => r(e)));
+  }
+  static async LoadAllComponents(e, t) {
+    var o, r, s;
+    g.Log("Koatty", "", "Load Configurations ...");
+    const i = Loader.GetConfigurationMeta(e, t);
+    const c = new Loader(e);
+    c.LoadConfigs(i);
+    const p = (o = e.config("server")) !== null && o !== void 0 ? o : {
+      protocol: "http"
+    };
+    const f = (r = p.protocol) !== null && r !== void 0 ? r : "http";
+    a.Helper.define(e, "server", l.NewServe(e, p));
+    const d = (s = e.config(void 0, "router")) !== null && s !== void 0 ? s : {};
+    a.Helper.define(e, "router", n.NewRouter(e, {
+      protocol: f,
+      ...d
+    }));
+    g.Log("Koatty", "", "Load Components ...");
+    await c.LoadComponents();
+    g.Log("Koatty", "", "Load Middlewares ...");
+    await c.LoadMiddlewares();
+    g.Log("Koatty", "", "Load Services ...");
+    await c.LoadServices();
+    g.Log("Koatty", "", "Load Controllers ...");
+    const u = await c.LoadControllers();
+    g.Log("Koatty", "", "Load Routers ...");
+    c.LoadRouter(u);
+  }
+  LoadConfigs(t) {
+    const o = {};
+    i.Load([ "./config" ], this.app.koattyPath, (function(e, t, r) {
+      o[e] = r;
+    }));
+    if (a.Helper.isArray(t)) t = t.length > 0 ? t : [ "./config" ];
+    let r = e.LoadConfigs(t, this.app.appPath);
+    r = a.Helper.extend(o, r, !0);
+    this.app.setMetaData("_configs", r);
+  }
+  async LoadMiddlewares() {
+    var e;
+    let r = this.app.config(void 0, "middleware");
+    if (a.Helper.isEmpty(r)) r = {
+      config: {},
+      list: [],
+      routeList: []
+    };
+    const n = (e = t.IOC.listClass("MIDDLEWARE")) !== null && e !== void 0 ? e : [];
+    n.forEach((e => {
+      var r;
+      e.id = ((r = e.id) !== null && r !== void 0 ? r : "").replace("MIDDLEWARE:", "");
+      if (e.id && a.Helper.isClass(e.target)) {
+        t.IOC.reg(e.id, e.target, {
+          scope: "Prototype",
+          type: "MIDDLEWARE",
+          args: []
         });
-        if (koatty_lib.Helper.isArray(loadPath)) {
-            loadPath = loadPath.length > 0 ? loadPath : ["./config"];
-        }
-        let appConfig = koatty_config.LoadConfigs(loadPath, this.app.appPath);
-        appConfig = koatty_lib.Helper.extend(frameConfig, appConfig, true);
-        this.app.setMetaData("_configs", appConfig);
+        const r = t.IOC.getInsByClass(e.target);
+        if (!o.implementsMiddlewareInterface(r)) throw Error(`The middleware ${e.id} must implements interface 'IMiddleware'.`);
+      }
+    }));
+    const s = r.list || [];
+    const i = new Set([]);
+    s.forEach((e => {
+      i.add(e);
+    }));
+    const l = r.routeList || [];
+    const c = new Set([]);
+    l.forEach((e => {
+      c.add(e);
+    }));
+    const p = r.config || {};
+    for (const e of i) {
+      const o = t.IOC.get(e, "MIDDLEWARE");
+      if (!o) throw Error(`Middleware ${e} load error.`);
+      if (!a.Helper.isFunction(o.run)) throw Error(`The middleware ${e} must implements interface 'IMiddleware'.`);
+      g.Debug(`Load middleware: ${e}`);
+      const r = p[e] || {};
+      const n = await o.run(r, this.app);
+      if (a.Helper.isFunction(n)) if (n.length < 3) this.app.use(n); else this.app.useExp(n);
     }
-    /**
-     * Load middlewares
-     * [async]
-     * @memberof Loader
-     */
-    async LoadMiddlewares() {
-        var _a;
-        let middlewareConf = this.app.config(undefined, "middleware");
-        if (koatty_lib.Helper.isEmpty(middlewareConf)) {
-            middlewareConf = { config: {}, list: [] };
-        }
-        //Mount default middleware
-        // Load(loadPath || ["./middleware"], app.koattyPath);
-        //Mount application middleware
-        // const middleware: any = {};
-        const appMiddleware = (_a = koatty_container.IOC.listClass("MIDDLEWARE")) !== null && _a !== void 0 ? _a : [];
-        appMiddleware.forEach((item) => {
-            var _a;
-            item.id = ((_a = item.id) !== null && _a !== void 0 ? _a : "").replace("MIDDLEWARE:", "");
-            if (item.id && koatty_lib.Helper.isClass(item.target)) {
-                koatty_container.IOC.reg(item.id, item.target, { scope: "Prototype", type: "MIDDLEWARE", args: [] });
-                const ctl = koatty_container.IOC.getInsByClass(item.target);
-                if (!koatty_core.implementsMiddlewareInterface(ctl)) {
-                    throw Error(`The middleware ${item.id} must implements interface 'IMiddleware'.`);
-                }
-            }
-        });
-        const middlewareConfList = middlewareConf.list || [];
-        //de-duplication
-        const appMList = new Set([]);
-        middlewareConfList.forEach((item) => {
-            appMList.add(item);
-        });
-        //Automatically call middleware
-        const middlewareConfig = middlewareConf.config || {};
-        for (const key of appMList) {
-            const handle = koatty_container.IOC.get(key, "MIDDLEWARE");
-            if (!handle) {
-                throw Error(`Middleware ${key} load error.`);
-            }
-            if (!koatty_lib.Helper.isFunction(handle.run)) {
-                throw Error(`The middleware ${key} must implements interface 'IMiddleware'.`);
-            }
-            // if (middlewareConfig[key] === false) {
-            //   Logger.Warn(`The middleware ${key} has been loaded but not executed.`);
-            //   continue;
-            // }
-            Logger.Debug(`Load middleware: ${key}`);
-            const middlewareOpt = middlewareConfig[key] || {};
-            const result = await handle.run(middlewareOpt, this.app);
-            if (koatty_lib.Helper.isFunction(result)) {
-                if (result.length < 3) {
-                    this.app.use(result);
-                }
-                else {
-                    this.app.useExp(result);
-                }
-            }
-        }
+    for (const e of c) {
+      const r = t.IOC.get(e, "MIDDLEWARE");
+      if (!r) throw Error(`Router middleware ${e} load error.`);
+      if (!a.Helper.isFunction(r.run)) throw Error(`The router middleware ${e} must implements interface 'IMiddleware'.`);
+      g.Debug(`Load router middleware: ${e}`);
+      const n = await r.run(p[e] || {}, this.app);
+      if (a.Helper.isFunction(n)) this.app.setMetaData(`routerMiddleware_${e}`, n.length > 2 ? o.parseExp(n) : n);
     }
-    /**
-     * Load controllers
-     *
-     * @memberof Loader
-     */
-    async LoadControllers() {
-        const controllerList = koatty_container.IOC.listClass("CONTROLLER");
-        const controllers = [];
-        controllerList.forEach((item) => {
-            var _a;
-            item.id = ((_a = item.id) !== null && _a !== void 0 ? _a : "").replace("CONTROLLER:", "");
-            if (item.id && koatty_lib.Helper.isClass(item.target)) {
-                Logger.Debug(`Load controller: ${item.id}`);
-                // registering to IOC
-                koatty_container.IOC.reg(item.id, item.target, { scope: "Prototype", type: "CONTROLLER", args: [] });
-                const ctl = koatty_container.IOC.getInsByClass(item.target);
-                if (!koatty_core.implementsControllerInterface(ctl)) {
-                    throw Error(`The controller ${item.id} must implements interface 'IController'.`);
-                }
-                controllers.push(item.id);
-            }
+  }
+  async LoadControllers() {
+    const e = t.IOC.listClass("CONTROLLER");
+    const r = [];
+    e.forEach((e => {
+      var n;
+      e.id = ((n = e.id) !== null && n !== void 0 ? n : "").replace("CONTROLLER:", "");
+      if (e.id && a.Helper.isClass(e.target)) {
+        g.Debug(`Load controller: ${e.id}`);
+        t.IOC.reg(e.id, e.target, {
+          scope: "Prototype",
+          type: "CONTROLLER",
+          args: []
         });
-        return controllers;
-    }
-    /**
-     * Load services
-     *
-     * @memberof Loader
-     */
-    async LoadServices() {
-        const serviceList = koatty_container.IOC.listClass("SERVICE");
-        serviceList.forEach((item) => {
-            var _a;
-            item.id = ((_a = item.id) !== null && _a !== void 0 ? _a : "").replace("SERVICE:", "");
-            if (item.id && koatty_lib.Helper.isClass(item.target)) {
-                Logger.Debug(`Load service: ${item.id}`);
-                // registering to IOC
-                koatty_container.IOC.reg(item.id, item.target, { scope: "Singleton", type: "SERVICE", args: [] });
-                const ctl = koatty_container.IOC.getInsByClass(item.target);
-                if (!koatty_core.implementsServiceInterface(ctl)) {
-                    throw Error(`The service ${item.id} must implements interface 'IService'.`);
-                }
-            }
+        const a = t.IOC.getInsByClass(e.target);
+        if (!o.implementsControllerInterface(a)) throw Error(`The controller ${e.id} must implements interface 'IController'.`);
+        r.push(e.id);
+      }
+    }));
+    return r;
+  }
+  async LoadServices() {
+    const e = t.IOC.listClass("SERVICE");
+    e.forEach((e => {
+      var r;
+      e.id = ((r = e.id) !== null && r !== void 0 ? r : "").replace("SERVICE:", "");
+      if (e.id && a.Helper.isClass(e.target)) {
+        g.Debug(`Load service: ${e.id}`);
+        t.IOC.reg(e.id, e.target, {
+          scope: "Singleton",
+          type: "SERVICE",
+          args: []
         });
-    }
-    /**
-     * Load components
-     *
-     * @memberof Loader
-     */
-    async LoadComponents() {
-        var _a, _b;
-        const componentList = koatty_container.IOC.listClass("COMPONENT");
-        const pluginList = [];
-        componentList.forEach(async (item) => {
-            var _a;
-            item.id = ((_a = item.id) !== null && _a !== void 0 ? _a : "").replace("COMPONENT:", "");
-            if (koatty_lib.Helper.isClass(item.target)) {
-                // registering to IOC
-                koatty_container.IOC.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
-                if (item.id && (item.id).endsWith("Plugin")) {
-                    const ctl = koatty_container.IOC.getInsByClass(item.target);
-                    if (!koatty_core.implementsPluginInterface(ctl)) {
-                        throw Error(`The plugin ${item.id} must implements interface 'IPlugin'.`);
-                    }
-                    pluginList.push(item.id);
-                }
-                if (item.id && (item.id).endsWith("Aspect")) {
-                    const ctl = koatty_container.IOC.getInsByClass(item.target);
-                    if (!koatty_core.implementsAspectInterface(ctl)) {
-                        throw Error(`The aspect ${item.id} must implements interface 'IAspect'.`);
-                    }
-                }
-            }
+        const r = t.IOC.getInsByClass(e.target);
+        if (!o.implementsServiceInterface(r)) throw Error(`The service ${e.id} must implements interface 'IService'.`);
+      }
+    }));
+  }
+  async LoadComponents() {
+    var e, r;
+    const n = t.IOC.listClass("COMPONENT");
+    const s = [];
+    n.forEach((async e => {
+      var r;
+      e.id = ((r = e.id) !== null && r !== void 0 ? r : "").replace("COMPONENT:", "");
+      if (a.Helper.isClass(e.target)) {
+        t.IOC.reg(e.id, e.target, {
+          scope: "Singleton",
+          type: "COMPONENT",
+          args: []
         });
-        // load plugin config
-        let pluginsConf = this.app.config(undefined, "plugin");
-        if (koatty_lib.Helper.isEmpty(pluginsConf)) {
-            pluginsConf = { config: {}, list: [] };
+        if (e.id && e.id.endsWith("Plugin")) {
+          const r = t.IOC.getInsByClass(e.target);
+          if (!o.implementsPluginInterface(r)) throw Error(`The plugin ${e.id} must implements interface 'IPlugin'.`);
+          s.push(e.id);
         }
-        const pluginConfList = (_a = pluginsConf.list) !== null && _a !== void 0 ? _a : [];
-        // load plugin list
-        for (const key of pluginConfList) {
-            const handle = koatty_container.IOC.get(key, "COMPONENT");
-            if (!handle) {
-                throw Error(`Plugin ${key} load error.`);
-            }
-            if (!koatty_lib.Helper.isFunction(handle.run)) {
-                throw Error(`Plugin ${key} must implements interface 'IPlugin'.`);
-            }
-            if (pluginsConf.config[key] === false) {
-                Logger.Warn(`Plugin ${key} already loaded but not effective.`);
-                continue;
-            }
-            // sync exec 
-            await handle.run((_b = pluginsConf.config[key]) !== null && _b !== void 0 ? _b : {}, this.app);
+        if (e.id && e.id.endsWith("Aspect")) {
+          const r = t.IOC.getInsByClass(e.target);
+          if (!o.implementsAspectInterface(r)) throw Error(`The aspect ${e.id} must implements interface 'IAspect'.`);
         }
+      }
+    }));
+    let i = this.app.config(void 0, "plugin");
+    if (a.Helper.isEmpty(i)) i = {
+      config: {},
+      list: []
+    };
+    const l = (e = i.list) !== null && e !== void 0 ? e : [];
+    for (const e of l) {
+      const o = t.IOC.get(e, "COMPONENT");
+      if (!o) throw Error(`Plugin ${e} load error.`);
+      if (!a.Helper.isFunction(o.run)) throw Error(`Plugin ${e} must implements interface 'IPlugin'.`);
+      if (i.config[e] === !1) {
+        g.Warn(`Plugin ${e} already loaded but not effective.`);
+        continue;
+      }
+      await o.run((r = i.config[e]) !== null && r !== void 0 ? r : {}, this.app);
     }
-    /**
-     * @description: load router
-     * @param {string} ctls
-     * @return {*}
-     */
-    async LoadRouter(ctls) {
-        // load router
-        await this.app.router.LoadRouter(this.app, ctls);
-    }
+  }
+  async LoadRouter(e) {
+    await this.app.router.LoadRouter(this.app, e);
+  }
 }
 
 /*
@@ -612,229 +409,147 @@ class Loader {
  * @LastEditTime: 2025-01-14 16:11:21
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
- */
-/**
- * Bootstrap application decorator
- *
- * @export
- * @param {Function} [bootFunc]
- * @returns {ClassDecorator}
- */
-function Bootstrap(bootFunc) {
-    return function (target) {
-        if (!(target.prototype instanceof koatty_core.Koatty)) {
-            throw new Error(`class does not inherit from Koatty`);
-        }
-        executeBootstrap(target, bootFunc);
-    };
+ */ function I(e) {
+  return function(t) {
+    if (!(t.prototype instanceof o.Koatty)) throw new Error(`class does not inherit from Koatty`);
+    S(t, e);
+  };
 }
-/**
- * Actively perform dependency injection
- * Parse the decorator, return the instantiated app.
- * @export  ExecBootStrap
- * @param {Function} [bootFunc] callback function
- * @returns
- */
-function ExecBootStrap(bootFunc) {
-    return async (target) => {
-        if (!(target.prototype instanceof koatty_core.Koatty)) {
-            throw new Error(`class ${target.name} does not inherit from Koatty`);
-        }
-        return await executeBootstrap(target, bootFunc, true);
-    };
+
+function P(e) {
+  return async t => {
+    if (!(t.prototype instanceof o.Koatty)) throw new Error(`class ${t.name} does not inherit from Koatty`);
+    return await S(t, e, !0);
+  };
 }
-/**
- * Define project scan path
- *
- * @export
- * @param {(string | string[])} [scanPath]
- * @returns {ClassDecorator}
- */
-function ComponentScan(scanPath) {
-    return (target) => {
-        if (!(target.prototype instanceof koatty_core.Koatty)) {
-            throw new Error(`class does not inherit from Koatty`);
-        }
-        scanPath = scanPath !== null && scanPath !== void 0 ? scanPath : '';
-        koatty_container.IOC.saveClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, scanPath, target);
-    };
+
+function b(e) {
+  return r => {
+    if (!(r.prototype instanceof o.Koatty)) throw new Error(`class does not inherit from Koatty`);
+    e = e !== null && e !== void 0 ? e : "";
+    t.IOC.saveClassMetadata(t.TAGGED_CLS, E, e, r);
+  };
 }
-/**
- * Define project configuration scan path
- *
- * @export
- * @param {(string | string[])} [scanPath]
- * @returns {ClassDecorator}
- */
-function ConfigurationScan(scanPath) {
-    return (target) => {
-        if (!(target.prototype instanceof koatty_core.Koatty)) {
-            throw new Error(`class does not inherit from Koatty`);
-        }
-        scanPath = scanPath !== null && scanPath !== void 0 ? scanPath : '';
-        koatty_container.IOC.saveClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, scanPath, target);
-    };
+
+function A(e) {
+  return r => {
+    if (!(r.prototype instanceof o.Koatty)) throw new Error(`class does not inherit from Koatty`);
+    e = e !== null && e !== void 0 ? e : "";
+    t.IOC.saveClassMetadata(t.TAGGED_CLS, O, e, r);
+  };
 }
-/**
- * @description: bind App event hook func
- * example:
- * export function TestDecorator(): ClassDecorator {
- *  return (target: Function) => {
- *   BindEventHook(AppEvent.appBoot, (app: KoattyApplication) => {
- *      // todo
- *      return Promise.resolve();
- *   }, target)
- *  }
- * }
- * @param {AppEvent} eventName
- * @param {EventHookFunc} eventFunc
- * @param {any} target
- * @return {*}
- */
-function BindEventHook(eventName, eventFunc, target) {
-    koatty_container.IOC.attachClassMetadata(koatty_container.TAGGED_CLS, eventName, eventFunc, target);
+
+function H(e, o, r) {
+  t.IOC.attachClassMetadata(t.TAGGED_CLS, e, o, r);
 }
-/**
- * execute bootstrap
- *
- * @param {*} target
- * @param {Function} bootFunc
- * @param {boolean} [isInitiative=false] Whether to actively execute app instantiation,
- * mainly for unittest scenarios, you need to actively obtain app instances
- * @returns {Promise<void>}
- */
-const executeBootstrap = async function (target, bootFunc, isInitiative = false) {
-    // checked runtime
-    checkRuntime();
-    // unittest running environment
-    const isUTRuntime = checkUTRuntime();
-    if (!isInitiative && isUTRuntime) {
-        return;
-    }
-    const app = Reflect.construct(target, []);
-    // unittest does not print startup logs
-    if (isUTRuntime) {
-        app.silent = true;
-        Logger.enable(false);
-    }
-    try {
-        if (!app.silent)
-            Logger.Log("Koatty", LOGO);
-        if (!(app instanceof koatty_core.Koatty)) {
-            throw new Error(`class ${target.name} does not inherit from Koatty`);
-        }
-        // Initialize env
-        Loader.initialize(app);
-        // exec bootFunc
-        if (koatty_lib.Helper.isFunction(bootFunc)) {
-            Logger.Log('Koatty', '', 'Execute bootFunc ...');
-            await bootFunc(app);
-        }
-        // Set IOC.app
-        koatty_container.IOC.setApp(app);
-        // Check all bean
-        Logger.Log('Koatty', '', 'ComponentScan ...');
-        Loader.CheckAllComponents(app, target);
-        // Load App event hooks
-        Loader.LoadAppEventHooks(app, target);
-        Logger.Log('Koatty', '', 'Emit App Boot ...');
-        await asyncEvent(app, "appBoot" /* AppEvent.appBoot */);
-        // Load All components
-        await Loader.LoadAllComponents(app, target);
-        // Emit app ready event
-        Logger.Log('Koatty', '', 'Emit App Ready ...');
-        await asyncEvent(app, "appReady" /* AppEvent.appReady */);
-        if (!isUTRuntime) {
-            // Start Server
-            app.listen(listenCallback);
-        }
-        return app;
-    }
-    catch (err) {
-        Logger.Error(err);
-        process.exit();
-    }
-};
-/**
- * Listening callback function
- *
- * @param {Koatty} app
- * @returns {*}
- */
-const listenCallback = (app) => {
-    let servers = [];
-    if (!Array.isArray(app.server)) {
-        servers = [app.server];
-    }
-    else {
-        servers = app.server;
+
+const S = async function(e, r, n = !1) {
+  L();
+  const s = v();
+  if (!n && s) return;
+  const i = Reflect.construct(e, []);
+  if (s) {
+    i.silent = !0;
+    g.enable(!1);
+  }
+  try {
+    if (!i.silent) g.Log("Koatty", w);
+    if (!(i instanceof o.Koatty)) throw new Error(`class ${e.name} does not inherit from Koatty`);
+    Loader.initialize(i);
+    if (a.Helper.isFunction(r)) {
+      g.Log("Koatty", "", "Execute bootFunc ...");
+      await r(i);
     }
-    Logger.Log('Koatty', '', '====================================');
-    Logger.Log("Koatty", "", `Nodejs Version: ${process.version}`);
-    Logger.Log("Koatty", "", `Koatty Version: v${KOATTY_VERSION}`);
-    Logger.Log("Koatty", "", `App Environment: ${app.env}`);
-    servers.forEach(s => {
-        Logger.Log('Koatty', '', `Server: ${(s.options.protocol).toUpperCase()} running at ${s.options.protocol === "http2" ?
-            "https" : s.options.protocol}://${s.options.hostname || '127.0.0.1'}:${s.options.port}/`);
-    });
-    Logger.Log("Koatty", "", "====================================");
-    if (app.appDebug)
-        Logger.Warn(`Running in debug mode.`);
-    // Set Logger
-    Loader.SetLogger(app);
+    t.IOC.setApp(i);
+    g.Log("Koatty", "", "ComponentScan ...");
+    Loader.CheckAllComponents(i, e);
+    Loader.LoadAppEventHooks(i, e);
+    g.Log("Koatty", "", "Emit App Boot ...");
+    await o.asyncEvent(i, "appBoot");
+    await Loader.LoadAllComponents(i, e);
+    g.Log("Koatty", "", "Emit App Ready ...");
+    await o.asyncEvent(i, "appReady");
+    if (!s) i.listen(M);
+    return i;
+  } catch (e) {
+    g.Error(e);
+    process.exit();
+  }
 };
-/**
- * Execute event as async
- *
- * @param {Koatty} event
- * @param {string} eventName
- */
-const asyncEvent = async function (event, eventName) {
-    const ls = event.listeners(eventName);
-    // eslint-disable-next-line no-restricted-syntax
-    for await (const func of ls) {
-        if (koatty_lib.Helper.isFunction(func)) {
-            func();
-        }
-    }
-    return event.removeAllListeners(eventName);
+
+const M = e => {
+  let t = [];
+  if (!Array.isArray(e.server)) t = [ e.server ]; else t = e.server;
+  g.Log("Koatty", "", "====================================");
+  g.Log("Koatty", "", `Nodejs Version: ${process.version}`);
+  g.Log("Koatty", "", `Koatty Version: v${y}`);
+  g.Log("Koatty", "", `App Environment: ${e.env}`);
+  t.forEach((e => {
+    g.Log("Koatty", "", `Server: ${e.options.protocol.toUpperCase()} running at ${e.options.protocol === "http2" ? "https" : e.options.protocol}://${e.options.hostname || "127.0.0.1"}:${e.options.port}/`);
+  }));
+  g.Log("Koatty", "", "====================================");
+  if (e.appDebug) g.Warn(`Running in debug mode.`);
+  Loader.SetLogger(e);
 };
 
 Object.defineProperty(exports, "Config", {
-  enumerable: true,
-  get: function () { return koatty_config.Config; }
+  enumerable: !0,
+  get: function() {
+    return e.Config;
+  }
 });
+
 Object.defineProperty(exports, "Helper", {
-  enumerable: true,
-  get: function () { return koatty_lib.Helper; }
+  enumerable: !0,
+  get: function() {
+    return a.Helper;
+  }
 });
-exports.BindEventHook = BindEventHook;
-exports.Bootstrap = Bootstrap;
-exports.ComponentScan = ComponentScan;
-exports.ConfigurationScan = ConfigurationScan;
-exports.ExecBootStrap = ExecBootStrap;
-exports.Logger = Logger;
-Object.keys(koatty_container).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return koatty_container[k]; }
+
+exports.BindEventHook = H;
+
+exports.Bootstrap = I;
+
+exports.ComponentScan = b;
+
+exports.ConfigurationScan = A;
+
+exports.ExecBootStrap = P;
+
+exports.Logger = g;
+
+Object.keys(t).forEach((function(e) {
+  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
+    enumerable: !0,
+    get: function() {
+      return t[e];
+    }
   });
-});
-Object.keys(koatty_core).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return koatty_core[k]; }
+}));
+
+Object.keys(o).forEach((function(e) {
+  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
+    enumerable: !0,
+    get: function() {
+      return o[e];
+    }
   });
-});
-Object.keys(koatty_exception).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return koatty_exception[k]; }
+}));
+
+Object.keys(r).forEach((function(e) {
+  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
+    enumerable: !0,
+    get: function() {
+      return r[e];
+    }
   });
-});
-Object.keys(koatty_router).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return koatty_router[k]; }
+}));
+
+Object.keys(n).forEach((function(e) {
+  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
+    enumerable: !0,
+    get: function() {
+      return n[e];
+    }
   });
-});
+}));