koatty 3.11.4-2 → 3.11.7

package/dist/index.mjs

@@ -1,99 +1,32 @@
 /*!
 * @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/
 */
-import { CONTROLLER_ROUTER, NewRouter } from 'koatty_router';
-export * from 'koatty_router';
-import { IOCContainer, TAGGED_CLS } from 'koatty_container';
+import { LoadConfigs } from 'koatty_config';
+export { Config } from 'koatty_config';
+import { IOC, TAGGED_CLS } from 'koatty_container';
 export * from 'koatty_container';
-import { AppEventArr, Koatty } from 'koatty_core';
+import { AppEventArr, implementsMiddlewareInterface, implementsControllerInterface, implementsServiceInterface, implementsPluginInterface, implementsAspectInterface, Koatty } from 'koatty_core';
 export * from 'koatty_core';
-import { NewServe, BindProcessEvent } from 'koatty_serve';
-export * from 'koatty_serve';
-import * as path from 'path';
-import { Load } from 'koatty_loader';
-import { prevent } from 'koatty_exception';
 export * from 'koatty_exception';
-import { LoadConfigs } from 'koatty_config';
-export { Config, Value } from 'koatty_config';
-import { Trace } from 'koatty_trace';
+import { NewRouter } from 'koatty_router';
+export * from 'koatty_router';
 import { Helper } from 'koatty_lib';
 export { Helper } from 'koatty_lib';
 import { DefaultLogger } from 'koatty_logger';
