@midwayjs/core 3.0.0-alpha.9 → 3.0.0-beta.4

package/dist/baseFramework.js

@@ -1,166 +1,85 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseFramework = void 0;
 const interface_1 = require("./interface");
 const decorator_1 = require("@midwayjs/decorator");
 const logger_1 = require("@midwayjs/logger");
-const logger_2 = require("./logger");
 const requestContainer_1 = require("./context/requestContainer");
-const configuration_1 = require("./functional/configuration");
+const environmentService_1 = require("./service/environmentService");
+const configService_1 = require("./service/configService");
 const informationService_1 = require("./service/informationService");
-const containerUtil_1 = require("./util/containerUtil");
+const loggerService_1 = require("./service/loggerService");
+const middlewareManager_1 = require("./common/middlewareManager");
+const middlewareService_1 = require("./service/middlewareService");
+const filterManager_1 = require("./common/filterManager");
 class BaseFramework {
-    constructor() {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
         this.defaultContext = {};
+        this.middlewareManager = this.createMiddlewareManager();
+        this.filterManager = this.createFilterManager();
+        this.composeMiddleware = null;
     }
-    configure(options) {
-        this.configurationOptions = options || {};
+    async init() {
+        var _a, _b, _c;
+        this.configurationOptions = (_a = this.configure()) !== null && _a !== void 0 ? _a : {};
         this.BaseContextLoggerClass =
-            this.configurationOptions.ContextLoggerClass ||
-                this.getDefaultContextLoggerClass();
-        this.logger = this.configurationOptions.logger;
-        this.appLogger = this.configurationOptions.appLogger;
+            (_b = this.configurationOptions.ContextLoggerClass) !== null && _b !== void 0 ? _b : this.getDefaultContextLoggerClass();
+        this.ContextLoggerApplyLogger =
+            (_c = this.configurationOptions.ContextLoggerApplyLogger) !== null && _c !== void 0 ? _c : 'appLogger';
+        this.logger = this.loggerService.getLogger('coreLogger');
+        this.appLogger = this.loggerService.getLogger('appLogger');
         return this;
     }
+    isEnable() {
+        return true;
+    }
     async initialize(options) {
-        this.isMainFramework = options.isMainFramework;
-        this.configurationOptions = this.configurationOptions || {};
-        /**
-         * before create MidwayContainer instance，can change init parameters
-         */
         await this.beforeContainerInitialize(options);
-        /**
-         * initialize MidwayContainer instance
-         */
         await this.containerInitialize(options);
-        /**
-         * before container load directory and bind
-         */
         await this.afterContainerInitialize(options);
-        /**
-         * run container loadDirectoryLoad method to create object definition
-         */
         await this.containerDirectoryLoad(options);
-        /**
-         * after container load directory and bind
-         */
         await this.afterContainerDirectoryLoad(options);
         /**
          * Third party application initialization
          */
         await this.applicationInitialize(options);
-        /**
-         * start container ready
-         */
         await this.containerReady(options);
-        if (this.isMainFramework !== undefined) {
-            // 多框架场景，由 bootstrap 执行后续流程
-            return;
-        }
-        /**
-         * load extensions and lifeCycle
-         */
-        await this.loadExtension();
-        /**
-         * after container refresh
-         */
         await this.afterContainerReady(options);
     }
-    async initializeInfo(options) {
-        if (!this.applicationContext.getInformationService()) {
-            const informationService = new informationService_1.MidwayInformationService(options);
-            this.applicationContext.setInformationService(informationService);
-        }
-    }
-    async initializeLogger(options) {
-        if (!this.logger) {
-            this.logger = new Proxy(logger_2.createMidwayLogger(this, 'coreLogger'), {});
-            this.logger.updateDefaultLabel(this.getFrameworkName());
-        }
-        if (!this.appLogger) {
-            this.appLogger = logger_2.createMidwayLogger(this, 'logger', {
-                fileLogName: 'midway-app.log',
-            });
-        }
-    }
-    async containerInitialize(options) {
-        /**
-         * initialize container
-         */
-        if (options.applicationContext) {
-            this.applicationContext = options.applicationContext;
-        }
-        else {
-            this.applicationContext = containerUtil_1.createDirectoryGlobContainer({
-                baseDir: options.baseDir,
-            });
-        }
-        this.applicationContext.registerObject('baseDir', options.baseDir);
-        this.applicationContext.registerObject('appDir', options.appDir);
-        /**
-         * initialize base information
-         */
-        await this.initializeInfo(options);
-        /**
-         * initialize framework logger
-         */
-        await this.initializeLogger(options);
-    }
-    async containerDirectoryLoad(options) {
-        if (options.applicationContext) {
-            // 如果有传入全局容器，就不需要再次扫描了
-            return;
-        }
-        // 废弃 deprecated
-        if (options.preloadModules && options.preloadModules.length) {
-            for (const preloadModule of options.preloadModules) {
-                this.applicationContext.bindClass(preloadModule);
-            }
-        }
-        // register app
-        this.applicationContext.registerDataHandler(decorator_1.APPLICATION_KEY, (key, meta) => {
-            var _a;
-            if (options.globalApplicationHandler) {
-                return ((_a = options.globalApplicationHandler(meta === null || meta === void 0 ? void 0 : meta.type)) !== null && _a !== void 0 ? _a : this.getApplication());
-            }
-            else {
-                return this.getApplication();
-            }
-        });
-        // register logger
-        this.getApplicationContext().registerDataHandler(decorator_1.LOGGER_KEY, key => {
-            return this.getLogger(key);
-        });
-    }
+    /**
+     * @deprecated
+     */
+    async containerInitialize(options) { }
+    /**
+     * @deprecated
+     */
+    async containerDirectoryLoad(options) { }
+    /**
+     * @deprecated
+     */
     async containerReady(options) {
         if (!this.app.getApplicationContext) {
             this.defineApplicationProperties();
         }
-        await this.applicationContext.ready();
-    }
-    async loadExtension() {
-        // 切面支持
-        await this.applicationContext.getAspectService().loadAspect();
-        // 预加载模块支持
-        await this.loadPreloadModule();
-        // lifecycle 支持
-        await this.loadLifeCycles();
-    }
-    async containerStop() {
-        await this.applicationContext.stop();
     }
     getApplicationContext() {
         return this.applicationContext;
     }
     getConfiguration(key) {
-        return this.getApplicationContext()
-            .getConfigService()
-            .getConfiguration(key);
+        return this.configService.getConfiguration(key);
     }
     getCurrentEnvironment() {
-        return this.getApplicationContext()
-            .getEnvironmentService()
-            .getCurrentEnvironment();
+        return this.environmentService.getCurrentEnvironment();
     }
     getApplication() {
         return this.app;
@@ -169,44 +88,34 @@ class BaseFramework {
         this.BaseContextLoggerClass = BaseContextLogger;
     }
     createContextLogger(ctx, name) {
-        const appLogger = this.getLogger(name);
+        const appLogger = this.getLogger(name !== null && name !== void 0 ? name : this.ContextLoggerApplyLogger);
         return new this.BaseContextLoggerClass(ctx, appLogger);
     }
     async stop() {
         await this.beforeStop();
-        if (this.isMainFramework === true || this.isMainFramework === undefined) {
-            await this.stopLifeCycles();
-            await this.containerStop();
-        }
     }
     getAppDir() {
-        return this.applicationContext.getInformationService().getAppDir();
+        return this.informationService.getAppDir();
     }
     getBaseDir() {
-        return this.applicationContext.getInformationService().getBaseDir();
+        return this.informationService.getBaseDir();
     }
     defineApplicationProperties(applicationProperties = {}, whiteList = []) {
         const defaultApplicationProperties = {
             getBaseDir: () => {
-                return this.getApplicationContext()
-                    .getInformationService()
-                    .getBaseDir();
+                return this.getBaseDir();
             },
             getAppDir: () => {
-                return this.getApplicationContext().getInformationService().getAppDir();
+                return this.getAppDir();
             },
             getEnv: () => {
-                return this.getApplicationContext()
-                    .getEnvironmentService()
-                    .getCurrentEnvironment();
+                return this.getCurrentEnvironment();
             },
             getApplicationContext: () => {
                 return this.getApplicationContext();
             },
             getConfig: (key) => {
-                return this.getApplicationContext()
-                    .getConfigService()
-                    .getConfiguration(key);
+                return this.getConfiguration(key);
             },
             getFrameworkType: () => {
                 return this.getFrameworkType();
@@ -243,20 +152,35 @@ class BaseFramework {
                         return this.createContextLogger(ctx, name);
                     };
                 }
+                ctx.setAttr = (key, value) => {
+                    ctx.requestContext.setAttr(key, value);
+                };
+                ctx.getAttr = (key) => {
+                    return ctx.requestContext.getAttr(key);
+                };
                 return ctx;
             },
             setContextLoggerClass: (BaseContextLogger) => {
                 return this.setContextLoggerClass(BaseContextLogger);
             },
-            addConfigObject(obj) {
-                this.getApplicationContext().getConfigService().addObject(obj);
+            addConfigObject: (obj) => {
+                this.configService.addObject(obj);
             },
-            setAttr(key, value) {
+            setAttr: (key, value) => {
                 this.getApplicationContext().setAttr(key, value);
             },
-            getAttr(key) {
+            getAttr: (key) => {
                 return this.getApplicationContext().getAttr(key);
             },
+            useMiddleware: (middleware) => {
+                this.middlewareManager.insertLast(middleware);
+            },
+            getMiddleware: () => {
+                return this.middlewareManager;
+            },
+            useFilter: (Filter) => {
+                this.filterManager.useFilter(Filter);
+            },
         };
         for (const method of whiteList) {
             delete defaultApplicationProperties[method];
@@ -264,116 +188,111 @@ class BaseFramework {
         Object.assign(this.app, defaultApplicationProperties, applicationProperties);
     }
     async beforeStop() { }
+    /**
+     * @deprecated
+     */
     async beforeContainerInitialize(options) { }
+    /**
+     * @deprecated
+     */
     async afterContainerInitialize(options) { }
+    /**
+     * @deprecated
+     */
     async afterContainerDirectoryLoad(options) { }
+    /**
+     * @deprecated
+     */
     async afterContainerReady(options) { }
-    async loadLifeCycles(isForce = false) {
-        // agent 不加载生命周期
-        if (this.app.getProcessType() === interface_1.MidwayProcessTypeEnum.AGENT)
-            return;
-        const cycles = decorator_1.listModule(decorator_1.CONFIGURATION_KEY);
-        const lifecycleInstanceList = [];
-        for (const cycle of cycles) {
-            if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
-                // 函数式写法
-                cycle.instance = cycle.target;
-            }
-            else {
-                // 普通类写法
-                const providerId = decorator_1.getProviderId(cycle.target);
-                cycle.instance =
-                    await this.getApplicationContext().getAsync(providerId);
-            }
-            lifecycleInstanceList.push(cycle);
-        }
-        // exec onConfigLoad()
-        for (const cycle of lifecycleInstanceList) {
-            if (typeof cycle.instance.onConfigLoad === 'function') {
-                const configData = await cycle.instance.onConfigLoad(this.getApplicationContext());
-                if (configData) {
-                    this.getApplicationContext().getConfigService().addObject(configData);
+    async getMiddleware(lastMiddleware) {
+        if (!this.composeMiddleware) {
+            this.middlewareManager.insertFirst((async (ctx, next) => {
+                let returnResult = undefined;
+                try {
+                    const result = await next();
+                    returnResult = await this.filterManager.runResultFilter(result, ctx);
                 }
-            }
-        }
-        for (const cycle of lifecycleInstanceList) {
-            if (typeof cycle.instance.onReady === 'function') {
-                /**
-                 * 让组件能正确获取到 bind 之后 registerObject 的对象有三个方法
-                 * 1、在 load 之后修改 bind，不太可行
-                 * 2、每次 getAsync 的时候，去掉 namespace，同时还要查找当前全局的变量，性能差
-                 * 3、一般只会在 onReady 的地方执行 registerObject（否则没有全局的意义），这个取巧的办法就是 onReady 传入一个代理，其中绑定当前的 namespace
-                 */
-                await cycle.instance.onReady(new Proxy(this.getApplicationContext(), {
-                    get: function (target, prop, receiver) {
-                        if (prop === 'getCurrentNamespace' && cycle.namespace) {
-                            return () => {
-                                return cycle.namespace;
-                            };
-                        }
-                        return Reflect.get(target, prop, receiver);
-                    },
-                }), this.app);
-            }
+                catch (err) {
+                    returnResult = await this.filterManager.runErrorFilter(err, ctx);
+                }
+                return returnResult;
+            }));
+            this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager);
+            await this.filterManager.init(this.applicationContext);
         }
-    }
-    async stopLifeCycles() {
-        const cycles = decorator_1.listModule(decorator_1.CONFIGURATION_KEY);
-        for (const cycle of cycles) {
-            let inst;
-            if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
-                // 函数式写法
-                inst = cycle.target;
-            }
-            else {
-                const providerId = decorator_1.getProviderId(cycle.target);
-                inst = await this.applicationContext.getAsync(providerId);
-            }
-            if (inst.onStop && typeof inst.onStop === 'function') {
-                await inst.onStop(new Proxy(this.getApplicationContext(), {
-                    get: function (target, prop, receiver) {
-                        if (prop === 'getCurrentNamespace' && cycle.namespace) {
-                            return () => {
-                                return cycle.namespace;
-                            };
-                        }
-                        return Reflect.get(target, prop, receiver);
-                    },
-                }), this.app);
-            }
+        if (lastMiddleware) {
+            return await this.middlewareService.compose([
+                this.composeMiddleware,
+                lastMiddleware,
+            ]);
         }
-    }
-    /**
-     * load preload module for container
-     * @private
-     */
-    async loadPreloadModule() {
-        // some common decorator implementation
-        const modules = decorator_1.listPreloadModule();
-        for (const module of modules) {
-            // preload init context
-            await this.applicationContext.getAsync(module);
+        else {
+            return this.composeMiddleware;
         }
     }
     getLogger(name) {
         var _a;
-        return (_a = logger_1.loggers.getLogger(name)) !== null && _a !== void 0 ? _a : this.appLogger;
+        return (_a = this.loggerService.getLogger(name)) !== null && _a !== void 0 ? _a : this.appLogger;
     }
     getCoreLogger() {
         return this.logger;
     }
     createLogger(name, option = {}) {
-        return logger_2.createMidwayLogger(this, name, option);
+        return this.loggerService.createLogger(name, option);
     }
     getProjectName() {
-        return this.applicationContext.getInformationService().getProjectName();
+        return this.informationService.getProjectName();
     }
     getFrameworkName() {
-        return this.getFrameworkType().toString();
+        return this.getFrameworkType().name;
     }
     getDefaultContextLoggerClass() {
         return logger_1.MidwayContextLogger;
     }
+    useMiddleware(Middleware) {
+        this.middlewareManager.insertLast(Middleware);
+    }
+    useFilter(Filter) {
+        this.filterManager.useFilter(Filter);
+    }
+    createMiddlewareManager() {
+        return new middlewareManager_1.ContextMiddlewareManager();
+    }
+    createFilterManager() {
+        return new filterManager_1.FilterManager();
+    }
 }
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", loggerService_1.MidwayLoggerService)
+], BaseFramework.prototype, "loggerService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", environmentService_1.MidwayEnvironmentService)
+], BaseFramework.prototype, "environmentService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], BaseFramework.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", informationService_1.MidwayInformationService)
+], BaseFramework.prototype, "informationService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", middlewareService_1.MidwayMiddlewareService)
+], BaseFramework.prototype, "middlewareService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], BaseFramework.prototype, "init", null);
+__decorate([
+    (0, decorator_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], BaseFramework.prototype, "stop", null);
 exports.BaseFramework = BaseFramework;
 //# sourceMappingURL=baseFramework.js.map

package/dist/{util → common}/fileDetector.js

@@ -29,16 +29,13 @@ class DirectoryFileDetector extends AbstractFileDetector {
         this.directoryFilterArray = [];
     }
     run(container) {
-        const debugLogger = container.getDebugLogger();
         const loadDirs = [].concat(this.options.loadDir || []);
         for (const dir of loadDirs) {
-            const fileResults = glob_1.run(DEFAULT_PATTERN.concat(this.options.pattern || []), {
+            const fileResults = (0, glob_1.run)(DEFAULT_PATTERN.concat(this.options.pattern || []), {
                 cwd: dir,
                 ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []),
             });
             for (const file of fileResults) {
-                debugLogger(`\nmain:*********** binding "${file}" ***********`);
-                debugLogger(`  namespace => "${this.options.namespace}"`);
                 if (this.directoryFilterArray.length) {
                     for (const resolveFilter of this.directoryFilterArray) {
                         if (typeof resolveFilter.pattern === 'string') {
@@ -50,7 +47,7 @@ class DirectoryFileDetector extends AbstractFileDetector {
                                 continue;
                             }
                         }
-                        else if (decorator_1.isRegExp(resolveFilter.pattern)) {
+                        else if ((0, decorator_1.isRegExp)(resolveFilter.pattern)) {
                             if (resolveFilter.pattern.test(file)) {
                                 const exports = resolveFilter.ignoreRequire
                                     ? undefined
@@ -61,15 +58,21 @@ class DirectoryFileDetector extends AbstractFileDetector {
                         }
                         const exports = require(file);
                         // add module to set
-                        container.bindClass(exports, this.options.namespace, file);
-                        debugLogger(`  binding "${file}" end`);
+                        container.bindClass(exports, {
+                            namespace: this.options.namespace,
+                            srcPath: file,
+                            createFrom: 'file',
+                        });
                     }
                 }
                 else {
                     const exports = require(file);
                     // add module to set
-                    container.bindClass(exports, this.options.namespace, file);
-                    debugLogger(`  binding "${file}" end`);
+                    container.bindClass(exports, {
+                        namespace: this.options.namespace,
+                        srcPath: file,
+                        createFrom: 'file',
+                    });
                 }
             }
         }
@@ -79,7 +82,10 @@ exports.DirectoryFileDetector = DirectoryFileDetector;
 class CustomModuleDetector extends AbstractFileDetector {
     run(container) {
         for (const module of this.options.modules) {
-            container.bindClass(module, this.options.namespace);
+            container.bindClass(module, {
+                namespace: this.options.namespace,
+                createFrom: 'module',
+            });
         }
     }
 }

package/dist/common/filterManager.d.ts

@@ -0,0 +1,19 @@
+import { CommonFilterUnion, IMidwayContainer, IMidwayContext } from '../interface';
+export declare class FilterManager<CTX extends IMidwayContext = IMidwayContext, R = any, N = any> {
+    private errFilterList;
+    private successFilterList;
+    private exceptionMap;
+    private defaultErrFilter;
+    private matchFnList;
+    useFilter(Filters: CommonFilterUnion<CTX, R, N>): void;
+    init(applicationContext: IMidwayContainer): Promise<void>;
+    runErrorFilter(err: Error, ctx: CTX, res?: R, next?: N): Promise<{
+        result: any;
+        error: any;
+    }>;
+    runResultFilter(result: any, ctx: CTX, res?: R, next?: N): Promise<{
+        result: any;
+        error: any;
+    }>;
+}
+//# sourceMappingURL=filterManager.d.ts.map

package/dist/common/filterManager.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const util_1 = require("../util");
+class FilterManager {
+    constructor() {
+        this.errFilterList = [];
+        this.successFilterList = [];
+        this.exceptionMap = new WeakMap();
+        this.defaultErrFilter = undefined;
+        this.matchFnList = [];
+    }
+    useFilter(Filters) {
+        if (!Array.isArray(Filters)) {
+            Filters = [Filters];
+        }
+        for (const Filter of Filters) {
+            if ((0, decorator_1.getClassMetadata)(decorator_1.CATCH_KEY, Filter)) {
+                this.errFilterList.push(Filter);
+            }
+            if ((0, decorator_1.getClassMetadata)(decorator_1.MATCH_KEY, Filter)) {
+                this.successFilterList.push(Filter);
+            }
+        }
+    }
+    async init(applicationContext) {
+        // for catch exception
+        for (const FilterClass of this.errFilterList) {
+            const filter = await applicationContext.getAsync(FilterClass);
+            const exceptionMetadata = (0, decorator_1.getClassMetadata)(decorator_1.CATCH_KEY, FilterClass);
+            if (exceptionMetadata && exceptionMetadata.catchTargets) {
+                for (const Exception of exceptionMetadata.catchTargets) {
+                    this.exceptionMap.set(Exception, filter);
+                }
+            }
+            else {
+                // default filter
+                this.defaultErrFilter = filter;
+            }
+        }
+        // for success return
+        for (const FilterClass of this.successFilterList) {
+            const filter = await applicationContext.getAsync(FilterClass);
+            const matchMetadata = (0, decorator_1.getClassMetadata)(decorator_1.MATCH_KEY, FilterClass);
+            if (matchMetadata && matchMetadata.matchPattern) {
+                this.matchFnList.push({
+                    matchFn: (0, util_1.toPathMatch)(matchMetadata.matchPattern),
+                    target: filter,
+                });
+            }
+        }
+    }
+    async runErrorFilter(err, ctx, res, next) {
+        let result, error;
+        if (this.exceptionMap.has(err.constructor)) {
+            const filter = this.exceptionMap.get(err.constructor);
+            result = await filter.catch(err, ctx, res, next);
+        }
+        else if (this.defaultErrFilter) {
+            result = await this.defaultErrFilter.catch(err, ctx, res, next);
+        }
+        else {
+            error = err;
+        }
+        return {
+            result,
+            error,
+        };
+    }
+    async runResultFilter(result, ctx, res, next) {
+        let returnValue = result;
+        for (const matchData of this.matchFnList) {
+            if (matchData.matchFn(ctx)) {
+                returnValue = await matchData.target.match(returnValue, ctx, res, next);
+            }
+        }
+        return {
+            result: returnValue,
+            error: undefined,
+        };
+    }
+}
+exports.FilterManager = FilterManager;
+//# sourceMappingURL=filterManager.js.map