koatty 3.5.7 → 3.5.12-0

package/dist/index.js

@@ -1,26 +1,1266 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.Helper = void 0;
-const tslib_1 = require("tslib");
-/**
- * @ author: richen
- * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
- * @ license: BSD (3-Clause)
- * @ version: 2020-05-18 10:43:05
- */
-(0, tslib_1.__exportStar)(require("./controller/BaseController"), exports);
-(0, tslib_1.__exportStar)(require("./controller/HttpController"), exports);
-(0, tslib_1.__exportStar)(require("./core/Bootstrap"), exports);
-(0, tslib_1.__exportStar)(require("./core/Component"), exports);
-(0, tslib_1.__exportStar)(require("./service/BaseService"), exports);
-(0, tslib_1.__exportStar)(require("koatty_core"), exports);
-(0, tslib_1.__exportStar)(require("koatty_container"), exports);
-(0, tslib_1.__exportStar)(require("koatty_exception"), exports);
-(0, tslib_1.__exportStar)(require("koatty_router"), exports);
-(0, tslib_1.__exportStar)(require("koatty_serve"), exports);
-(0, tslib_1.__exportStar)(require("koatty_trace"), exports);
-var Helper_1 = require("./util/Helper");
-Object.defineProperty(exports, "Helper", { enumerable: true, get: function () { return Helper_1.Helper; } });
-var Logger_1 = require("./util/Logger");
-Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_1.Logger; } });
-//# sourceMappingURL=index.js.map
+/*!
+* @Author: richen
+* @Date: 2021-12-21 12:21:50
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var koatty_lib = require('koatty_lib');
+require('reflect-metadata');
+var koatty_router = require('koatty_router');
+var koatty_core = require('koatty_core');
+var koatty_serve = require('koatty_serve');
+var koatty_container = require('koatty_container');
+var path = require('path');
+var koatty_loader = require('koatty_loader');
+var koatty_config = require('koatty_config');
+var koatty_logger = require('koatty_logger');
+var koatty_exception = require('koatty_exception');
+var koatty_trace = require('koatty_trace');
+var koatty_payload = require('koatty_payload');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return 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);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-05-10 11:49:15
+ */
+/**
+ * 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;
+}
+/**
+ * Format api interface data format
+ *
+ * @private
+ * @param {Error | string | ApiInput} msg   待处理的接口数据信息｜接口msg
+ * @param {*} data    待返回的数据
+ * @param {number} defaultCode   默认错误码
+ * @returns {ApiOutput}   格式化之后的接口数据
+ * @memberof BaseController
+ */
+function formatApiData(msg, data, defaultCode) {
+    let obj = {
+        code: defaultCode,
+        message: '',
+        data: null,
+    };
+    if (koatty_lib.Helper.isError(msg)) {
+        const { code, message } = msg;
+        obj.code = code || defaultCode;
+        obj.message = message;
+    }
+    else if (koatty_lib.Helper.isObject(msg)) {
+        obj = { ...obj, ...msg };
+    }
+    else {
+        obj.message = msg;
+        obj.data = data;
+    }
+    return obj;
+}
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-05-20 15:45:24
+ */
+/**
+ * Base controller
+ *
+ * @export
+ * @class BaseController
+ * @implements {IController}
+ */
+class BaseController {
+    /**
+     * instance of BaseController.
+     * @param {Koatty} app
+     * @param {KoattyContext} ctx
+     * @memberof BaseController
+     */
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.init();
+    }
+    /**
+     * init
+     *
+     * @protected
+     * @memberof BaseController
+     */
+    init() {
+    }
+    // /**
+    //  * Class pre-execution method, executed before each class member methods (except constructor, init, __after) are executed.
+    //  *
+    //  * @returns {Promise<any>}
+    //  * @memberof BaseController
+    //  */
+    // public __before(): Promise<any> {
+    //     return Promise.resolve();
+    // }
+    // /**
+    //  * Class after-execution method,after each class member methods (except constructor, init, __before) are executed.
+    //  *
+    //  * @public
+    //  * @returns {*}
+    //  * @memberof BaseController
+    //  */
+    // public __after(): Promise<any> {
+    //     return Promise.resolve();
+    // }
+    /**
+     * Response to normalize json format content for success
+     *
+     * @param {(string | ApiInput)} msg   待处理的message消息
+     * @param {*} [data]    待处理的数据
+     * @param {number} [code=200]    错误码，默认0
+     * @returns {*}
+     * @memberof BaseController
+     */
+    ok(msg, data, code = 0) {
+        const obj = formatApiData(msg, data, code);
+        return Promise.resolve(obj);
+    }
+    /**
+     * Response to normalize json format content for fail
+     *
+     * @param {(string | ApiInput)} msg
+     * @param {*} [data]
+     * @param {number} [code=1]
+     * @returns {*}
+     * @memberof BaseController
+     */
+    fail(msg, data, code = 1) {
+        const obj = formatApiData(msg, data, code);
+        return Promise.resolve(obj);
+    }
+}
+// const properties = ["constructor", "init"];
+// export const BaseController = new Proxy(Base, {
+//     set(target, key, value, receiver) {
+//         if (Reflect.get(target, key, receiver) === undefined) {
+//             return Reflect.set(target, key, value, receiver);
+//         } else if (key === "init") {
+//             return Reflect.set(target, key, value, receiver);
+//         } else {
+//             throw Error("Cannot redefine getter-only property");
+//         }
+//     },
+//     deleteProperty(target, key) {
+//         throw Error("Cannot delete getter-only property");
+//     },
+//     construct(target, args, newTarget) {
+//         Reflect.ownKeys(target.prototype).map((n) => {
+//             if (newTarget.prototype.hasOwnProperty(n) && !properties.includes(Helper.toString(n))) {
+//                 throw Error(`Cannot override the final method "${Helper.toString(n)}"`);
+//             }
+//         });
+//         return Reflect.construct(target, args, newTarget);
+//     }
+// });
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-05-20 15:45:24
+ */
+/**
+ * HTTP controller
+ *
+ * @export
+ * @class HttpController
+ * @implements {IController}
+ */
+class HttpController extends BaseController {
+    /**
+     * Whether it is a GET request
+     *
+     * @public
+     * @returns {boolean}
+     * @memberof HttpController
+     */
+    isGet() {
+        return this.ctx.method === "GET";
+    }
+    /**
+     * Whether it is a POST request
+     *
+     * @public
+     * @returns {boolean}
+     * @memberof HttpController
+     */
+    isPost() {
+        return this.ctx.method === "POST";
+    }
+    /**
+     * Determines whether the METHOD request is specified
+     *
+     * @public
+     * @param {string} method
+     * @returns {boolean}
+     * @memberof HttpController
+     */
+    isMethod(method) {
+        return this.ctx.method === method.toUpperCase();
+    }
+    /**
+     * Get/Set headers.
+     *
+     * @public
+     * @param {string} [name]
+     * @param {*} [value]
+     * @returns {*}
+     * @memberof HttpController
+     */
+    header(name, value) {
+        if (name === undefined) {
+            return this.ctx.headers;
+        }
+        if (value === undefined) {
+            return this.ctx.get(name);
+        }
+        return this.ctx.set(name, value);
+    }
+    /**
+     * Get POST/GET parameters, the POST value is priority.
+     *
+     * @param {string} [name]
+     * @returns
+     * @memberof HttpController
+     */
+    param(name) {
+        return this.ctx.bodyParser().then((body) => {
+            const getParams = this.ctx.queryParser() || {};
+            const postParams = (body.post ? body.post : body) || {};
+            if (name !== undefined) {
+                return postParams[name] === undefined ? getParams[name] : postParams[name];
+            }
+            return { ...getParams, ...postParams };
+        });
+    }
+    /**
+     * Set response content-type
+     *
+     * @public
+     * @param {string} contentType
+     * @param {(string | boolean)} [encoding]
+     * @returns {string}
+     * @memberof HttpController
+     */
+    type(contentType, encoding) {
+        if (encoding !== false && !contentType.includes("charset")) {
+            contentType = `${contentType}; charset=${encoding || this.app.config("encoding")}`;
+        }
+        this.ctx.type = contentType;
+        return contentType;
+    }
+    /**
+     * set cache-control and expires header
+     *
+     * @public
+     * @param {number} [timeout=30]
+     * @returns {void}
+     * @memberof HttpController
+     */
+    expires(timeout = 30) {
+        timeout = koatty_lib.Helper.toNumber(timeout) * 1000;
+        const date = new Date(Date.now() + timeout);
+        this.ctx.set("Cache-Control", `max-age=${timeout}`);
+        return this.ctx.set("Expires", date.toUTCString());
+    }
+    /**
+     * Url redirect
+     *
+     * @param {string} urls
+     * @param {string} [alt]
+     * @returns {void}
+     * @memberof HttpController
+     */
+    redirect(urls, alt) {
+        return this.ctx.redirect(urls, alt);
+    }
+    /**
+     * Block access
+     *
+     * @param {number} [code=403]
+     * @returns {Promise<any>}
+     * @memberof HttpController
+     */
+    deny(code = 403) {
+        return this.ctx.throw(code);
+    }
+    /**
+     * Set response Body content
+     *
+     * @param {*} data
+     * @param {string} [contentType]
+     * @param {string} [encoding]
+     * @returns {Promise<any>}
+     * @memberof HttpController
+     */
+    body(data, contentType, encoding) {
+        contentType = contentType || "text/plain";
+        encoding = encoding || this.app.config("encoding") || "utf-8";
+        this.type(contentType, encoding);
+        this.ctx.body = data;
+        return null;
+    }
+    /**
+     * Respond to json formatted content
+     *
+     * @param {*} data
+     * @returns {Promise<any>}
+     * @memberof HttpController
+     */
+    json(data) {
+        return this.body(data, "application/json");
+    }
+    /**
+     * Response to normalize json format content for success
+     *
+     * @param {(string | ApiInput)} msg   待处理的message消息
+     * @param {*} [data]    待处理的数据
+     * @param {number} [code=200]    错误码，默认0
+     * @returns {*}
+     * @memberof HttpController
+     */
+    ok(msg, data, code = 0) {
+        const obj = formatApiData(msg, data, code);
+        return this.json(obj);
+    }
+    /**
+     * Response to normalize json format content for fail
+     *
+     * @param {(string | ApiInput)} msg
+     * @param {*} [data]
+     * @param {number} [code=1]
+     * @returns {*}
+     * @memberof HttpController
+     */
+    fail(msg, data, code = 1) {
+        const obj = formatApiData(msg, data, code);
+        return this.json(obj);
+    }
+}
+// const properties = ["constructor", "init"];
+// export const HttpController = new Proxy(Base, {
+//     set(target, key, value, receiver) {
+//         if (Reflect.get(target, key, receiver) === undefined) {
+//             return Reflect.set(target, key, value, receiver);
+//         } else if (key === "init") {
+//             return Reflect.set(target, key, value, receiver);
+//         } else {
+//             throw Error("Cannot redefine getter-only property");
+//         }
+//     },
+//     deleteProperty(target, key) {
+//         throw Error("Cannot delete getter-only property");
+//     },
+//     construct(target, args, newTarget) {
+//         Reflect.ownKeys(target.prototype).map((n) => {
+//             if (newTarget.prototype.hasOwnProperty(n) && !properties.includes(Helper.toString(n))) {
+//                 throw Error(`Cannot override the final method "${Helper.toString(n)}"`);
+//             }
+//         });
+//         return Reflect.construct(target, args, newTarget);
+//     }
+// });
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-05-10 11:49:15
+ */
+// Logger
+const Logger = koatty_logger.DefaultLogger;
+/**
+ * SetLogger
+ *
+ * @export
+ * @param {{
+ *     logLevel?: LogLevelType;
+ *     logConsole?: boolean;
+ *     logFile?: boolean;
+ *     logFileLevel?: LogLevelType;
+ *     logFilePath?: string;
+ * }} config
+ */
+function SetLogger(config) {
+    if (config.logLevel !== undefined) {
+        koatty_logger.DefaultLogger.setLevel(config.logLevel);
+    }
+    if (config.logConsole !== undefined) {
+        koatty_logger.DefaultLogger.setLogConsole(config.logConsole);
+    }
+    if (config.logFile !== undefined) {
+        koatty_logger.DefaultLogger.setLogFile(config.logFile);
+        koatty_logger.DefaultLogger.setLogFilePath(config.logFilePath);
+    }
+    if (config.logFileLevel !== undefined) {
+        koatty_logger.DefaultLogger.setLogFileLevel(config.logFileLevel);
+    }
+}
+
+/**
+ * Base class
+ *
+ * @export
+ * @class Base
+ */
+class BaseService {
+    /**
+     * instance of Base.
+     * @param {...any[]} arg
+     * @memberof Base
+     */
+    constructor(...arg) {
+        this.init(arg);
+    }
+    /**
+     * init
+     *
+     * @protected
+     * @param {...any[]} arg
+     * @memberof Base
+     */
+    init(...arg) {
+        // todo
+        // Logger.Debug(arg)
+    }
+}
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-05-10 11:49:15
+ */
+const COMPONENT_SCAN = 'COMPONENT_SCAN';
+const CONFIGURATION_SCAN = 'CONFIGURATION_SCAN';
+const APP_READY_HOOK = "APP_READY_HOOK";
+// tslint:disable: no-irregular-whitespace
+const LOGO = `
+
+██   ██  ██████   █████  ████████ ████████ ██    ██ 
+██  ██  ██    ██ ██   ██    ██       ██     ██  ██  
+█████   ██    ██ ███████    ██       ██      ████   
+██  ██  ██    ██ ██   ██    ██       ██       ██    
+██   ██  ██████  ██   ██    ██       ██       ██    
+                         https://github.com/koatty
+`;
+
+class TraceMiddleware {
+    run(options, app) {
+        return koatty_trace.Trace(options, app);
+    }
+}
+
+class PayloadMiddleware {
+    run(options, app) {
+        return koatty_payload.Payload(options, app);
+    }
+}
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-07-06 11:18:01
+ */
+/**
+ *
+ */
+class Loader {
+    /**
+     * initialize env
+     *
+     * @static
+     * @param {Koatty} app
+     * @memberof Loader
+     */
+    static initialize(app) {
+        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) || (((_b = app.env) !== null && _b !== void 0 ? _b : '').indexOf('pro') > -1)) {
+            app.appDebug = false;
+        }
+        if (app.appDebug) {
+            app.env = 'development';
+            process.env.NODE_ENV = 'development';
+            process.env.APP_DEBUG = 'true';
+            Logger.setLevel("DEBUG");
+        }
+        else {
+            app.env = 'production';
+            process.env.NODE_ENV = 'production';
+            Logger.setLevel("INFO");
+        }
+        // define path
+        const rootPath = app.rootPath || process.cwd();
+        const appPath = app.appPath || path__namespace.resolve(rootPath, env.indexOf('ts-node') > -1 ? 'src' : 'dist');
+        const thinkPath = path__namespace.resolve(__dirname, '..');
+        koatty_lib.Helper.define(app, 'rootPath', rootPath);
+        koatty_lib.Helper.define(app, 'appPath', appPath);
+        koatty_lib.Helper.define(app, 'thinkPath', thinkPath);
+        process.env.ROOT_PATH = rootPath;
+        process.env.APP_PATH = appPath;
+        process.env.THINK_PATH = thinkPath;
+        // Compatible with old version, will be deprecated
+        koatty_lib.Helper.define(app, 'prevent', koatty_exception.prevent);
+        koatty_lib.Helper.define(app, 'root_path', rootPath);
+        koatty_lib.Helper.define(app, 'app_path', appPath);
+        koatty_lib.Helper.define(app, 'think_path', thinkPath);
+    }
+    /**
+     * Get component metadata
+     *
+     * @static
+     * @param {Koatty} app
+     * @param {*} target
+     * @returns {*}  {any[]}
+     * @memberof Loader
+     */
+    static GetComponentMetas(app, target) {
+        let componentMetas = [];
+        const componentMeta = koatty_container.IOCContainer.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;
+    }
+    /**
+     * 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 {*} target
+     * @returns {*}  {any[]}
+     * @memberof Loader
+     */
+    static GetConfigurationMetas(app, target) {
+        const confMeta = koatty_container.IOCContainer.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;
+    }
+    /**
+     * Set Logger level
+     *
+     * @static
+     * @param {Koatty} app
+     * @memberof Loader
+     */
+    static SetLogger(app) {
+        var _a;
+        const configs = (_a = app.getMetaData("_configs")) !== null && _a !== void 0 ? _a : {};
+        //Logger
+        if (configs.config) {
+            const opt = configs.config;
+            let logLevel = "DEBUG", logFileLevel = "INFO", logConsole = true, logFile = false, logFilePath = app.rootPath + "/logs";
+            if (app.env === "production") {
+                logLevel = "INFO";
+                logFileLevel = "WARN";
+                logConsole = false;
+                logFile = true;
+            }
+            if (opt.logs_level) {
+                logLevel = opt.logs_level;
+            }
+            if (opt.logs_write_level) {
+                logFileLevel = opt.logs_write_level;
+            }
+            if (opt.logs_write !== undefined) {
+                logFile = !!opt.logs_write;
+            }
+            if (opt.logs_console !== undefined) {
+                logConsole = !!opt.logs_console;
+            }
+            if (opt.logs_path) {
+                logFilePath = opt.logs_path;
+            }
+            SetLogger({ logLevel, logConsole, logFile, logFileLevel, logFilePath });
+        }
+    }
+    /**
+     * Load app ready hook funcs
+     *
+     * @static
+     * @param {Koatty} app
+     * @param {*} target
+     * @memberof Loader
+     */
+    static LoadAppReadyHooks(app, target) {
+        const funcs = koatty_container.IOCContainer.getClassMetadata(koatty_container.TAGGED_CLS, APP_READY_HOOK, target);
+        if (koatty_lib.Helper.isArray(funcs)) {
+            funcs.forEach((element) => {
+                app.once('appReady', () => element(app));
+                return null;
+            });
+        }
+    }
+    /**
+     * Load configuration
+     *
+     * @static
+     * @param {Koatty} app
+     * @param {string[]} [loadPath]
+     * @memberof Loader
+     */
+    static LoadConfigs(app, loadPath) {
+        const frameConfig = {};
+        // Logger.Debug(`Load configuration path: ${app.thinkPath}/config`);
+        koatty_loader.Load(["./config"], app.thinkPath, 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);
+        appConfig = koatty_lib.Helper.extend(frameConfig, appConfig, true);
+        app.setMetaData("_configs", appConfig);
+    }
+    /**
+     * Load middlewares
+     * [async]
+     * @static
+     * @param {*} app
+     * @param {(string | string[])} [loadPath]
+     * @memberof Loader
+     */
+    static async LoadMiddlewares(app, loadPath) {
+        var _a, _b;
+        let middlewareConf = app.config(undefined, "middleware");
+        if (koatty_lib.Helper.isEmpty(middlewareConf)) {
+            middlewareConf = { config: {}, list: [] };
+        }
+        //Mount default middleware
+        koatty_loader.Load(loadPath || ["./middleware"], app.thinkPath);
+        //Mount application middleware
+        // const middleware: any = {};
+        const appMiddleware = (_a = koatty_container.IOCContainer.listClass("MIDDLEWARE")) !== null && _a !== void 0 ? _a : [];
+        appMiddleware.push({ id: "TraceMiddleware", target: TraceMiddleware });
+        appMiddleware.push({ id: "PayloadMiddleware", target: PayloadMiddleware });
+        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.IOCContainer.reg(item.id, item.target, { scope: "Prototype", type: "MIDDLEWARE", args: [] });
+                // middleware[item.id] = item.target;
+            }
+        });
+        const middlewareConfList = middlewareConf.list;
+        const defaultList = ["TraceMiddleware", "PayloadMiddleware"];
+        middlewareConfList.forEach((item) => {
+            if (!defaultList.includes(item)) {
+                defaultList.push(item);
+            }
+        });
+        // if (defaultList.length > middlewareConfList.length) {
+        //     Logger.Warn("Some middleware is loaded but not allowed to execute.");
+        // }
+        //de-duplication
+        const appMList = [...new Set(defaultList)];
+        //Automatically call middleware
+        for (const key of appMList) {
+            const handle = koatty_container.IOCContainer.get(key, "MIDDLEWARE");
+            if (!handle) {
+                Logger.Error(`Middleware ${key} load error.`);
+                continue;
+            }
+            if (!koatty_lib.Helper.isFunction(handle.run)) {
+                Logger.Error(`Middleware ${key} must be implements method 'run'.`);
+                continue;
+            }
+            if (middlewareConf.config[key] === false) {
+                Logger.Warn(`Middleware ${key} is loaded but not allowed to execute.`);
+                continue;
+            }
+            Logger.Debug(`Load middleware: ${key}`);
+            const result = await handle.run((_b = middlewareConf.config[key]) !== null && _b !== void 0 ? _b : {}, app);
+            if (koatty_lib.Helper.isFunction(result)) {
+                if (result.length < 3) {
+                    app.use(result);
+                }
+                else {
+                    app.useExp(result);
+                }
+            }
+        }
+        // app.setMetaData("_middlewares", middleware);
+    }
+    /**
+     * Load controllers
+     *
+     * @static
+     * @param {*} app
+     * @memberof Loader
+     */
+    static LoadControllers(app) {
+        const controllerList = koatty_container.IOCContainer.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.IOCContainer.reg(item.id, item.target, { scope: "Prototype", type: "CONTROLLER", args: [] });
+                const ctl = koatty_container.IOCContainer.getInsByClass(item.target);
+                if (!(ctl instanceof BaseController)) {
+                    throw new Error(`class ${item.id} does not inherit from BaseController`);
+                }
+                controllers[item.id] = 1;
+            }
+        });
+        app.setMetaData("_controllers", controllers);
+    }
+    /**
+     * Load services
+     *
+     * @static
+     * @param {*} app
+     * @memberof Loader
+     */
+    static LoadServices(app) {
+        const serviceList = koatty_container.IOCContainer.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.IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "SERVICE", args: [] });
+                const ctl = koatty_container.IOCContainer.getInsByClass(item.target);
+                if (!(ctl instanceof BaseService)) {
+                    throw new Error(`class ${item.id} does not inherit from BaseService`);
+                }
+            }
+        });
+    }
+    /**
+     * Load components
+     *
+     * @static
+     * @param {*} app
+     * @memberof Loader
+     */
+    static LoadComponents(app) {
+        const componentList = koatty_container.IOCContainer.listClass("COMPONENT");
+        componentList.forEach((item) => {
+            var _a;
+            item.id = ((_a = item.id) !== null && _a !== void 0 ? _a : "").replace("COMPONENT:", "");
+            if (item.id && !(item.id).endsWith("Plugin") && koatty_lib.Helper.isClass(item.target)) {
+                Logger.Debug(`Load component: ${item.id}`);
+                // inject schedule
+                // injectSchedule(item.target, item.target.prototype, IOCContainer);
+                // registering to IOC
+                koatty_container.IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
+            }
+        });
+    }
+    /**
+     * Load plugins
+     *
+     * @static
+     * @param {*} app
+     * @memberof Loader
+     */
+    static async LoadPlugins(app) {
+        var _a;
+        const componentList = koatty_container.IOCContainer.listClass("COMPONENT");
+        let pluginsConf = app.config(undefined, "plugin");
+        if (koatty_lib.Helper.isEmpty(pluginsConf)) {
+            pluginsConf = { config: {}, list: [] };
+        }
+        const pluginList = [];
+        componentList.forEach(async (item) => {
+            var _a;
+            item.id = ((_a = item.id) !== null && _a !== void 0 ? _a : "").replace("COMPONENT:", "");
+            if (item.id && (item.id).endsWith("Plugin") && koatty_lib.Helper.isClass(item.target)) {
+                // Logger.Debug(`Load plugin: ${item.id}`);
+                // registering to IOC
+                koatty_container.IOCContainer.reg(item.id, item.target, { scope: "Singleton", type: "COMPONENT", args: [] });
+                pluginList.push(item.id);
+            }
+        });
+        const pluginConfList = pluginsConf.list;
+        if (pluginList.length > pluginConfList.length) {
+            Logger.Warn("Some plugins is loaded but not allowed to execute.");
+        }
+        for (const key of pluginConfList) {
+            const handle = koatty_container.IOCContainer.get(key, "COMPONENT");
+            if (!koatty_lib.Helper.isFunction(handle.run)) {
+                Logger.Error(`plugin ${key} must be implements method 'run'.`);
+                continue;
+            }
+            if (pluginsConf.config[key] === false) {
+                continue;
+            }
+            // Logger.Debug(`Execute plugin: ${key}`);
+            // sync exec 
+            await handle.run((_a = pluginsConf.config[key]) !== null && _a !== void 0 ? _a : {}, app);
+        }
+    }
+}
+
+var version = "3.5.12-0";
+var engines = {
+	node: ">12.0.0"
+};
+
+/*
+* @Description:
+* @Usage:
+* @Author: richen
+* @Date: 2021-12-17 11:54:06
+ * @LastEditTime: 2021-12-17 13:13:00
+*/
+const KOATTY_VERSION = version;
+const ENGINES_VERSION = engines.node.slice(1) || '12.0.0';
+/**
+ * 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);
+    }
+}
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-07-06 11:22:58
+ */
+/**
+ * execute bootstrap
+ *
+ * @param {*} target
+ * @param {Function} bootFunc
+ * @returns {Promise<void>}
+ */
+const ExecBootstrap = async function (target, bootFunc) {
+    // checked runtime
+    checkRuntime();
+    const app = Reflect.construct(target, []);
+    try {
+        console.log(LOGO);
+        if (!(app instanceof koatty_core.Koatty)) {
+            throw new Error(`class ${target.name} does not inherit from Koatty`);
+        }
+        // version
+        koatty_lib.Helper.define(app, "version", KOATTY_VERSION);
+        // Initialize env
+        Loader.initialize(app);
+        // exec bootFunc
+        if (koatty_lib.Helper.isFunction(bootFunc)) {
+            Logger.Log('think', '', 'Execute bootFunc ...');
+            await bootFunc(app);
+        }
+        // Set IOCContainer.app
+        koatty_container.IOCContainer.setApp(app);
+        Logger.Log('think', '', 'ComponentScan ...');
+        // Check all bean
+        Loader.CheckAllComponents(app, target);
+        // Load configuration
+        Logger.Log('think', '', 'Load Configurations ...');
+        // configuration metadata
+        const configurationMetas = Loader.GetConfigurationMetas(app, target);
+        Loader.LoadConfigs(app, configurationMetas);
+        // Load Plugin
+        Logger.Log('think', '', 'Load Plugins ...');
+        await Loader.LoadPlugins(app);
+        // Set Logger
+        Loader.SetLogger(app);
+        // app.emit("appBoot");
+        await asyncEvent(app, 'appBoot');
+        // Load App ready hooks
+        Loader.LoadAppReadyHooks(app, target);
+        // New router
+        const KoattyRouter = newRouter(app);
+        // Load Middleware
+        Logger.Log('think', '', 'Load Middlewares ...');
+        await Loader.LoadMiddlewares(app);
+        // Load Components
+        Logger.Log('think', '', 'Load Components ...');
+        Loader.LoadComponents(app);
+        // Load Services
+        Logger.Log('think', '', 'Load Services ...');
+        Loader.LoadServices(app);
+        // Load Controllers
+        Logger.Log('think', '', 'Load Controllers ...');
+        Loader.LoadControllers(app);
+        // Emit app ready event
+        Logger.Log('think', '', 'Emit App Ready ...');
+        // app.emit("appReady");
+        await asyncEvent(app, 'appReady');
+        // Load Routers
+        Logger.Log('think', '', 'Load Routers ...');
+        KoattyRouter.LoadRouter(app.getMetaData("_controllers"));
+        // Emit app started event
+        Logger.Log('think', '', 'Emit App Start ...');
+        // app.emit("appStart");
+        const server = newServe(app);
+        await asyncEvent(app, 'appStart');
+        Logger.Log('think', '', '====================================');
+        // Start server
+        app.listen(server);
+        // binding event "appStop"
+        koatty_serve.BindProcessEvent(app, 'appStop');
+    }
+    catch (err) {
+        Logger.Error(err);
+        process.exit();
+    }
+};
+/**
+ * create router
+ *
+ * @export
+ * @param {Koatty} app
+ * @returns {*}
+ */
+const newRouter = function (app) {
+    var _a;
+    const protocol = app.config("protocol") || "http";
+    const options = (_a = app.config(undefined, 'router')) !== null && _a !== void 0 ? _a : {};
+    const router = koatty_router.NewRouter(app, options, protocol);
+    koatty_lib.Helper.define(app, "router", router);
+    return router;
+};
+/**
+ * create serve
+ *
+ * @param {Koatty} app
+ * @returns {*}
+ */
+const newServe = function (app) {
+    const protocol = app.config("protocol") || "http";
+    const server = koatty_serve.Serve(app, protocol);
+    koatty_lib.Helper.define(app, "server", server);
+    return server;
+};
+/**
+ * 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);
+};
+/**
+ * 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`);
+        }
+        ExecBootstrap(target, bootFunc);
+    };
+}
+/**
+ * Define project scan path
+ *
+ * @export
+ * @param {(string | string[])} [scanPath]
+ * @returns {ClassDecorator}
+ */
+function ComponentScan(scanPath) {
+    Logger.Log('think', '', 'ComponentScan');
+    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.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) {
+    Logger.Log('think', '', 'ConfigurationScan');
+    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.IOCContainer.saveClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, scanPath, target);
+    };
+}
+/**
+ * bind AppReadyHookFunc
+ * example:
+ * export function TestDecorator(): ClassDecorator {
+ *  return (target: any) => {
+ *   BindAppReadyHook((app: Koatty) => {
+ *      // todo
+ *      return Promise.resolve();
+ *   }, target)
+ *  }
+ * }
+ *
+ * @export
+ * @param {AppReadyHookFunc} func
+ * @param {*} target
+ */
+function BindAppReadyHook(func, target) {
+    koatty_container.IOCContainer.attachClassMetadata(koatty_container.TAGGED_CLS, APP_READY_HOOK, func, target);
+}
+
+/**
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: BSD (3-Clause)
+ * @ version: 2020-05-10 11:32:45
+ */
+/**
+ * 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);
+    };
+}
+/**
+ * Indicates that an decorated class is a "controller".
+ *
+ * @export
+ * @param {string} [path] controller router path
+ * @returns {ClassDecorator}
+ */
+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);
+    };
+}
+/**
+ * Indicates that an decorated class is a "middleware".
+ *
+ * @export
+ * @param {string} [identifier] middleware name
+ * @returns {ClassDecorator}
+ */
+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] middleware name
+ * @returns {ClassDecorator}
+ */
+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".
+ *
+ * @export
+ * @param {string} [identifier]
+ * @returns {ClassDecorator}
+ */
+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.");
+        }
+        koatty_container.IOCContainer.saveClass("COMPONENT", target, `${identifier}`);
+    };
+}
+
+Object.defineProperty(exports, 'Helper', {
+    enumerable: true,
+    get: function () { return koatty_lib.Helper; }
+});
+exports.BaseController = BaseController;
+exports.BaseService = BaseService;
+exports.BindAppReadyHook = BindAppReadyHook;
+exports.Bootstrap = Bootstrap;
+exports.Component = Component;
+exports.ComponentScan = ComponentScan;
+exports.ConfigurationScan = ConfigurationScan;
+exports.Controller = Controller;
+exports.HttpController = HttpController;
+exports.Logger = Logger;
+exports.Middleware = Middleware;
+exports.Plugin = Plugin;
+exports.Service = Service;
+Object.keys(koatty_router).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return koatty_router[k]; }
+    });
+});
+Object.keys(koatty_core).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return koatty_core[k]; }
+    });
+});
+Object.keys(koatty_serve).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return koatty_serve[k]; }
+    });
+});
+Object.keys(koatty_container).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return koatty_container[k]; }
+    });
+});
+Object.keys(koatty_exception).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return koatty_exception[k]; }
+    });
+});
+Object.keys(koatty_trace).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return koatty_trace[k]; }
+    });
+});