-import 'reflect-metadata';
-
-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(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 (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 && 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;
-}
+import { Load } from 'koatty_loader';
+import { NewServe } from 'koatty_serve';
+import * as path from 'path';
 
 /*
  * @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>
  */
@@ -123,125 +56,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 || IOCContainer.getIdentifier(target);
-        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 = IOCContainer.getIdentifier(target);
-        IOCContainer.saveClass("CONTROLLER", target, identifier);
-        IOCContainer.savePropertyData(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 (Helper.toNumber(nodeEngines) > 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 || IOCContainer.getIdentifier(target);
-        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 || IOCContainer.getIdentifier(target);
-        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 || IOCContainer.getIdentifier(target);
-        // 
-        if (!identifier.endsWith("Plugin")) {
-            throw Error("Plugin class name must be 'Plugin' suffix.");
+function checkClass(fileName, xpath, target, exSet) {
+    if (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 && Helper.isClass(target[keys[0]])) {
+                throw Error(`The file(${xpath}) name should be always the same as class name.`);
+            }
         }
-        IOCContainer.saveClass("COMPONENT", target, `${identifier}`);
-    };
-}
-/**
- * check is implements Middleware Interface
- * @param cls
- * @returns
- */
-function implementsMiddlewareInterface(cls) {
-    return 'run' in cls && 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 && Helper.isFunction(cls.run);
-}
-/**
- * check is implements Aspect Interface
- * @param cls
- * @returns
- */
-function implementsAspectInterface(cls) {
-    return 'app' in cls && 'run' in cls && 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;
 }
 
 /*
@@ -256,13 +162,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
 `;
 
 /*
@@ -270,7 +176,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>
  */
@@ -278,21 +184,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) {
@@ -308,7 +223,7 @@ class Loader {
         }
         // define path
         const rootPath = app.rootPath || process.cwd();
-        const appPath = app.appPath || path.resolve(rootPath, env.indexOf('ts-node') > -1 ? 'src' : 'dist');
+        const appPath = app.appPath || path.resolve(rootPath, app.appDebug ? 'src' : 'dist');
         const koattyPath = path.resolve(__dirname, '..');
         Helper.define(app, 'rootPath', rootPath);
         Helper.define(app, 'appPath', appPath);
@@ -325,7 +240,6 @@ class Loader {
         process.env.APP_PATH = appPath;
         process.env.KOATTY_PATH = koattyPath;
         // Compatible with old version, will be deprecated
-        Helper.define(app, 'prevent', prevent);
         Helper.define(app, 'thinkPath', koattyPath);
         process.env.THINK_PATH = koattyPath;
     }
@@ -333,14 +247,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 = IOCContainer.getClassMetadata(TAGGED_CLS, COMPONENT_SCAN, target);
+        const componentMeta = IOC.getClassMetadata(TAGGED_CLS, COMPONENT_SCAN, target);
         if (componentMeta) {
             if (Helper.isArray(componentMeta)) {
                 componentMetas = componentMeta;
@@ -354,36 +268,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();
-        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 = IOCContainer.getClassMetadata(TAGGED_CLS, CONFIGURATION_SCAN, target);
+    static GetConfigurationMeta(app, target) {
+        const confMeta = IOC.getClassMetadata(TAGGED_CLS, CONFIGURATION_SCAN, target);
         let configurationMetas = [];
         if (confMeta) {
             if (Helper.isArray(confMeta)) {
@@ -395,11 +290,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();
+        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) {
@@ -428,7 +342,7 @@ class Loader {
      * Load app event hook funcs
      *
      * @static
-     * @param {Koatty} app
+     * @param {KoattyApplication} app
      * @param {*} target
      * @memberof Loader
      */
@@ -438,25 +352,25 @@ class Loader {
             let funcs;
             switch (event) {
                 case "appBoot" /* AppEvent.appBoot */:
-                    funcs = IOCContainer.getClassMetadata(TAGGED_CLS, "appBoot" /* AppEvent.appBoot */, target);
+                    funcs = IOC.getClassMetadata(TAGGED_CLS, "appBoot" /* AppEvent.appBoot */, target);
                     if (Helper.isArray(funcs)) {
                         eventFuncs.set("appBoot" /* AppEvent.appBoot */, funcs);
                     }
                     break;
                 case "appReady" /* AppEvent.appReady */:
-                    funcs = IOCContainer.getClassMetadata(TAGGED_CLS, "appReady" /* AppEvent.appReady */, target);
+                    funcs = IOC.getClassMetadata(TAGGED_CLS, "appReady" /* AppEvent.appReady */, target);
                     if (Helper.isArray(funcs)) {
                         eventFuncs.set("appReady" /* AppEvent.appReady */, funcs);
                     }
                     break;
                 case "appStart" /* AppEvent.appStart */:
-                    funcs = IOCContainer.getClassMetadata(TAGGED_CLS, "appStart" /* AppEvent.appStart */, target);
+                    funcs = IOC.getClassMetadata(TAGGED_CLS, "appStart" /* AppEvent.appStart */, target);
                     if (Helper.isArray(funcs)) {
                         eventFuncs.set("appStart" /* AppEvent.appStart */, funcs);
                     }
                     break;
                 case "appStop" /* AppEvent.appStop */:
-                    funcs = IOCContainer.getClassMetadata(TAGGED_CLS, "appStop" /* AppEvent.appStop */, target);
+                    funcs = IOC.getClassMetadata(TAGGED_CLS, "appStop" /* AppEvent.appStop */, target);
                     if (Helper.isArray(funcs)) {
                         eventFuncs.set("appStop" /* AppEvent.appStop */, funcs);
                     }
@@ -470,39 +384,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'),
+        };
+        Helper.define(app, "server", NewServe(app, serveOpts));
+        // Create router
+        const routerOpts = (_a = app.config(undefined, 'router')) !== null && _a !== void 0 ? _a : {};
+        Helper.define(app, "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`);
-        Load(["./config"], app.koattyPath, function (name, path, exp) {
+        Load(["./config"], this.app.koattyPath, function (name, path, exp) {
             frameConfig[name] = exp;
         });
         if (Helper.isArray(loadPath)) {
             loadPath = loadPath.length > 0 ? loadPath : ["./config"];
         }
-        let appConfig = LoadConfigs(loadPath, app.appPath);
+        let appConfig = LoadConfigs(loadPath, this.app.appPath);
         appConfig = 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 (Helper.isEmpty(middlewareConf)) {
             middlewareConf = { config: {}, list: [] };
         }
@@ -510,12 +455,13 @@ class Loader {
         // Load(loadPath || ["./middleware"], app.koattyPath);
         //Mount application middleware
         // const middleware: any = {};
-        const appMiddleware = IOCContainer.listClass("MIDDLEWARE") ?? [];
+        const appMiddleware = (_a = 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 && Helper.isClass(item.target)) {
-                IOCContainer.reg(item.id, item.target, { scope: "Prototype", type: "MIDDLEWARE", args: [] });
-                const ctl = IOCContainer.getInsByClass(item.target);
+                IOC.reg(item.id, item.target, { scope: "Prototype", type: "MIDDLEWARE", args: [] });
+                const ctl = IOC.getInsByClass(item.target);
                 if (!implementsMiddlewareInterface(ctl)) {
                     throw Error(`The middleware ${item.id} must implements interface 'IMiddleware'.`);
                 }
@@ -530,7 +476,7 @@ class Loader {
         //Automatically call middleware
         const middlewareConfig = middlewareConf.config || {};
         for (const key of appMList) {
-            const handle = IOCContainer.get(key, "MIDDLEWARE");
+            const handle = IOC.get(key, "MIDDLEWARE");
             if (!handle) {
                 throw Error(`Middleware ${key} load error.`);
             }
@@ -542,13 +488,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 (Helper.isFunction(result)) {
                 if (result.length < 3) {
-                    app.use(result);
+                    this.app.use(result);
                 }
                 else {
-                    app.useExp(result);
+                    this.app.useExp(result);
                 }
             }
         }
@@ -556,20 +502,19 @@ class Loader {
     /**
      * Load controllers
      *
-     * @static
-     * @param {*} app
      * @memberof Loader
      */
-    static LoadControllers(app) {
-        const controllerList = IOCContainer.listClass("CONTROLLER");
+    async LoadControllers() {
+        const controllerList = 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 && Helper.isClass(item.target)) {
                 Logger.Debug(`Load controller: ${item.id}`);
                 // registering to IOC
-                IOCContainer.reg(item.id, item.target, { scope: "Prototype", type: "CONTROLLER", args: [] });
-                const ctl = IOCContainer.getInsByClass(item.target);
+                IOC.reg(item.id, item.target, { scope: "Prototype", type: "CONTROLLER", args: [] });
+                const ctl = IOC.getInsByClass(item.target);
                 if (!implementsControllerInterface(ctl)) {
                     throw Error(`The controller ${item.id} must implements interface 'IController'.`);
                 }
@@ -581,19 +526,18 @@ class Loader {
     /**
      * Load services
      *
-     * @static
-     * @param {*} app
      * @memberof Loader
      */
-    static LoadServices(app) {
-        const serviceList = IOCContainer.listClass("SERVICE");
+    async LoadServices() {
+        const serviceList = 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 && Helper.isClass(item.target)) {
                 Logger.Debug(`Load service: ${item.id}`);
                 // registering to IOC
-                IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "SERVICE", args: [] });
-                const ctl = IOCContainer.getInsByClass(item.target);
+                IOC.reg(item.id, item.target, { scope: "Singleton", type: "SERVICE", args: [] });
+                const ctl = IOC.getInsByClass(item.target);
                 if (!implementsServiceInterface(ctl)) {
                     throw Error(`The service ${item.id} must implements interface 'IService'.`);
                 }
@@ -603,27 +547,27 @@ class Loader {
     /**
      * Load components
      *
-     * @static
-     * @param {*} app
      * @memberof Loader
      */
-    static async LoadComponents(app) {
-        const componentList = IOCContainer.listClass("COMPONENT");
+    async LoadComponents() {
+        var _a, _b;
+        const componentList = 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 (Helper.isClass(item.target)) {
                 // registering to IOC
-                IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
+                IOC.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
                 if (item.id && (item.id).endsWith("Plugin")) {
-                    const ctl = IOCContainer.getInsByClass(item.target);
+                    const ctl = IOC.getInsByClass(item.target);
                     if (!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 = IOCContainer.getInsByClass(item.target);
+                    const ctl = IOC.getInsByClass(item.target);
                     if (!implementsAspectInterface(ctl)) {
                         throw Error(`The aspect ${item.id} must implements interface 'IAspect'.`);
                     }
@@ -631,14 +575,14 @@ class Loader {
             }
         });
         // load plugin config
-        let pluginsConf = app.config(undefined, "plugin");
+        let pluginsConf = this.app.config(undefined, "plugin");
         if (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 = IOCContainer.get(key, "COMPONENT");
+            const handle = IOC.get(key, "COMPONENT");
             if (!handle) {
                 throw Error(`Plugin ${key} load error.`);
             }
@@ -650,68 +594,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 (Helper.toNumber(nodeEngines) > 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)) {
+            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)) {
+            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)) {
+            throw new Error(`class does not inherit from Koatty`);
+        }
+        scanPath = scanPath !== null && scanPath !== void 0 ? scanPath : '';
+        IOC.saveClassMetadata(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)) {
+            throw new Error(`class does not inherit from Koatty`);
+        }
+        scanPath = scanPath !== null && scanPath !== void 0 ? scanPath : '';
+        IOC.saveClassMetadata(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) {
+    IOC.attachClassMetadata(TAGGED_CLS, eventName, eventFunc, target);
+}
 /**
  * execute bootstrap
  *
@@ -736,7 +722,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)) {
             throw new Error(`class ${target.name} does not inherit from Koatty`);
         }
@@ -747,44 +734,20 @@ const executeBootstrap = async function (target, bootFunc, isInitiative = false)
             Logger.Log('Koatty', '', 'Execute bootFunc ...');
             await bootFunc(app);
         }
-        // Set IOCContainer.app
-        IOCContainer.setApp(app);
-        Logger.Log('Koatty', '', 'ComponentScan ...');
+        // Set IOC.app
+        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);
-        Helper.define(app, "server", NewServe(app));
-        // Create router
-        // app.router = newRouter(app);
-        Helper.define(app, "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);
@@ -803,19 +766,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 ...');
-    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);
 };
@@ -835,86 +803,5 @@ 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)) {
-            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)) {
-            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)) {
-            throw new Error(`class does not inherit from Koatty`);
-        }
-        scanPath = scanPath ?? '';
-        IOCContainer.saveClassMetadata(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)) {
-            throw new Error(`class does not inherit from Koatty`);
-        }
-        scanPath = scanPath ?? '';
-        IOCContainer.saveClassMetadata(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) {
-    IOCContainer.attachClassMetadata(TAGGED_CLS, eventName, eventFunc, target);
-}
 
-export { BindEventHook, Bootstrap, Component, ComponentScan, ConfigurationScan, Controller, ExecBootStrap, Logger, Middleware, Plugin, Service, implementsAspectInterface, implementsControllerInterface, implementsMiddlewareInterface, implementsPluginInterface, implementsServiceInterface };
+export { BindEventHook, Bootstrap, ComponentScan, ConfigurationScan, ExecBootStrap, Logger };