@midwayjs/core 3.9.0 → 3.10.1

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
@@ -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");
@@ -97,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.`);
@@ -106,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);
             }
@@ -184,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

@@ -7,6 +7,7 @@ export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     readonly globalOptions: {};
     configService: MidwayConfigService;
     private loggerFactory;
+    private lazyLoggerConfigMap;
     constructor(applicationContext: IMidwayContainer, globalOptions?: {});
     protected init(): void;
     protected createClient(config: any, name?: string): void;

package/dist/service/loggerService.js

@@ -13,12 +13,14 @@ 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, globalOptions = {}) {
         super();
         this.applicationContext = applicationContext;
         this.globalOptions = globalOptions;
+        this.lazyLoggerConfigMap = new Map();
     }
     init() {
         var _a;
@@ -28,7 +30,13 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
         (_a = this.applicationContext) === null || _a === void 0 ? void 0 : _a.registerObject('logger', this.getLogger('appLogger'));
     }
     createClient(config, name) {
-        this.loggerFactory.createLogger(name, config);
+        if (!config.lazyLoad) {
+            this.loggerFactory.createLogger(name, config);
+        }
+        else {
+            delete config['lazyLoad'];
+            this.lazyLoggerConfigMap.set(name, config);
+        }
     }
     getName() {
         return 'logger';
@@ -37,6 +45,15 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
         return this.loggerFactory.createLogger(name, config);
     }
     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() {
@@ -55,7 +72,7 @@ __decorate([
 ], MidwayLoggerService.prototype, "init", null);
 MidwayLoggerService = __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])
 ], MidwayLoggerService);
 exports.MidwayLoggerService = MidwayLoggerService;

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;

package/dist/setup.js

@@ -32,6 +32,8 @@ async function initializeGlobalApplicationContext(globalOptions) {
     await applicationContext.getAsync(_1.MidwayLifeCycleService, [
         applicationContext,
     ]);
+    // mock support
+    await applicationContext.get(_1.MidwayMockService, [applicationContext]);
     // some preload module init
     const modules = (0, decorator_1.listPreloadModule)();
     for (const module of modules) {

package/dist/util/httpclient.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import http = require('http');
-declare type MethodType = 'GET' | 'POST';
-declare type MimeType = 'text' | 'json' | undefined;
+type MethodType = 'GET' | 'POST';
+type MimeType = 'text' | 'json' | undefined;
 interface IOptions {
     method?: MethodType;
     headers?: any;

package/dist/util/pathToRegexp.d.ts

@@ -30,7 +30,7 @@ interface TokensToFunctionOptions {
  * Compile a string to a template function for the path.
  */
 declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
-declare type PathFunction<P extends object = object> = (data?: P) => string;
+type PathFunction<P extends object = object> = (data?: P) => string;
 interface RegexpToFunctionOptions {
     /**
      * Function for decoding strings for params.
@@ -48,11 +48,11 @@ interface MatchResult<P extends object = object> {
 /**
  * A match is either `false` (no match) or a match result.
  */
-declare type Match<P extends object = object> = false | MatchResult<P>;
+type Match<P extends object = object> = false | MatchResult<P>;
 /**
  * The match function takes a string and returns whether it matched the path.
  */
-declare type MatchFunction<P extends object = object> = (path: string) => Match<P>;
+type MatchFunction<P extends object = object> = (path: string) => Match<P>;
 /**
  * Create path match function from `path-to-regexp` spec.
  */
@@ -70,7 +70,7 @@ interface Key {
 /**
  * A token is a string (nothing special) or key metadata (capture group).
  */
-declare type Token = string | Key;
+type Token = string | Key;
 interface TokensToRegexpOptions {
     /**
      * When `true` the regexp will be case sensitive. (default: `false`)
@@ -104,7 +104,7 @@ interface TokensToRegexpOptions {
 /**
  * Supported `path-to-regexp` input types.
  */
-declare type Path = string | RegExp | Array<string | RegExp>;
+type Path = string | RegExp | Array<string | RegExp>;
 /**
  * Normalize the given path string, returning a regular expression.
  *

package/dist/util/webRouterParam.d.ts

@@ -1,5 +1,3 @@
-import { PipeTransform, PipeTransformFunction } from '../decorator';
-export declare function callPipes(pipes: Array<PipeTransform | PipeTransformFunction>, value: any): Promise<any>;
-export declare const extractKoaLikeValue: (key: any, data: any, paramType?: any, pipes?: PipeTransform[]) => (ctx: any, next: any) => Promise<any>;
-export declare const extractExpressLikeValue: (key: any, data: any, paramType?: any, pipes?: PipeTransform[]) => (req: any, res: any, next: any) => Promise<any>;
+export declare const extractKoaLikeValue: (key: any, data: any, paramType?: any) => (ctx: any, next: any) => any;
+export declare const extractExpressLikeValue: (key: any, data: any, paramType?: any) => (req: any, res: any, next: any) => any;
 //# sourceMappingURL=webRouterParam.d.ts.map