koatty 3.11.4-2 → 3.11.7

package/dist/index.js

@@ -1,24 +1,22 @@
 /*!
 * @Author: richen
-* @Date: 2024-04-15 05:09:24
+* @Date: 2024-12-06 09:38:17
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
 'use strict';
 
-var koatty_router = require('koatty_router');
+var koatty_config = require('koatty_config');
 var koatty_container = require('koatty_container');
 var koatty_core = require('koatty_core');
-var koatty_serve = require('koatty_serve');
-var path = require('path');
-var koatty_loader = require('koatty_loader');
 var koatty_exception = require('koatty_exception');
-var koatty_config = require('koatty_config');
-var koatty_trace = require('koatty_trace');
+var koatty_router = require('koatty_router');
 var koatty_lib = require('koatty_lib');
 var koatty_logger = require('koatty_logger');
-require('reflect-metadata');
+var koatty_loader = require('koatty_loader');
+var koatty_serve = require('koatty_serve');
+var path = require('path');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -39,75 +37,12 @@ function _interopNamespaceDefault(e) {
 
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
-function TraceHandler(app) {
-    const timeout = (app.config('http_timeout') || 10) * 1000;
-    const encoding = app.config('encoding') || 'utf-8';
-    const openTrace = app.config("open_trace") || false;
-    const asyncHooks = app.config("async_hooks") || false;
-    const options = {
-        RequestIdHeaderName: app.config('trace_header') || 'X-Request-Id',
-        RequestIdName: app.config('trace_id') || "requestId",
-        IdFactory: undefined,
-        Timeout: timeout,
-        Encoding: encoding,
-        OpenTrace: openTrace,
-        AsyncHooks: asyncHooks,
-    };
-    app.use(koatty_trace.Trace(options, app));
-}
-
-/*
- * @Description: framework helper
- * @Usage:
- * @Author: richen
- * @Date: 2023-12-09 21:56:32
- * @LastEditTime: 2024-01-16 01:20:17
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
- */
-/**
- * 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;
-}
-
 /*
  * @Description: framework logger
  * @Usage:
  * @Author: richen
  * @Date: 2023-12-09 21:56:32
- * @LastEditTime: 2023-12-09 23:02:27
+ * @LastEditTime: 2024-10-31 17:52:43
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
  */
@@ -137,125 +72,98 @@ function SetLogger(app, config) {
     }
 }
 
+var version = "3.11.7";
+var engines = {
+	node: ">12.0.0"
+};
+
 /*
- * @Description: component interface
+ * @Description: framework runtime checker
  * @Usage:
  * @Author: richen
  * @Date: 2023-12-09 21:56:32
- * @LastEditTime: 2024-01-19 08:36:27
+ * @LastEditTime: 2023-12-09 23:01:22
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
  */
-// tslint:disable-next-line: no-import-side-effect
-/**
- * Indicates that an decorated class is a "component".
- *
- * @export
- * @param {string} [identifier] component name
- * @returns {ClassDecorator}
- */
-function Component(identifier) {
-    return (target) => {
-        identifier = identifier || koatty_container.IOCContainer.getIdentifier(target);
-        koatty_container.IOCContainer.saveClass("COMPONENT", target, identifier);
-    };
-}
+const KOATTY_VERSION = version;
+const ENGINES_VERSION = engines.node.slice(1) || '12.0.0';
 /**
- * Indicates that an decorated class is a "controller".
- *
- * @export
- * @param {string} [path] controller router path
- * @returns {ClassDecorator}
+ * check node version
+ * @return {void} []
  */
-function Controller(path = "") {
-    return (target) => {
-        const identifier = koatty_container.IOCContainer.getIdentifier(target);
-        koatty_container.IOCContainer.saveClass("CONTROLLER", target, identifier);
-        koatty_container.IOCContainer.savePropertyData(koatty_router.CONTROLLER_ROUTER, path, target, identifier);
-    };
+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);
+    }
 }
 /**
- * Indicates that an decorated class is a "middleware".
- *
- * @export
- * @param {string} [identifier] class name
- * @returns {ClassDecorator}
+ * unittest running environment detection
+ * only support jest
+ * @returns {boolean}
  */
