@midwayjs/core 3.0.0-alpha.6 → 3.0.0-beta.11

package/dist/service/aspectService.js

@@ -1,27 +1,31 @@
 "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.MidwayAspectService = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const pm = require("picomatch");
-const util = require("util");
-const debugLogger = util.debuglog('midway:container:aspect');
-class MidwayAspectService {
-    constructor(container) {
-        this.container = container;
-        this.aspectMappingMap = new WeakMap();
-        this.aspectModuleSet = new Set();
+let MidwayAspectService = class MidwayAspectService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
     }
     /**
      * load aspect method for container
-     * @private
      */
     async loadAspect() {
         // for aop implementation
-        const aspectModules = decorator_1.listModule(decorator_1.ASPECT_KEY);
+        const aspectModules = (0, decorator_1.listModule)(decorator_1.ASPECT_KEY);
         // sort for aspect target
         let aspectDataList = [];
         for (const module of aspectModules) {
-            const data = decorator_1.getClassMetadata(decorator_1.ASPECT_KEY, module);
+            const data = (0, decorator_1.getClassMetadata)(decorator_1.ASPECT_KEY, module);
             aspectDataList = aspectDataList.concat(data.map(el => {
                 el.aspectModule = module;
                 return el;
@@ -32,37 +36,15 @@ class MidwayAspectService {
             return (next.priority || 0) - (pre.priority || 0);
         });
         for (const aspectData of aspectDataList) {
-            const aspectIns = await this.container.getAsync(aspectData.aspectModule);
+            // aspect instance init
+            const aspectIns = await this.applicationContext.getAsync(aspectData.aspectModule);
             await this.addAspect(aspectIns, aspectData);
         }
-        // 合并拦截器方法，提升性能
-        for (const module of this.aspectModuleSet) {
-            const aspectMapping = this.aspectMappingMap.get(module);
-            for (const [method, aspectFn] of aspectMapping) {
-                const composeFn = (ins, originMethod) => {
-                    for (const fn of aspectFn) {
-                        originMethod = fn(ins, originMethod);
-                    }
-                    return originMethod;
-                };
-                aspectMapping.set(method, [composeFn]);
-            }
-        }
-        // 绑定完后清理 Set 记录
-        this.aspectModuleSet.clear();
     }
     async addAspect(aspectIns, aspectData) {
         const module = aspectData.aspectTarget;
         const names = Object.getOwnPropertyNames(module.prototype);
         const isMatch = aspectData.match ? pm(aspectData.match) : () => true;
-        // 存到 set 里用来做循环
-        this.aspectModuleSet.add(module);
-        /**
-         * 拦截器流程
-         * 1、在每个被拦截的 class 上做拦截标记，记录哪些方法需要被拦截
-         * 2、Container 保存每个 class 的方法对应的拦截器数组
-         * 3、创建完实例后，在返回前执行包裹逻辑，把需要拦截的方法都执行一遍拦截（不对原型做修改）
-         */
         for (const name of names) {
             if (name === 'constructor' || !isMatch(name)) {
                 continue;
@@ -71,149 +53,111 @@ class MidwayAspectService {
             if (!descriptor || descriptor.writable === false) {
                 continue;
             }
-            // 把拦截器和当前容器绑定
-            if (!this.aspectMappingMap.has(module)) {
-                this.aspectMappingMap.set(module, new Map());
-            }
-            const mappingMap = this.aspectMappingMap.get(module);
-            if (!mappingMap.has(name)) {
-                mappingMap.set(name, []);
-            }
-            // 把拦截器本身加到数组中
-            const methodAspectCollection = mappingMap.get(name);
-            if (decorator_1.isAsyncFunction(descriptor.value)) {
-                debugLogger(`aspect [#${module.name}:${name}], isAsync=true, aspect class=[${aspectIns.constructor.name}]`);
-                const fn = (ins, originMethod) => {
-                    return async (...args) => {
-                        var _a, _b, _c;
-                        let error, result;
-                        const newProceed = (...args) => {
-                            return originMethod.apply(ins, args);
-                        };
-                        const joinPoint = {
-                            methodName: name,
-                            target: ins,
-                            args: args,
-                            proceed: newProceed,
-                        };
-                        try {
-                            await ((_a = aspectIns.before) === null || _a === void 0 ? void 0 : _a.call(aspectIns, joinPoint));
-                            if (aspectIns.around) {
-                                result = await aspectIns.around(joinPoint);
-                            }
-                            else {
-                                result = await originMethod.apply(ins, joinPoint.args);
-                            }
-                            joinPoint.proceed = undefined;
-                            const resultTemp = await ((_b = aspectIns.afterReturn) === null || _b === void 0 ? void 0 : _b.call(aspectIns, joinPoint, result));
-                            result = typeof resultTemp === 'undefined' ? result : resultTemp;
-                            return result;
-                        }
-                        catch (err) {
-                            joinPoint.proceed = undefined;
-                            error = err;
-                            if (aspectIns.afterThrow) {
-                                await aspectIns.afterThrow(joinPoint, error);
-                            }
-                            else {
-                                throw err;
-                            }
-                        }
-                        finally {
-                            await ((_c = aspectIns.after) === null || _c === void 0 ? void 0 : _c.call(aspectIns, joinPoint, result, error));
-                        }
-                    };
-                };
-                methodAspectCollection.push(fn);
-            }
-            else {
-                debugLogger(`aspect [#${module.name}:${name}], isAsync=false, aspect class=[${aspectIns.constructor.name}]`);
-                const fn = (ins, originMethod) => {
-                    return (...args) => {
-                        var _a, _b, _c;
-                        let error, result;
-                        const newProceed = (...args) => {
-                            return originMethod.apply(ins, args);
-                        };
-                        const joinPoint = {
-                            methodName: name,
-                            target: ins,
-                            args: args,
-                            proceed: newProceed,
-                        };
-                        try {
-                            (_a = aspectIns.before) === null || _a === void 0 ? void 0 : _a.call(aspectIns, joinPoint);
-                            if (aspectIns.around) {
-                                result = aspectIns.around(joinPoint);
-                            }
-                            else {
-                                result = originMethod.apply(ins, joinPoint.args);
-                            }
-                            const resultTemp = (_b = aspectIns.afterReturn) === null || _b === void 0 ? void 0 : _b.call(aspectIns, joinPoint, result);
-                            result = typeof resultTemp === 'undefined' ? result : resultTemp;
-                            if (result && decorator_1.isClass(result.constructor)) {
-                                return this.wrapperAspectToInstance(ins);
-                            }
-                            else {
-                                return result;
-                            }
-                        }
-                        catch (err) {
-                            error = err;
-                            if (aspectIns.afterThrow) {
-                                aspectIns.afterThrow(joinPoint, error);
-                            }
-                            else {
-                                throw err;
-                            }
-                        }
-                        finally {
-                            (_c = aspectIns.after) === null || _c === void 0 ? void 0 : _c.call(aspectIns, joinPoint, result, error);
-                        }
-                    };
-                };
-                methodAspectCollection.push(fn);
-            }
+            this.interceptPrototypeMethod(module, name, aspectIns);
         }
     }
     /**
-     * wrapper aspect method before instance return
-     * @param ins
-     * @protected
+     * intercept class method in prototype
+     * @param Clz class you want to intercept
+     * @param methodName method name you want to intercept
+     * @param aspectObject aspect object, before, round, etc.
      */
-    wrapperAspectToInstance(ins) {
-        var _a, _b, _c, _d, _e;
-        let proxy = null;
-        /**
-         * 过滤循环依赖创建的对象
-         */
-        if (!ins['__is_proxy__'] && (ins === null || ins === void 0 ? void 0 : ins.constructor)) {
-            // 动态处理拦截器
-            let methodAspectCollection;
-            if ((_a = this.aspectMappingMap) === null || _a === void 0 ? void 0 : _a.has(ins.constructor)) {
-                methodAspectCollection = this.aspectMappingMap.get(ins.constructor);
-            }
-            else if ((_c = (_b = this.container) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.getAspectService().hasAspect(ins.constructor)) {
-                // for requestContainer
-                methodAspectCollection = (_e = (_d = this.container) === null || _d === void 0 ? void 0 : _d.parent) === null || _e === void 0 ? void 0 : _e.getAspectService().hasAspect(ins.constructor);
-            }
-            if (methodAspectCollection) {
-                proxy = new Proxy(ins, {
-                    get: (obj, prop) => {
-                        if (typeof prop === 'string' && methodAspectCollection.has(prop)) {
-                            const aspectFn = methodAspectCollection.get(prop);
-                            return aspectFn[0](ins, obj[prop]);
-                        }
-                        return obj[prop];
-                    },
-                });
-            }
+    interceptPrototypeMethod(Clz, methodName, aspectObject) {
+        const originMethod = Clz.prototype[methodName];
+        if ((0, decorator_1.isAsyncFunction)(Clz.prototype[methodName])) {
+            Clz.prototype[methodName] = async function (...args) {
+                var _a, _b, _c;
+                let error, result;
+                const newProceed = (...args) => {
+                    return originMethod.apply(this, args);
+                };
+                const joinPoint = {
+                    methodName,
+                    target: this,
+                    args: args,
+                    proceed: newProceed,
+                };
+                if (typeof aspectObject === 'function') {
+                    aspectObject = aspectObject();
+                }
+                try {
+                    await ((_a = aspectObject.before) === null || _a === void 0 ? void 0 : _a.call(aspectObject, joinPoint));
+                    if (aspectObject.around) {
+                        result = await aspectObject.around(joinPoint);
+                    }
+                    else {
+                        result = await originMethod.call(this, ...joinPoint.args);
+                    }
+                    joinPoint.proceed = undefined;
+                    const resultTemp = await ((_b = aspectObject.afterReturn) === null || _b === void 0 ? void 0 : _b.call(aspectObject, joinPoint, result));
+                    result = typeof resultTemp === 'undefined' ? result : resultTemp;
+                    return result;
+                }
+                catch (err) {
+                    joinPoint.proceed = undefined;
+                    error = err;
+                    if (aspectObject.afterThrow) {
+                        await aspectObject.afterThrow(joinPoint, error);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                finally {
+                    await ((_c = aspectObject.after) === null || _c === void 0 ? void 0 : _c.call(aspectObject, joinPoint, result, error));
+                }
+            };
+        }
+        else {
+            Clz.prototype[methodName] = function (...args) {
+                var _a, _b, _c;
+                let error, result;
+                const newProceed = (...args) => {
+                    return originMethod.apply(this, args);
+                };
+                const joinPoint = {
+                    methodName,
+                    target: this,
+                    args: args,
+                    proceed: newProceed,
+                };
+                if (typeof aspectObject === 'function') {
+                    aspectObject = aspectObject();
+                }
+                try {
+                    (_a = aspectObject.before) === null || _a === void 0 ? void 0 : _a.call(aspectObject, joinPoint);
+                    if (aspectObject.around) {
+                        result = aspectObject.around(joinPoint);
+                    }
+                    else {
+                        result = originMethod.call(this, ...joinPoint.args);
+                    }
+                    joinPoint.proceed = undefined;
+                    const resultTemp = (_b = aspectObject.afterReturn) === null || _b === void 0 ? void 0 : _b.call(aspectObject, joinPoint, result);
+                    result = typeof resultTemp === 'undefined' ? result : resultTemp;
+                    return result;
+                }
+                catch (err) {
+                    joinPoint.proceed = undefined;
+                    error = err;
+                    if (aspectObject.afterThrow) {
+                        aspectObject.afterThrow(joinPoint, error);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                finally {
+                    (_c = aspectObject.after) === null || _c === void 0 ? void 0 : _c.call(aspectObject, joinPoint, result, error);
+                }
+            };
         }
-        return proxy || ins;
-    }
-    hasAspect(module) {
-        return this.aspectMappingMap.has(module);
     }
-}
+};
+MidwayAspectService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayAspectService);
 exports.MidwayAspectService = MidwayAspectService;
 //# sourceMappingURL=aspectService.js.map

package/dist/service/configService.d.ts

@@ -1,19 +1,21 @@
 import { IConfigService } from '../interface';
+import { MidwayEnvironmentService } from './environmentService';
+import { MidwayInformationService } from './informationService';
 export declare class MidwayConfigService implements IConfigService {
     private envDirMap;
-    private container;
     private aliasMap;
-    configuration: any;
-    isReady: boolean;
-    externalObject: Record<string, unknown>[];
-    constructor(container: any);
+    protected configuration: any;
+    protected isReady: boolean;
+    protected externalObject: Record<string, unknown>[];
+    protected environmentService: MidwayEnvironmentService;
+    protected informationService: MidwayInformationService;
     add(configFilePaths: any[]): void;
     addObject(obj: Record<string, unknown>): void;
-    getEnvSet(env: any): Set<any>;
-    getConfigEnv(configFilePath: any): string;
+    private getEnvSet;
+    private getConfigEnv;
     load(): Promise<void>;
     getConfiguration(configKey?: string): any;
-    loadConfig(configFilename: any, target?: any): Promise<Record<string, unknown>>;
+    private loadConfig;
     clearAllConfig(): void;
 }
 //# sourceMappingURL=configService.d.ts.map

package/dist/service/configService.js

@@ -1,4 +1,13 @@
 "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.MidwayConfigService = void 0;
 const extend = require("extend2");
@@ -7,17 +16,18 @@ const util_1 = require("../util");
 const fs_1 = require("fs");
 const decorator_1 = require("@midwayjs/decorator");
 const util = require("util");
-const debug = util.debuglog('midway:config');
-class MidwayConfigService {
-    constructor(container) {
+const environmentService_1 = require("./environmentService");
+const informationService_1 = require("./informationService");
+const debug = util.debuglog('midway:debug');
+let MidwayConfigService = class MidwayConfigService {
+    constructor() {
+        this.envDirMap = new Map();
         this.aliasMap = {
             prod: 'production',
             unittest: 'test',
         };
         this.isReady = false;
         this.externalObject = [];
-        this.container = container;
-        this.envDirMap = new Map();
     }
     add(configFilePaths) {
         for (const dir of configFilePaths) {
@@ -33,11 +43,11 @@ class MidwayConfigService {
                 }
                 else {
                     // directory
-                    const fileStat = fs_1.statSync(dir);
+                    const fileStat = (0, fs_1.statSync)(dir);
                     if (fileStat.isDirectory()) {
-                        const files = fs_1.readdirSync(dir);
+                        const files = (0, fs_1.readdirSync)(dir);
                         this.add(files.map(file => {
-                            return path_1.join(dir, file);
+                            return (0, path_1.join)(dir, file);
                         }));
                     }
                 }
@@ -67,7 +77,7 @@ class MidwayConfigService {
     }
     getConfigEnv(configFilePath) {
         // parse env
-        const configFileBaseName = path_1.basename(configFilePath);
+        const configFileBaseName = (0, path_1.basename)(configFilePath);
         const splits = configFileBaseName.split('.');
         const suffix = splits.pop();
         if (suffix !== 'js' && suffix !== 'ts') {
@@ -81,24 +91,41 @@ class MidwayConfigService {
         // get default
         const defaultSet = this.getEnvSet('default');
         // get current set
-        const currentEnvSet = this.getEnvSet(this.container.getCurrentEnv());
+        const currentEnvSet = this.getEnvSet(this.environmentService.getCurrentEnvironment());
         // merge set
         const target = {};
         for (const filename of [...defaultSet, ...currentEnvSet]) {
-            let config = filename;
-            if (typeof filename === 'string') {
-                config = await this.loadConfig(filename, target);
+            let config = await this.loadConfig(filename);
+            if ((0, decorator_1.isFunction)(config)) {
+                // eslint-disable-next-line prefer-spread
+                config = config.apply(null, [
+                    {
+                        pkg: this.informationService.getPkg(),
+                        name: this.informationService.getProjectName(),
+                        baseDir: this.informationService.getBaseDir(),
+                        appDir: this.informationService.getAppDir(),
+                        HOME: this.informationService.getHome(),
+                        root: this.informationService.getRoot(),
+                        env: this.environmentService.getCurrentEnvironment(),
+                    },
+                    target,
+                ]);
             }
             if (!config) {
                 continue;
             }
-            debug('Loaded config %s, %j', filename, config);
+            if (typeof filename === 'string') {
+                debug('[config]: Loaded config %s, %j', filename, config);
+            }
+            else {
+                debug('[config]: Loaded config %j', config);
+            }
             extend(true, target, config);
         }
         if (this.externalObject.length) {
             for (const externalObject of this.externalObject) {
                 if (externalObject) {
-                    debug('Loaded external object %j', externalObject);
+                    debug('[config]: Loaded external object %j', externalObject);
                     extend(true, target, externalObject);
                 }
             }
@@ -108,38 +135,34 @@ class MidwayConfigService {
     }
     getConfiguration(configKey) {
         if (configKey) {
-            debug('get configuration by key => %s.', configKey);
-            return util_1.safelyGet(configKey, this.configuration);
+            return (0, util_1.safelyGet)(configKey, this.configuration);
         }
         return this.configuration;
     }
-    async loadConfig(configFilename, target) {
-        debug('load config %s.', configFilename);
-        let exports = require(configFilename);
+    async loadConfig(configFilename) {
+        let exports = typeof configFilename === 'string'
+            ? require(configFilename)
+            : configFilename;
         if (exports && exports['default'] && Object.keys(exports).length === 1) {
             exports = exports['default'];
         }
-        let result = exports;
-        if (decorator_1.isFunction(exports)) {
-            const informationService = this.container.getInformationService();
-            // eslint-disable-next-line prefer-spread
-            result = exports.apply(null, [
-                {
-                    pkg: informationService.getPkg(),
-                    name: informationService.getProjectName(),
-                    baseDir: informationService.getBaseDir(),
-                    appDir: informationService.getAppDir(),
-                    HOME: informationService.getHome(),
-                    root: informationService.getRoot(),
-                },
-                target,
-            ]);
-        }
-        return result;
+        return exports;
     }
     clearAllConfig() {
         this.configuration.clear();
     }
-}
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", environmentService_1.MidwayEnvironmentService)
+], MidwayConfigService.prototype, "environmentService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", informationService_1.MidwayInformationService)
+], MidwayConfigService.prototype, "informationService", void 0);
+MidwayConfigService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayConfigService);
 exports.MidwayConfigService = MidwayConfigService;
 //# sourceMappingURL=configService.js.map

package/dist/service/decoratorService.d.ts

@@ -0,0 +1,23 @@
+import { HandlerFunction, IMidwayContainer, MethodHandlerFunction, ParameterHandlerFunction } from '../interface';
+export declare class MidwayDecoratorService {
+    readonly applicationContext: IMidwayContainer;
+    private propertyHandlerMap;
+    private methodDecoratorMap;
+    private parameterDecoratorMap;
+    private aspectService;
+    constructor(applicationContext: IMidwayContainer);
+    protected init(): Promise<void>;
+    registerPropertyHandler(decoratorKey: string, fn: HandlerFunction): void;
+    registerMethodHandler(decoratorKey: string, fn: MethodHandlerFunction): void;
+    registerParameterHandler(decoratorKey: string, fn: ParameterHandlerFunction): void;
+    /**
+     * binding getter method for decorator
+     *
+     * @param prop
+     * @param instance
+     * @param getterHandler
+     */
+    private defineGetterPropertyValue;
+    private getHandler;
+}
+//# sourceMappingURL=decoratorService.d.ts.map