@midwayjs/core 3.8.0 → 3.10.0

package/dist/service/decoratorService.js

@@ -11,9 +11,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayDecoratorService = void 0;
 const decorator_1 = require("../decorator");
+const interface_1 = require("../interface");
 const aspectService_1 = require("./aspectService");
 const error_1 = require("../error");
 const util = require("util");
+const types_1 = require("../util/types");
 const debug = util.debuglog('midway:debug');
 let MidwayDecoratorService = class MidwayDecoratorService {
     constructor(applicationContext) {
@@ -21,6 +23,7 @@ let MidwayDecoratorService = class MidwayDecoratorService {
         this.propertyHandlerMap = new Map();
         this.methodDecoratorMap = new Map();
         this.parameterDecoratorMap = new Map();
+        this.parameterDecoratorPipes = new Map();
     }
     init() {
         // add custom method decorator listener
@@ -30,8 +33,8 @@ let MidwayDecoratorService = class MidwayDecoratorService {
             if (methodDecoratorMetadataList) {
                 // loop it, save this order for decorator run
                 for (const meta of methodDecoratorMetadataList) {
-                    const { propertyName, key, metadata, impl } = meta;
-                    if (!impl) {
+                    const { propertyName, key, metadata, options } = meta;
+                    if (!options.impl) {
                         continue;
                     }
                     // add aspect implementation first
@@ -40,7 +43,7 @@ let MidwayDecoratorService = class MidwayDecoratorService {
                         if (!methodDecoratorHandler) {
                             throw new error_1.MidwayCommonError(`Method Decorator "${key}" handler not found, please register first.`);
                         }
-                        return this.methodDecoratorMap.get(key)({
+                        return methodDecoratorHandler({
                             target: Clzz,
                             propertyName,
                             metadata,
@@ -60,15 +63,23 @@ let MidwayDecoratorService = class MidwayDecoratorService {
                                 // joinPoint.args
                                 const newArgs = [...joinPoint.args];
                                 for (const meta of parameterDecoratorMetadata[methodName]) {
-                                    const { propertyName, key, metadata, parameterIndex, impl } = meta;
-                                    if (!impl) {
-                                        continue;
+                                    const { propertyName, key, metadata, parameterIndex, options, } = meta;
+                                    let parameterDecoratorHandler;
+                                    if (options.impl) {
+                                        parameterDecoratorHandler =
+                                            this.parameterDecoratorMap.get(key);
+                                        if (!parameterDecoratorHandler) {
+                                            throw new error_1.MidwayCommonError(`Parameter Decorator "${key}" handler not found, please register first.`);
+                                        }
                                     }
-                                    const parameterDecoratorHandler = this.parameterDecoratorMap.get(key);
-                                    if (!parameterDecoratorHandler) {
-                                        throw new error_1.MidwayCommonError(`Parameter Decorator "${key}" handler not found, please register first.`);
+                                    else {
+                                        // set default handler
+                                        parameterDecoratorHandler = async ({ parameterIndex, originArgs, }) => {
+                                            return originArgs[parameterIndex];
+                                        };
                                     }
                                     const paramTypes = (0, decorator_1.getMethodParamTypes)(Clzz, propertyName);
+                                    let skipPipes = false;
                                     try {
                                         newArgs[parameterIndex] = await parameterDecoratorHandler({
                                             metadata,
@@ -80,8 +91,43 @@ let MidwayDecoratorService = class MidwayDecoratorService {
                                         });
                                     }
                                     catch (err) {
-                                        // ignore
-                                        debug(`[core]: Parameter decorator throw error and use origin args, ${err.stack}`);
+                                        skipPipes = true;
+                                        if ((options === null || options === void 0 ? void 0 : options.throwError) === true) {
+                                            throw err;
+                                        }
+                                        else {
+                                            // ignore
+                                            debug(`[core]: Parameter decorator throw error and use origin args, ${err.stack}`);
+                                        }
+                                    }
+                                    if (skipPipes) {
+                                        continue;
+                                    }
+                                    const pipes = [
+                                        ...(this.parameterDecoratorPipes.get(key) || []),
+                                        ...((options === null || options === void 0 ? void 0 : options.pipes) || []),
+                                    ];
+                                    for (const pipe of pipes) {
+                                        let transform;
+                                        if ('transform' in pipe) {
+                                            transform = pipe['transform'].bind(pipe);
+                                        }
+                                        else if ((0, types_1.isClass)(pipe)) {
+                                            const ins = await this.applicationContext.getAsync(pipe);
+                                            transform = ins.transform.bind(ins);
+                                        }
+                                        else if (typeof pipe === 'function') {
+                                            transform = pipe;
+                                        }
+                                        else {
+                                            throw new error_1.MidwayParameterError('Pipe must be a function or implement PipeTransform interface');
+                                        }
+                                        newArgs[parameterIndex] = await transform(newArgs[parameterIndex], {
+                                            metaType: (0, decorator_1.transformTypeFromTSDesign)(paramTypes[parameterIndex]),
+                                            metadata,
+                                            target: joinPoint.target,
+                                            methodName: joinPoint.methodName,
+                                        });
                                     }
                                 }
                                 joinPoint.args = newArgs;
@@ -118,6 +164,12 @@ let MidwayDecoratorService = class MidwayDecoratorService {
         debug(`[core]: Register parameter decorator key="${decoratorKey}"`);
         this.parameterDecoratorMap.set(decoratorKey, fn);
     }
+    registerParameterPipes(decoratorKey, pipes) {
+        if (!this.parameterDecoratorPipes.has(decoratorKey)) {
+            this.parameterDecoratorPipes.set(decoratorKey, []);
+        }
+        this.parameterDecoratorPipes.set(decoratorKey, this.parameterDecoratorPipes.get(decoratorKey).concat(pipes));
+    }
     /**
      * binding getter method for decorator
      *
@@ -154,7 +206,7 @@ __decorate([
 ], MidwayDecoratorService.prototype, "init", null);
 MidwayDecoratorService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayDecoratorService);
 exports.MidwayDecoratorService = MidwayDecoratorService;

package/dist/service/environmentService.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayEnvironmentService = void 0;
+const interface_1 = require("../interface");
 const util_1 = require("../util");
 const decorator_1 = require("../decorator");
 let MidwayEnvironmentService = class MidwayEnvironmentService {
@@ -25,7 +26,7 @@ let MidwayEnvironmentService = class MidwayEnvironmentService {
 };
 MidwayEnvironmentService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
 ], MidwayEnvironmentService);
 exports.MidwayEnvironmentService = MidwayEnvironmentService;
 //# sourceMappingURL=environmentService.js.map

package/dist/service/frameworkService.d.ts

@@ -1,5 +1,4 @@
-import { MidwayFrameworkType } from '../decorator';
-import { IMidwayContainer, IMidwayFramework } from '../interface';
+import { IMidwayContainer, IMidwayFramework, MidwayFrameworkType } from '../interface';
 import { MidwayConfigService } from './configService';
 import { MidwayLoggerService } from './loggerService';
 import { MidwayDecoratorService } from './decoratorService';

package/dist/service/frameworkService.js

@@ -11,6 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayFrameworkService = void 0;
 const decorator_1 = require("../decorator");
+const interface_1 = require("../interface");
 const configService_1 = require("./configService");
 const loggerService_1 = require("./loggerService");
 const baseFramework_1 = require("../baseFramework");
@@ -66,6 +67,21 @@ let MidwayFrameworkService = class MidwayFrameworkService {
             var _a;
             return this.getMainApp()[(_a = meta.identifier) !== null && _a !== void 0 ? _a : propertyName];
         });
+        this.decoratorService.registerPropertyHandler(decorator_1.FACTORY_SERVICE_CLIENT_KEY, (propertyName, meta) => {
+            const factory = this.applicationContext.get(meta.serviceFactoryClz);
+            const clientName = meta.clientName || factory.getDefaultClientName();
+            if (clientName && factory.has(clientName)) {
+                return factory.get(clientName);
+            }
+            else {
+                if (!clientName) {
+                    throw new error_1.MidwayParameterError(`Please set clientName or options.defaultClientName for ${meta.serviceFactoryClz.name}).`);
+                }
+                else {
+                    throw new error_1.MidwayParameterError(`ClientName(${clientName} not found in ${meta.serviceFactoryClz.name}).`);
+                }
+            }
+        });
         let frameworks = (0, decorator_1.listModule)(decorator_1.FRAMEWORK_KEY);
         // filter proto
         frameworks = filterProtoFramework(frameworks);
@@ -82,6 +98,7 @@ let MidwayFrameworkService = class MidwayFrameworkService {
                     // app init
                     await frameworkInstance.initialize({
                         applicationContext: this.applicationContext,
+                        namespace: frameworkInstance.getNamespace(),
                         ...this.globalOptions,
                     });
                     debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
@@ -91,6 +108,9 @@ let MidwayFrameworkService = class MidwayFrameworkService {
                 }
                 // app init
                 const definition = this.applicationContext.registry.getDefinition((0, decorator_1.getProviderUUId)(frameworkClz));
+                // set framework namespace here
+                frameworkInstance.setNamespace(definition === null || definition === void 0 ? void 0 : definition.namespace);
+                // link framework to application manager
                 this.applicationManager.addFramework((_a = definition === null || definition === void 0 ? void 0 : definition.namespace) !== null && _a !== void 0 ? _a : frameworkInstance.getFrameworkName(), frameworkInstance);
                 this.globalFrameworkList.push(frameworkInstance);
             }
@@ -169,7 +189,7 @@ __decorate([
 ], MidwayFrameworkService.prototype, "init", null);
 MidwayFrameworkService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object, Object])
 ], MidwayFrameworkService);
 exports.MidwayFrameworkService = MidwayFrameworkService;

package/dist/service/informationService.js

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayInformationService = void 0;
+const interface_1 = require("../interface");
 const util_1 = require("../util");
 const path_1 = require("path");
 const decorator_1 = require("../decorator");
@@ -62,7 +63,7 @@ __decorate([
 ], MidwayInformationService.prototype, "init", null);
 MidwayInformationService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
 ], MidwayInformationService);
 exports.MidwayInformationService = MidwayInformationService;
 //# sourceMappingURL=informationService.js.map

package/dist/service/lifeCycleService.d.ts

@@ -1,10 +1,12 @@
 import { IMidwayContainer } from '../interface';
 import { MidwayFrameworkService } from './frameworkService';
 import { MidwayConfigService } from './configService';
+import { MidwayMockService } from './mockService';
 export declare class MidwayLifeCycleService {
     readonly applicationContext: IMidwayContainer;
     protected frameworkService: MidwayFrameworkService;
     protected configService: MidwayConfigService;
+    protected mockService: MidwayMockService;
     constructor(applicationContext: IMidwayContainer);
     protected init(): Promise<void>;
     stop(): Promise<void>;

package/dist/service/lifeCycleService.js

@@ -10,17 +10,21 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayLifeCycleService = void 0;
+const interface_1 = require("../interface");
 const decorator_1 = require("../decorator");
 const configuration_1 = require("../functional/configuration");
 const frameworkService_1 = require("./frameworkService");
 const configService_1 = require("./configService");
 const util_1 = require("util");
+const mockService_1 = require("./mockService");
 const debug = (0, util_1.debuglog)('midway:debug');
 let MidwayLifeCycleService = class MidwayLifeCycleService {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
     }
     async init() {
+        // exec simulator init
+        await this.mockService.initSimulation();
         // run lifecycle
         const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
         debug(`[core]: Found Configuration length = ${cycles.length}`);
@@ -32,7 +36,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
             }
             else {
                 // 普通类写法
-                debug(`[core]: Lifecycle run ${cycle.target.name} init`);
+                debug(`[core]: Lifecycle run ${cycle.namespace} init`);
                 cycle.instance = await this.applicationContext.getAsync(cycle.target);
             }
             cycle.instance && lifecycleInstanceList.push(cycle);
@@ -52,6 +56,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
                 this.configService.addObject(configData);
             }
         });
+        await this.mockService.runSimulatorSetup();
         // exec onReady()
         await this.runContainerLifeCycle(lifecycleInstanceList, 'onReady');
         // exec framework.run()
@@ -64,9 +69,10 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         }
     }
     async stop() {
+        await this.mockService.runSimulatorTearDown();
         // stop lifecycle
-        const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
-        for (const cycle of cycles) {
+        const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY) || [];
+        for (const cycle of cycles.reverse()) {
             let inst;
             if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
                 // 函数式写法
@@ -119,6 +125,10 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", configService_1.MidwayConfigService)
 ], MidwayLifeCycleService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", mockService_1.MidwayMockService)
+], MidwayLifeCycleService.prototype, "mockService", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
@@ -127,7 +137,7 @@ __decorate([
 ], MidwayLifeCycleService.prototype, "init", null);
 MidwayLifeCycleService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayLifeCycleService);
 exports.MidwayLifeCycleService = MidwayLifeCycleService;

package/dist/service/loggerService.d.ts

@@ -1,15 +1,19 @@
 import { MidwayConfigService } from './configService';
 import { ServiceFactory } from '../common/serviceFactory';
-import { ILogger, LoggerOptions } from '@midwayjs/logger';
-import { IMidwayContainer } from '../interface';
+import { ILogger, IMidwayContainer } from '../interface';
+import { LoggerFactory } from '../common/loggerFactory';
 export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     readonly applicationContext: IMidwayContainer;
+    readonly globalOptions: {};
     configService: MidwayConfigService;
-    constructor(applicationContext: IMidwayContainer);
-    protected init(): void;
-    protected createClient(config: LoggerOptions, name?: string): void;
+    private loggerFactory;
+    private lazyLoggerConfigMap;
+    constructor(applicationContext: IMidwayContainer, globalOptions?: {});
+    protected init(): Promise<void>;
+    protected createClient(config: any, name?: string): void;
     getName(): string;
-    createLogger(name: any, config: any): ILogger;
-    getLogger(name: string): ILogger;
+    createLogger(name: any, config: any): any;
+    getLogger(name: string): any;
+    getCurrentLoggerFactory(): LoggerFactory<any, any>;
 }
 //# sourceMappingURL=loggerService.d.ts.map

package/dist/service/loggerService.js

@@ -13,29 +13,51 @@ exports.MidwayLoggerService = void 0;
 const decorator_1 = require("../decorator");
 const configService_1 = require("./configService");
 const serviceFactory_1 = require("../common/serviceFactory");
+const interface_1 = require("../interface");
 const logger_1 = require("@midwayjs/logger");
 let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.ServiceFactory {
-    constructor(applicationContext) {
+    constructor(applicationContext, globalOptions = {}) {
         super();
         this.applicationContext = applicationContext;
+        this.globalOptions = globalOptions;
+        this.lazyLoggerConfigMap = new Map();
     }
-    init() {
+    async init() {
         var _a;
-        this.initClients(this.configService.getConfiguration('midwayLogger'));
+        this.loggerFactory = this.globalOptions['loggerFactory'] || logger_1.loggers;
+        await this.initClients(this.configService.getConfiguration('midwayLogger'));
         // alias inject logger
         (_a = this.applicationContext) === null || _a === void 0 ? void 0 : _a.registerObject('logger', this.getLogger('appLogger'));
     }
     createClient(config, name) {
-        logger_1.loggers.createLogger(name, config);
+        if (!config.lazyLoad) {
+            this.loggerFactory.createLogger(name, config);
+        }
+        else {
+            delete config['lazyLoad'];
+            this.lazyLoggerConfigMap.set(name, config);
+        }
     }
     getName() {
         return 'logger';
     }
     createLogger(name, config) {
-        return logger_1.loggers.createLogger(name, config);
+        return this.loggerFactory.createLogger(name, config);
     }
     getLogger(name) {
-        return logger_1.loggers.getLogger(name);
+        const logger = this.loggerFactory.getLogger(name);
+        if (logger) {
+            return logger;
+        }
+        if (this.lazyLoggerConfigMap.has(name)) {
+            // try to lazy init
+            this.createClient(this.lazyLoggerConfigMap.get(name), name);
+            this.lazyLoggerConfigMap.delete(name);
+        }
+        return this.loggerFactory.getLogger(name);
+    }
+    getCurrentLoggerFactory() {
+        return this.loggerFactory;
     }
 };
 __decorate([
@@ -46,12 +68,12 @@ __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], MidwayLoggerService.prototype, "init", null);
 MidwayLoggerService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
-    __metadata("design:paramtypes", [Object])
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object, Object])
 ], MidwayLoggerService);
 exports.MidwayLoggerService = MidwayLoggerService;
 //# sourceMappingURL=loggerService.js.map

package/dist/service/middlewareService.js

@@ -11,6 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayMiddlewareService = void 0;
 const decorator_1 = require("../decorator");
+const interface_1 = require("../interface");
 const error_1 = require("../error");
 const util_1 = require("../util");
 const types_1 = require("../util/types");
@@ -126,7 +127,7 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
 };
 MidwayMiddlewareService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayMiddlewareService);
 exports.MidwayMiddlewareService = MidwayMiddlewareService;

package/dist/service/mockService.d.ts

@@ -1,4 +1,4 @@
-import { IMidwayApplication, IMidwayContainer, IMidwayContext } from '../interface';
+import { IMidwayApplication, IMidwayContainer, IMidwayContext, ISimulation } from '../interface';
 export declare class MidwayMockService {
     readonly applicationContext: IMidwayContainer;
     protected mocks: any[];
@@ -8,6 +8,7 @@ export declare class MidwayMockService {
         value: any;
     }>;
     protected cache: Map<any, any>;
+    protected simulatorList: Array<ISimulation>;
     constructor(applicationContext: IMidwayContainer);
     init(): Promise<void>;
     static prepareMocks: any[];
@@ -21,5 +22,12 @@ export declare class MidwayMockService {
     applyContextMocks(app: IMidwayApplication, ctx: IMidwayContext): void;
     getContextMocksSize(): number;
     private overridePropertyDescriptor;
+    initSimulation(): Promise<void>;
+    runSimulatorSetup(): Promise<void>;
+    runSimulatorTearDown(): Promise<void>;
+    runSimulatorAppSetup(app: IMidwayApplication): Promise<void>;
+    runSimulatorAppTearDown(app: IMidwayApplication): Promise<void>;
+    runSimulatorContextSetup(ctx: IMidwayContext, app: IMidwayApplication): Promise<void>;
+    runSimulatorContextTearDown(ctx: IMidwayContext, app: IMidwayApplication): Promise<void>;
 }
 //# sourceMappingURL=mockService.d.ts.map

package/dist/service/mockService.js

@@ -11,6 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var MidwayMockService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayMockService = void 0;
+const interface_1 = require("../interface");
 const decorator_1 = require("../decorator");
 let MidwayMockService = MidwayMockService_1 = class MidwayMockService {
     constructor(applicationContext) {
@@ -18,6 +19,7 @@ let MidwayMockService = MidwayMockService_1 = class MidwayMockService {
         this.mocks = [];
         this.contextMocks = [];
         this.cache = new Map();
+        this.simulatorList = [];
     }
     async init() {
         if (MidwayMockService_1.prepareMocks.length > 0) {
@@ -86,6 +88,7 @@ let MidwayMockService = MidwayMockService_1 = class MidwayMockService {
         this.mocks = [];
         this.contextMocks = [];
         this.cache.clear();
+        this.simulatorList = [];
         MidwayMockService_1.prepareMocks = [];
     }
     isMocked(obj, key) {
@@ -127,6 +130,45 @@ let MidwayMockService = MidwayMockService_1 = class MidwayMockService {
         }
         return descriptor;
     }
+    async initSimulation() {
+        const simulationModule = (0, decorator_1.listModule)(decorator_1.MOCK_KEY);
+        for (const module of simulationModule) {
+            const instance = await this.applicationContext.getAsync(module);
+            if (await instance.enableCondition()) {
+                this.simulatorList.push(instance);
+            }
+        }
+    }
+    async runSimulatorSetup() {
+        for (const simulator of this.simulatorList) {
+            await (simulator === null || simulator === void 0 ? void 0 : simulator.setup());
+        }
+    }
+    async runSimulatorTearDown() {
+        for (const simulator of this.simulatorList) {
+            await (simulator === null || simulator === void 0 ? void 0 : simulator.tearDown());
+        }
+    }
+    async runSimulatorAppSetup(app) {
+        for (const simulator of this.simulatorList) {
+            await (simulator === null || simulator === void 0 ? void 0 : simulator.appSetup(app));
+        }
+    }
+    async runSimulatorAppTearDown(app) {
+        for (const simulator of this.simulatorList) {
+            await (simulator === null || simulator === void 0 ? void 0 : simulator.appTearDown(app));
+        }
+    }
+    async runSimulatorContextSetup(ctx, app) {
+        for (const simulator of this.simulatorList) {
+            await (simulator === null || simulator === void 0 ? void 0 : simulator.contextSetup(ctx, app));
+        }
+    }
+    async runSimulatorContextTearDown(ctx, app) {
+        for (const simulator of this.simulatorList) {
+            await (simulator === null || simulator === void 0 ? void 0 : simulator.contextTearDown(ctx, app));
+        }
+    }
 };
 MidwayMockService.prepareMocks = [];
 __decorate([
@@ -143,7 +185,7 @@ __decorate([
 ], MidwayMockService.prototype, "restore", null);
 MidwayMockService = MidwayMockService_1 = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayMockService);
 exports.MidwayMockService = MidwayMockService;

package/dist/service/pipelineService.d.ts

@@ -1,5 +1,4 @@
-import { IMidwayContainer } from '../interface';
-import { ObjectIdentifier } from '../decorator';
+import { IMidwayContainer, ObjectIdentifier } from '../interface';
 interface IPipelineInfo {
     /**
      * 上次执行结果(只有在执行 waterfall 时才有值)
@@ -122,7 +121,7 @@ export interface IPipelineHandler {
     concatSeries<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
     waterfall<T>(opts: IPipelineOptions): Promise<IPipelineResult<T>>;
 }
-declare type valvesType = Array<ObjectIdentifier | (new (...args: any[]) => any)>;
+type valvesType = Array<ObjectIdentifier | (new (...args: any[]) => any)>;
 export declare class PipelineContext implements IPipelineContext {
     args: any;
     info: IPipelineInfo;

package/dist/service/slsFunctionService.d.ts

@@ -1,5 +1,5 @@
-import { FaaSMetadata } from '../decorator';
 import { MidwayWebRouterService, RouterCollectorOptions, RouterInfo, RouterPriority } from './webRouterService';
+import { FaaSMetadata } from '../interface';
 export declare class MidwayServerlessFunctionService extends MidwayWebRouterService {
     readonly options: RouterCollectorOptions;
     constructor(options?: RouterCollectorOptions);

package/dist/service/slsFunctionService.js

@@ -15,6 +15,7 @@ const webRouterService_1 = require("./webRouterService");
 const container_1 = require("../context/container");
 const fileDetector_1 = require("../common/fileDetector");
 const contextUtil_1 = require("../util/contextUtil");
+const interface_1 = require("../interface");
 let MidwayServerlessFunctionService = class MidwayServerlessFunctionService extends webRouterService_1.MidwayWebRouterService {
     constructor(options = {}) {
         super(Object.assign({}, options, {
@@ -97,8 +98,8 @@ let MidwayServerlessFunctionService = class MidwayServerlessFunctionService exte
                 data.functionTriggerName = webRouter['type'];
                 data.functionTriggerMetadata = webRouter['metadata'];
                 data.functionMetadata = {
-                    functionName,
                     ...functionMeta,
+                    functionName,
                 };
                 this.checkDuplicateAndPush(prefix, data);
             }
@@ -179,7 +180,7 @@ let MidwayServerlessFunctionService = class MidwayServerlessFunctionService exte
 };
 MidwayServerlessFunctionService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayServerlessFunctionService);
 exports.MidwayServerlessFunctionService = MidwayServerlessFunctionService;

package/dist/service/webRouterService.d.ts

@@ -93,7 +93,7 @@ export interface RouterInfo {
      */
     fullUrlFlattenString?: string;
 }
-export declare type DynamicRouterInfo = Omit<RouterInfo, 'id' | 'method' | 'controllerId' | 'controllerMiddleware' | 'responseMetadata'>;
+export type DynamicRouterInfo = Omit<RouterInfo, 'id' | 'method' | 'controllerId' | 'controllerMiddleware' | 'responseMetadata'>;
 export interface RouterPriority {
     prefix: string;
     priority: number;

package/dist/service/webRouterService.js

@@ -16,6 +16,7 @@ const error_1 = require("../error");
 const util = require("util");
 const pathToRegexp_1 = require("../util/pathToRegexp");
 const types_1 = require("../util/types");
+const interface_1 = require("../interface");
 const debug = util.debuglog('midway:debug');
 let MidwayWebRouterService = class MidwayWebRouterService {
     constructor(options = {}) {
@@ -142,7 +143,7 @@ let MidwayWebRouterService = class MidwayWebRouterService {
                 if (functionMeta) {
                     // get function information
                     data.functionName = controllerId + '-' + webRouter.method;
-                    data.functionTriggerName = decorator_1.ServerlessTriggerType.HTTP;
+                    data.functionTriggerName = interface_1.ServerlessTriggerType.HTTP;
                     data.functionTriggerMetadata = {
                         path: (0, util_1.joinURLPath)(prefix, webRouter.path.toString()),
                         method: webRouter.requestMethod,
@@ -323,7 +324,7 @@ let MidwayWebRouterService = class MidwayWebRouterService {
 };
 MidwayWebRouterService = __decorate([
     (0, decorator_1.Provide)(),
-    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton),
     __metadata("design:paramtypes", [Object])
 ], MidwayWebRouterService);
 exports.MidwayWebRouterService = MidwayWebRouterService;