-function Middleware(identifier) {
-    return (target) => {
-        identifier = identifier || koatty_container.IOCContainer.getIdentifier(target);
-        koatty_container.IOCContainer.saveClass("MIDDLEWARE", target, identifier);
-    };
-}
-/**
- * Indicates that an decorated class is a "service".
- *
- * @export
- * @param {string} [identifier] class name
- * @returns {ClassDecorator}
+const checkUTRuntime = () => {
+    let isUTRuntime = false;
+    // UT运行环境判断，暂时先只判断jest
+    const argv = JSON.stringify(process.argv[1]);
+    if (argv.indexOf('jest') > -1) {
+        isUTRuntime = true;
+    }
+    return isUTRuntime;
+};
+
+/*
+ * @Description: framework helper
+ * @Usage:
+ * @Author: richen
+ * @Date: 2023-12-09 21:56:32
+ * @LastEditTime: 2024-01-16 01:20:17
+ * @License: BSD (3-Clause)
+ * @Copyright (c): <richenlin(at)gmail.com>
  */
-function Service(identifier) {
-    return (target) => {
-        identifier = identifier || koatty_container.IOCContainer.getIdentifier(target);
-        koatty_container.IOCContainer.saveClass("SERVICE", target, identifier);
-    };
-}
 /**
- * Indicates that an decorated class is a "plugin".
+ * Check class file
+ * name should be always the same as class name
+ * class must be unique
  *
  * @export
- * @param {string} [identifier] class name
- * @returns {ClassDecorator}
+ * @param {string} fileName
+ * @param {string} xpath
+ * @param {*} target
+ * @param {Set<unknown>} [exSet]
+ * @returns {*}
  */
-function Plugin(identifier) {
-    return (target) => {
-        identifier = identifier || koatty_container.IOCContainer.getIdentifier(target);
-        // 
-        if (!identifier.endsWith("Plugin")) {
-            throw Error("Plugin class name must be 'Plugin' suffix.");
+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.`);
+            }
         }
-        koatty_container.IOCContainer.saveClass("COMPONENT", target, `${identifier}`);
-    };
-}
-/**
- * check is implements Middleware Interface
- * @param cls
- * @returns
- */
-function implementsMiddlewareInterface(cls) {
-    return 'run' in cls && koatty_lib.Helper.isFunction(cls.run);
-}
-/**
- * check is implements Controller Interface
- * @param cls
- * @returns
- */
-function implementsControllerInterface(cls) {
-    return 'app' in cls && 'ctx' in cls;
-}
-/**
- * check is implements Service Interface
- * @param cls
- * @returns
- */
-function implementsServiceInterface(cls) {
-    return 'app' in cls;
-}
-/**
- * check is implements Plugin Interface
- * @param cls
- * @returns
- */
-function implementsPluginInterface(cls) {
-    return 'run' in cls && koatty_lib.Helper.isFunction(cls.run);
-}
-/**
- * check is implements Aspect Interface
- * @param cls
- * @returns
- */
-function implementsAspectInterface(cls) {
-    return 'app' in cls && 'run' in cls && koatty_lib.Helper.isFunction(cls.run);
+        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;
 }
 
 /*
@@ -270,13 +178,13 @@ function implementsAspectInterface(cls) {
 const COMPONENT_SCAN = 'COMPONENT_SCAN';
 const CONFIGURATION_SCAN = 'CONFIGURATION_SCAN';
 // tslint:disable: no-irregular-whitespace
-const LOGO = `
-
-┬┌─┌─┐┌─┐┌┬┐┌┬┐┬ ┬
-├┴┐│ │├─┤ │  │ └┬┘
-┴ ┴└─┘┴ ┴ ┴  ┴  ┴ 
--------------------------------------------
-https://github.com/koatty
+const LOGO = `
+
+┬┌─┌─┐┌─┐┌┬┐┌┬┐┬ ┬
+├┴┐│ │├─┤ │  │ └┬┘
+┴ ┴└─┘┴ ┴ ┴  ┴  ┴ 
+-------------------------------------------
+https://github.com/koatty
 `;
 
 /*
@@ -284,7 +192,7 @@ https://github.com/koatty
  * @Usage:
  * @Author: richen
  * @Date: 2023-12-09 22:55:49
- * @LastEditTime: 2024-01-24 11:54:29
+ * @LastEditTime: 2024-11-29 18:20:23
  * @License: BSD (3-Clause)
  * @Copyright (c): <richenlin(at)gmail.com>
  */
@@ -292,21 +200,30 @@ https://github.com/koatty
  *
  */
 class Loader {
+    /**
+     * Creates an instance of Loader.
+     * @param {KoattyApplication} app
+     * @memberof Loader
+     */
+    constructor(app) {
+        this.app = app;
+    }
     /**
      * initialize env
      *
      * @static
-     * @param {Koatty} app
+     * @param {KoattyApplication} app
      * @memberof Loader
      */
     static initialize(app) {
-        const env = (process.execArgv ?? []).join(",");
+        var _a, _b;
+        const env = ((_a = process.execArgv) !== null && _a !== void 0 ? _a : []).join(",");
         if (env.indexOf('ts-node') > -1 || env.indexOf('--debug') > -1) {
             app.appDebug = true;
         }
         // app.env
         app.env = process.env.KOATTY_ENV || process.env.NODE_ENV;
-        if ((env.indexOf('--production') > -1) || ((app.env ?? '').indexOf('pro') > -1)) {
+        if ((env.indexOf('--production') > -1) || (((_b = app.env) !== null && _b !== void 0 ? _b : '').indexOf('pro') > -1)) {
             app.appDebug = false;
         }
         if (app.appDebug) {
@@ -322,7 +239,7 @@ class Loader {
         }
         // define path
         const rootPath = app.rootPath || process.cwd();
-        const appPath = app.appPath || path__namespace.resolve(rootPath, env.indexOf('ts-node') > -1 ? 'src' : 'dist');
+        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);
@@ -339,7 +256,6 @@ class Loader {
         process.env.APP_PATH = appPath;
         process.env.KOATTY_PATH = koattyPath;
         // Compatible with old version, will be deprecated
-        koatty_lib.Helper.define(app, 'prevent', koatty_exception.prevent);
         koatty_lib.Helper.define(app, 'thinkPath', koattyPath);
         process.env.THINK_PATH = koattyPath;
     }
@@ -347,14 +263,14 @@ class Loader {
      * Get component metadata
      *
      * @static
-     * @param {Koatty} app
+     * @param {KoattyApplication} app
      * @param {*} target
      * @returns {*}  {any[]}
      * @memberof Loader
      */
-    static GetComponentMetas(app, target) {
+    static GetComponentMeta(app, target) {
         let componentMetas = [];
-        const componentMeta = koatty_container.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, target);
+        const componentMeta = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, target);
         if (componentMeta) {
             if (koatty_lib.Helper.isArray(componentMeta)) {
                 componentMetas = componentMeta;
@@ -368,36 +284,17 @@ class Loader {
         }
         return componentMetas;
     }
-    /**
-     * Load all bean, excepted config/*、App.ts
-     *
-     * @static
-     * @param {Koatty} app
-     * @param {*} target
-     * @memberof Loader
-     */
-    static CheckAllComponents(app, target) {
-        // component metadata
-        const componentMetas = Loader.GetComponentMetas(app, target);
-        // configuration metadata
-        const configurationMetas = Loader.GetConfigurationMetas(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();
-    }
     /**
      * Get configuration metadata
      *
      * @static
-     * @param {Koatty} app
+     * @param {KoattyApplication} app
      * @param {*} target
      * @returns {*}  {any[]}
      * @memberof Loader
      */
-    static GetConfigurationMetas(app, target) {
-        const confMeta = koatty_container.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, target);
+    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)) {
@@ -409,11 +306,30 @@ class Loader {
         }
         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 {Koatty} app
+     * @param {KoattyApplication} app
      * @memberof Loader
      */
     static SetLogger(app) {
@@ -442,7 +358,7 @@ class Loader {
      * Load app event hook funcs
      *
      * @static
-     * @param {Koatty} app
+     * @param {KoattyApplication} app
      * @param {*} target
      * @memberof Loader
      */
@@ -452,25 +368,25 @@ class Loader {
             let funcs;
             switch (event) {
                 case "appBoot" /* AppEvent.appBoot */:
-                    funcs = koatty_container.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, "appBoot" /* AppEvent.appBoot */, target);
+                    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.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, "appReady" /* AppEvent.appReady */, target);
+                    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.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, "appStart" /* AppEvent.appStart */, target);
+                    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.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, "appStop" /* AppEvent.appStop */, target);
+                    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);
                     }
@@ -484,39 +400,70 @@ class Loader {
             }
         }
     }
+    /**
+     * LoadAllComponents
+     */
+    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 serveOpts = {
+            hostname: app.config('app_host'),
+            port: app.config('app_port'),
+            protocol: app.config('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, 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);
+    }
     /**
      * Load configuration
      *
-     * @static
-     * @param {Koatty} app
      * @param {string[]} [loadPath]
      * @memberof Loader
      */
-    static LoadConfigs(app, loadPath) {
+    LoadConfigs(loadPath) {
         const frameConfig = {};
         // Logger.Debug(`Load configuration path: ${app.thinkPath}/config`);
-        koatty_loader.Load(["./config"], app.koattyPath, function (name, path, exp) {
+        koatty_loader.Load(["./config"], this.app.koattyPath, function (name, path, exp) {
             frameConfig[name] = exp;
         });
         if (koatty_lib.Helper.isArray(loadPath)) {
             loadPath = loadPath.length > 0 ? loadPath : ["./config"];
         }
-        let appConfig = koatty_config.LoadConfigs(loadPath, app.appPath);
+        let appConfig = koatty_config.LoadConfigs(loadPath, this.app.appPath);
         appConfig = koatty_lib.Helper.extend(frameConfig, appConfig, true);
-        app.setMetaData("_configs", appConfig);
+        this.app.setMetaData("_configs", appConfig);
     }
     /**
      * Load middlewares
      * [async]
-     * @static
-     * @param {*} app
-     * @param {(string | string[])} [loadPath]
      * @memberof Loader
      */
-    static async LoadMiddlewares(app, loadPath) {
-        // Error handling middleware
-        await TraceHandler(app);
-        let middlewareConf = app.config(undefined, "middleware");
+    async LoadMiddlewares() {
+        var _a;
+        let middlewareConf = this.app.config(undefined, "middleware");
         if (koatty_lib.Helper.isEmpty(middlewareConf)) {
             middlewareConf = { config: {}, list: [] };
         }
@@ -524,13 +471,14 @@ class Loader {
         // Load(loadPath || ["./middleware"], app.koattyPath);
         //Mount application middleware
         // const middleware: any = {};
-        const appMiddleware = koatty_container.IOCContainer.listClass("MIDDLEWARE") ?? [];
+        const appMiddleware = (_a = koatty_container.IOC.listClass("MIDDLEWARE")) !== null && _a !== void 0 ? _a : [];
         appMiddleware.forEach((item) => {
-            item.id = (item.id ?? "").replace("MIDDLEWARE:", "");
+            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.IOCContainer.reg(item.id, item.target, { scope: "Prototype", type: "MIDDLEWARE", args: [] });
-                const ctl = koatty_container.IOCContainer.getInsByClass(item.target);
-                if (!implementsMiddlewareInterface(ctl)) {
+                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'.`);
                 }
             }
@@ -544,7 +492,7 @@ class Loader {
         //Automatically call middleware
         const middlewareConfig = middlewareConf.config || {};
         for (const key of appMList) {
-            const handle = koatty_container.IOCContainer.get(key, "MIDDLEWARE");
+            const handle = koatty_container.IOC.get(key, "MIDDLEWARE");
             if (!handle) {
                 throw Error(`Middleware ${key} load error.`);
             }
@@ -556,13 +504,13 @@ class Loader {
                 continue;
             }
             Logger.Debug(`Load middleware: ${key}`);
-            const result = await handle.run(middlewareConfig[key] || {}, app);
+            const result = await handle.run(middlewareConfig[key] || {}, this.app);
             if (koatty_lib.Helper.isFunction(result)) {
                 if (result.length < 3) {
-                    app.use(result);
+                    this.app.use(result);
                 }
                 else {
-                    app.useExp(result);
+                    this.app.useExp(result);
                 }
             }
         }
@@ -570,21 +518,20 @@ class Loader {
     /**
      * Load controllers
      *
-     * @static
-     * @param {*} app
      * @memberof Loader
      */
-    static LoadControllers(app) {
-        const controllerList = koatty_container.IOCContainer.listClass("CONTROLLER");
+    async LoadControllers() {
+        const controllerList = koatty_container.IOC.listClass("CONTROLLER");
         const controllers = [];
         controllerList.forEach((item) => {
-            item.id = (item.id ?? "").replace("CONTROLLER:", "");
+            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.IOCContainer.reg(item.id, item.target, { scope: "Prototype", type: "CONTROLLER", args: [] });
-                const ctl = koatty_container.IOCContainer.getInsByClass(item.target);
-                if (!implementsControllerInterface(ctl)) {
+                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);
@@ -595,20 +542,19 @@ class Loader {
     /**
      * Load services
      *
-     * @static
-     * @param {*} app
      * @memberof Loader
      */
-    static LoadServices(app) {
-        const serviceList = koatty_container.IOCContainer.listClass("SERVICE");
+    async LoadServices() {
+        const serviceList = koatty_container.IOC.listClass("SERVICE");
         serviceList.forEach((item) => {
-            item.id = (item.id ?? "").replace("SERVICE:", "");
+            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.IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "SERVICE", args: [] });
-                const ctl = koatty_container.IOCContainer.getInsByClass(item.target);
-                if (!implementsServiceInterface(ctl)) {
+                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'.`);
                 }
             }
@@ -617,42 +563,42 @@ class Loader {
     /**
      * Load components
      *
-     * @static
-     * @param {*} app
      * @memberof Loader
      */
-    static async LoadComponents(app) {
-        const componentList = koatty_container.IOCContainer.listClass("COMPONENT");
+    async LoadComponents() {
+        var _a, _b;
+        const componentList = koatty_container.IOC.listClass("COMPONENT");
         const pluginList = [];
         componentList.forEach(async (item) => {
-            item.id = (item.id ?? "").replace("COMPONENT:", "");
+            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.IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
+                koatty_container.IOC.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
                 if (item.id && (item.id).endsWith("Plugin")) {
-                    const ctl = koatty_container.IOCContainer.getInsByClass(item.target);
-                    if (!implementsPluginInterface(ctl)) {
+                    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.IOCContainer.getInsByClass(item.target);
-                    if (!implementsAspectInterface(ctl)) {
+                    const ctl = koatty_container.IOC.getInsByClass(item.target);
+                    if (!koatty_core.implementsAspectInterface(ctl)) {
                         throw Error(`The aspect ${item.id} must implements interface 'IAspect'.`);
                     }
                 }
             }
         });
         // load plugin config
-        let pluginsConf = app.config(undefined, "plugin");
+        let pluginsConf = this.app.config(undefined, "plugin");
         if (koatty_lib.Helper.isEmpty(pluginsConf)) {
             pluginsConf = { config: {}, list: [] };
         }
-        const pluginConfList = pluginsConf.list ?? [];
+        const pluginConfList = (_a = pluginsConf.list) !== null && _a !== void 0 ? _a : [];
         // load plugin list
         for (const key of pluginConfList) {
-            const handle = koatty_container.IOCContainer.get(key, "COMPONENT");
+            const handle = koatty_container.IOC.get(key, "COMPONENT");
             if (!handle) {
                 throw Error(`Plugin ${key} load error.`);
             }
@@ -664,68 +610,110 @@ class Loader {
                 continue;
             }
             // sync exec 
-            await handle.run(pluginsConf.config[key] ?? {}, app);
+            await handle.run((_b = pluginsConf.config[key]) !== null && _b !== void 0 ? _b : {}, this.app);
         }
     }
+    /**
+     * @description: load router
+     * @param {string} ctls
+     * @return {*}
+     */
+    async LoadRouter(ctls) {
+        // load router
+        await this.app.router.LoadRouter(this.app, ctls);
+    }
 }
 
-var version = "3.11.4-2";
-var engines = {
-	node: ">12.0.0"
-};
-
 /*
- * @Description: framework runtime checker
+ * @Description: framework bootstrap
  * @Usage:
  * @Author: richen
- * @Date: 2023-12-09 21:56:32
- * @LastEditTime: 2023-12-09 23:01:22
+ * @Date: 2021-12-09 21:56:32
+ * @LastEditTime: 2024-11-29 18:13:06
  * @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 node version
- * @return {void} []
+ * Bootstrap application decorator
+ *
+ * @export
+ * @param {Function} [bootFunc]
+ * @returns {ClassDecorator}
  */
-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 Bootstrap(bootFunc) {
+    return function (target) {
+        if (!(target.prototype instanceof koatty_core.Koatty)) {
+            throw new Error(`class does not inherit from Koatty`);
+        }
+        executeBootstrap(target, bootFunc);
+    };
 }
 /**
- * unittest running environment detection
- * only support jest
- * @returns {boolean}
+ * Actively perform dependency injection
+ * Parse the decorator, return the instantiated app.
+ * @export  ExecBootStrap
+ * @param {Function} [bootFunc] callback function
+ * @returns
  */
-const checkUTRuntime = () => {
-    let isUTRuntime = false;
-    // UT运行环境判断，暂时先只判断jest
-    const argv = JSON.stringify(process.argv[1]);
-    if (argv.indexOf('jest') > -1) {
-        isUTRuntime = true;
-    }
-    return isUTRuntime;
-};
-
-/*
- * @Description: framework bootstrap
- * @Usage:
- * @Author: richen
- * @Date: 2021-12-09 21:56:32
- * @LastEditTime: 2024-01-16 01:06:26
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
+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);
+    };
+}
+/**
+ * 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);
+    };
+}
+/**
+ * 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);
+    };
+}
+/**
+ * @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);
+}
 /**
  * execute bootstrap
  *
@@ -750,7 +738,8 @@ const executeBootstrap = async function (target, bootFunc, isInitiative = false)
         Logger.enable(false);
     }
     try {
-        !app.silent && Logger.Log("Koatty", LOGO);
+        if (!app.silent)
+            Logger.Log("Koatty", LOGO);
         if (!(app instanceof koatty_core.Koatty)) {
             throw new Error(`class ${target.name} does not inherit from Koatty`);
         }
@@ -761,44 +750,20 @@ const executeBootstrap = async function (target, bootFunc, isInitiative = false)
             Logger.Log('Koatty', '', 'Execute bootFunc ...');
             await bootFunc(app);
         }
-        // Set IOCContainer.app
-        koatty_container.IOCContainer.setApp(app);
-        Logger.Log('Koatty', '', 'ComponentScan ...');
+        // Set IOC.app
+        koatty_container.IOC.setApp(app);
         // Check all bean
+        Logger.Log('Koatty', '', 'ComponentScan ...');
         Loader.CheckAllComponents(app, target);
-        // Load configuration
-        Logger.Log('Koatty', '', 'Load Configurations ...');
-        // configuration metadata
-        const configurationMetas = Loader.GetConfigurationMetas(app, target);
-        Loader.LoadConfigs(app, configurationMetas);
         // Load App event hooks
         Loader.LoadAppEventHooks(app, target);
         Logger.Log('Koatty', '', 'Emit App Boot ...');
         await asyncEvent(app, "appBoot" /* AppEvent.appBoot */);
-        // Create Server
-        // app.server = newServe(app);
-        koatty_lib.Helper.define(app, "server", koatty_serve.NewServe(app));
-        // Create router
-        // app.router = newRouter(app);
-        koatty_lib.Helper.define(app, "router", koatty_router.NewRouter(app));
-        // Load Components
-        Logger.Log('Koatty', '', 'Load Components ...');
-        await Loader.LoadComponents(app);
-        // Load Middleware
-        Logger.Log('Koatty', '', 'Load Middlewares ...');
-        await Loader.LoadMiddlewares(app);
-        // Load Services
-        Logger.Log('Koatty', '', 'Load Services ...');
-        Loader.LoadServices(app);
-        // Load Controllers
-        Logger.Log('Koatty', '', 'Load Controllers ...');
-        const controllers = Loader.LoadControllers(app);
+        // Load All components
+        await Loader.LoadAllComponents(app, target);
         // Emit app ready event
         Logger.Log('Koatty', '', 'Emit App Ready ...');
         await asyncEvent(app, "appReady" /* AppEvent.appReady */);
-        // Load Routers
-        Logger.Log('Koatty', '', 'Load Routers ...');
-        app.router.LoadRouter(app, controllers);
         if (!isUTRuntime) {
             // Start Server
             app.listen(listenCallback);
@@ -817,19 +782,24 @@ const executeBootstrap = async function (target, bootFunc, isInitiative = false)
  * @returns {*}
  */
 const listenCallback = (app) => {
-    const options = app.server.options;
+    let servers = [];
+    if (!Array.isArray(app.server)) {
+        servers = [app.server];
+    }
+    else {
+        servers = app.server;
+    }
     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}`);
-    Logger.Log('Koatty', '', `Server Protocol: ${(options.protocol).toUpperCase()}`);
-    Logger.Log("Koatty", "", `Server running at ${options.protocol === "http2" ? "https" : options.protocol}://${options.hostname || '127.0.0.1'}:${options.port}/`);
+    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", "", "====================================");
-    // binding event "appStop"
-    Logger.Log('Koatty', '', 'Bind App Stop event ...');
-    koatty_serve.BindProcessEvent(app, 'appStop');
-    // tslint:disable-next-line: no-unused-expression
-    app.appDebug && Logger.Warn(`Running in debug mode.`);
+    if (app.appDebug)
+        Logger.Warn(`Running in debug mode.`);
     // Set Logger
     Loader.SetLogger(app);
 };
@@ -849,122 +819,21 @@ const asyncEvent = async function (event, eventName) {
     }
     return event.removeAllListeners(eventName);
 };
-/**
- * Bootstrap application
- *
- * @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);
-    };
-}
-/**
- * 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);
-    };
-}
-/**
- * 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 ?? '';
-        koatty_container.IOCContainer.saveClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, scanPath, target);
-    };
-}
-/**
- * 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 ?? '';
-        koatty_container.IOCContainer.saveClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, scanPath, target);
-    };
-}
-/**
- * @description: bind App event hook func
- * example:
- * export function TestDecorator(): ClassDecorator {
- *  return (target: Function) => {
- *   BindEventHook(AppEvent.appBoot, (app: Koatty) => {
- *      // todo
- *      return Promise.resolve();
- *   }, target)
- *  }
- * }
- * @param {AppEvent} eventName
- * @param {EventHookFunc} eventFunc
- * @param {any} target
- * @return {*}
- */
-function BindEventHook(eventName, eventFunc, target) {
-    koatty_container.IOCContainer.attachClassMetadata(koatty_container.TAGGED_CLS, eventName, eventFunc, target);
-}
 
-Object.defineProperty(exports, 'Config', {
+Object.defineProperty(exports, "Config", {
   enumerable: true,
   get: function () { return koatty_config.Config; }
 });
-Object.defineProperty(exports, 'Value', {
-  enumerable: true,
-  get: function () { return koatty_config.Value; }
-});
-Object.defineProperty(exports, 'Helper', {
+Object.defineProperty(exports, "Helper", {
   enumerable: true,
   get: function () { return koatty_lib.Helper; }
 });
 exports.BindEventHook = BindEventHook;
 exports.Bootstrap = Bootstrap;
-exports.Component = Component;
 exports.ComponentScan = ComponentScan;
 exports.ConfigurationScan = ConfigurationScan;
-exports.Controller = Controller;
 exports.ExecBootStrap = ExecBootStrap;
 exports.Logger = Logger;
-exports.Middleware = Middleware;
-exports.Plugin = Plugin;
-exports.Service = Service;
-exports.implementsAspectInterface = implementsAspectInterface;
-exports.implementsControllerInterface = implementsControllerInterface;
-exports.implementsMiddlewareInterface = implementsMiddlewareInterface;
-exports.implementsPluginInterface = implementsPluginInterface;
-exports.implementsServiceInterface = implementsServiceInterface;
-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(koatty_container).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
@@ -977,15 +846,15 @@ Object.keys(koatty_core).forEach(function (k) {
     get: function () { return koatty_core[k]; }
   });
 });
-Object.keys(koatty_serve).forEach(function (k) {
+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_serve[k]; }
+    get: function () { return koatty_exception[k]; }
   });
 });
-Object.keys(koatty_exception).forEach(function (k) {
+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_exception[k]; }
+    get: function () { return koatty_router[k]; }
   });
 });