@midwayjs/core 3.3.6 → 3.4.0-beta.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 - Now midwayjs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/baseFramework.d.ts

@@ -8,6 +8,7 @@ import { ContextMiddlewareManager } from './common/middlewareManager';
 import { MidwayMiddlewareService } from './service/middlewareService';
 import { FilterManager } from './common/filterManager';
 import { MidwayMockService } from './service/mockService';
+import { AsyncContextManager } from './common/asyncContextManager';
 export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next> {
     readonly applicationContext: IMidwayContainer;
     app: APP;
@@ -20,6 +21,8 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected composeMiddleware: any;
+    protected bootstrapOptions: IMidwayBootstrapOptions;
+    protected asyncContextManager: AsyncContextManager;
     loggerService: MidwayLoggerService;
     environmentService: MidwayEnvironmentService;
     configService: MidwayConfigService;

package/dist/baseFramework.js

@@ -22,6 +22,7 @@ const middlewareService_1 = require("./service/middlewareService");
 const filterManager_1 = require("./common/filterManager");
 const mockService_1 = require("./service/mockService");
 const util = require("util");
+const asyncContextManager_1 = require("./common/asyncContextManager");
 const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
@@ -45,6 +46,7 @@ class BaseFramework {
         return true;
     }
     async initialize(options) {
+        this.bootstrapOptions = options;
         await this.beforeContainerInitialize(options);
         await this.containerInitialize(options);
         await this.afterContainerInitialize(options);
@@ -231,21 +233,38 @@ class BaseFramework {
      */
     async afterContainerReady(options) { }
     async applyMiddleware(lastMiddleware) {
+        var _a;
+        if (!this.applicationContext.hasObject(interface_1.ASYNC_CONTEXT_MANAGER_KEY)) {
+            const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
+                false;
+            const contextManager = asyncContextManagerEnabled
+                ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.asyncContextManager) || new asyncContextManager_1.NoopContextManager()
+                : new asyncContextManager_1.NoopContextManager();
+            if (asyncContextManagerEnabled) {
+                contextManager.enable();
+            }
+            this.applicationContext.registerObject(interface_1.ASYNC_CONTEXT_MANAGER_KEY, contextManager);
+        }
         if (!this.composeMiddleware) {
             this.middlewareManager.insertFirst((async (ctx, next) => {
-                this.mockService.applyContextMocks(this.app, ctx);
-                let returnResult = undefined;
-                try {
-                    const result = await next();
-                    returnResult = await this.filterManager.runResultFilter(result, ctx);
-                }
-                catch (err) {
-                    returnResult = await this.filterManager.runErrorFilter(err, ctx);
-                }
-                if (returnResult.error) {
-                    throw returnResult.error;
-                }
-                return returnResult.result;
+                // warp with context manager
+                const rootContext = asyncContextManager_1.ASYNC_ROOT_CONTEXT.setValue(interface_1.ASYNC_CONTEXT_KEY, ctx);
+                const contextManager = this.applicationContext.get(interface_1.ASYNC_CONTEXT_MANAGER_KEY);
+                return await contextManager.with(rootContext, async () => {
+                    this.mockService.applyContextMocks(this.app, ctx);
+                    let returnResult = undefined;
+                    try {
+                        const result = await next();
+                        returnResult = await this.filterManager.runResultFilter(result, ctx);
+                    }
+                    catch (err) {
+                        returnResult = await this.filterManager.runErrorFilter(err, ctx);
+                    }
+                    if (returnResult.error) {
+                        throw returnResult.error;
+                    }
+                    return returnResult.result;
+                });
             }));
             debug(`[core]: Compose middleware = [${this.middlewareManager.getNames()}]`);
             this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager, this.app);

package/dist/common/asyncContextManager.d.ts

@@ -0,0 +1,61 @@
+export interface AsyncContext {
+    /**
+     * Get a value from the context.
+     *
+     * @param key key which identifies a context value
+     */
+    getValue(key: symbol): unknown;
+    /**
+     * Create a new context which inherits from this context and has
+     * the given key set to the given value.
+     *
+     * @param key context key for which to set the value
+     * @param value value to set for the given key
+     */
+    setValue(key: symbol, value: unknown): AsyncContext;
+    /**
+     * Return a new context which inherits from this context but does
+     * not contain a value for the given key.
+     *
+     * @param key context key for which to clear a value
+     */
+    deleteValue(key: symbol): AsyncContext;
+}
+export interface AsyncContextManager {
+    /**
+     * Get the current active context
+     */
+    active(): AsyncContext;
+    /**
+     * Run the fn callback with object set as the current active context
+     * @param context Any object to set as the current active context
+     * @param fn A callback to be immediately run within a specific context
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    /**
+     * Bind an object as the current context (or a specific one)
+     * @param [context] Optionally specify the context which you want to assign
+     * @param target Any object to which a context need to be set
+     */
+    bind<T>(context: AsyncContext, target: T): T;
+    /**
+     * Enable context management
+     */
+    enable(): this;
+    /**
+     * Disable context management
+     */
+    disable(): this;
+}
+/** The root context is used as the default parent context when there is no active context */
+export declare const ASYNC_ROOT_CONTEXT: AsyncContext;
+export declare class NoopContextManager implements AsyncContextManager {
+    active(): AsyncContext;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(_context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    bind<T>(_context: AsyncContext, target: T): T;
+    enable(): this;
+    disable(): this;
+}
+//# sourceMappingURL=asyncContextManager.d.ts.map

package/dist/common/asyncContextManager.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopContextManager = exports.ASYNC_ROOT_CONTEXT = void 0;
+class AsyncBaseContext {
+    /**
+     * Construct a new context which inherits values from an optional parent context.
+     *
+     * @param parentContext a context from which to inherit values
+     */
+    constructor(parentContext) {
+        // for minification
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : new Map();
+        self.getValue = (key) => self._currentContext.get(key);
+        self.setValue = (key, value) => {
+            const context = new AsyncBaseContext(self._currentContext);
+            context._currentContext.set(key, value);
+            return context;
+        };
+        self.deleteValue = (key) => {
+            const context = new AsyncBaseContext(self._currentContext);
+            context._currentContext.delete(key);
+            return context;
+        };
+    }
+}
+/** The root context is used as the default parent context when there is no active context */
+exports.ASYNC_ROOT_CONTEXT = new AsyncBaseContext();
+class NoopContextManager {
+    active() {
+        return exports.ASYNC_ROOT_CONTEXT;
+    }
+    with(_context, fn, thisArg, ...args) {
+        return fn.call(thisArg, ...args);
+    }
+    bind(_context, target) {
+        return target;
+    }
+    enable() {
+        return this;
+    }
+    disable() {
+        return this;
+    }
+}
+exports.NoopContextManager = NoopContextManager;
+//# sourceMappingURL=asyncContextManager.js.map

package/dist/common/dataSourceManager.d.ts

@@ -1,7 +1,8 @@
 export declare abstract class DataSourceManager<T> {
     protected dataSource: Map<string, T>;
     protected options: {};
-    protected initDataSource(options?: any): Promise<void>;
+    protected modelMapping: WeakMap<object, any>;
+    protected initDataSource(options: any, appDir: string): Promise<void>;
     /**
      * get a data source instance
      * @param dataSourceName
@@ -19,10 +20,16 @@ export declare abstract class DataSourceManager<T> {
      */
     isConnected(dataSourceName: string): Promise<boolean>;
     createInstance(config: any, clientName: any): Promise<T | void>;
+    /**
+     * get data source name by model or repository
+     * @param modelOrRepository
+     */
+    getDataSourceNameByModel(modelOrRepository: any): string | undefined;
     abstract getName(): string;
     protected abstract createDataSource(config: any, dataSourceName: string): Promise<T | void> | (T | void);
     protected abstract checkConnected(dataSource: T): Promise<boolean>;
     protected destroyDataSource(dataSource: T): Promise<void>;
     stop(): Promise<void>;
 }
+export declare function globModels(globString: string, appDir: string): any[];
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -1,22 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataSourceManager = void 0;
+exports.globModels = exports.DataSourceManager = void 0;
 /**
  * 数据源管理器实现
  */
 const extend_1 = require("../util/extend");
 const error_1 = require("../error");
+const glob_1 = require("@midwayjs/glob");
+const path_1 = require("path");
+const decorator_1 = require("@midwayjs/decorator");
+const DEFAULT_PATTERN = ['**/**.ts', '**/**.js'];
 class DataSourceManager {
     constructor() {
         this.dataSource = new Map();
         this.options = {};
+        this.modelMapping = new WeakMap();
     }
-    async initDataSource(options = {}) {
+    async initDataSource(options, appDir) {
         this.options = options;
         if (options.dataSource) {
             for (const dataSourceName in options.dataSource) {
+                const dataSourceOptions = options.dataSource[dataSourceName];
+                if (dataSourceOptions['entities']) {
+                    const entities = new Set();
+                    // loop entities and glob files to model
+                    for (const entity of dataSourceOptions['entities']) {
+                        if (typeof entity === 'string') {
+                            // string will be glob file
+                            const models = globModels(entity, appDir);
+                            for (const model of models) {
+                                entities.add(model);
+                                this.modelMapping.set(model, dataSourceName);
+                            }
+                        }
+                        else {
+                            // model will be add to array
+                            entities.add(entity);
+                            this.modelMapping.set(entity, dataSourceName);
+                        }
+                    }
+                    dataSourceOptions['entities'] = Array.from(entities);
+                }
                 // create data source
-                await this.createInstance(options.dataSource[dataSourceName], dataSourceName);
+                await this.createInstance(dataSourceOptions, dataSourceName);
             }
         }
         else {
@@ -58,12 +84,44 @@ class DataSourceManager {
             return client;
         }
     }
+    /**
+     * get data source name by model or repository
+     * @param modelOrRepository
+     */
+    getDataSourceNameByModel(modelOrRepository) {
+        return this.modelMapping.get(modelOrRepository);
+    }
     async destroyDataSource(dataSource) { }
     async stop() {
         for (const value of this.dataSource.values()) {
             await this.destroyDataSource(value);
         }
+        this.dataSource.clear();
     }
 }
 exports.DataSourceManager = DataSourceManager;
+function globModels(globString, appDir) {
+    const cwd = (0, path_1.join)(appDir, globString);
+    const models = [];
+    // string will be glob file
+    const files = (0, glob_1.run)(DEFAULT_PATTERN, {
+        cwd,
+    });
+    for (const file of files) {
+        const exports = require(file);
+        if (decorator_1.Types.isClass(exports)) {
+            models.push(exports);
+        }
+        else {
+            for (const m in exports) {
+                const module = exports[m];
+                if (decorator_1.Types.isClass(module)) {
+                    models.push(module);
+                }
+            }
+        }
+    }
+    return models;
+}
+exports.globModels = globModels;
 //# sourceMappingURL=dataSourceManager.js.map

package/dist/common/fileDetector.d.ts

@@ -13,6 +13,7 @@ export declare class DirectoryFileDetector extends AbstractFileDetector<{
     namespace: string;
 }> {
     private directoryFilterArray;
+    private duplicateModuleCheckSet;
     run(container: any): void;
 }
 export declare class CustomModuleDetector extends AbstractFileDetector<{

package/dist/common/fileDetector.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomModuleDetector = exports.DirectoryFileDetector = exports.AbstractFileDetector = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const glob_1 = require("@midwayjs/glob");
+const error_1 = require("../error");
 class AbstractFileDetector {
     constructor(options) {
         this.options = options;
@@ -31,6 +32,7 @@ class DirectoryFileDetector extends AbstractFileDetector {
     constructor() {
         super(...arguments);
         this.directoryFilterArray = [];
+        this.duplicateModuleCheckSet = new Map();
     }
     run(container) {
         const loadDirs = []
@@ -41,6 +43,20 @@ class DirectoryFileDetector extends AbstractFileDetector {
                 cwd: dir,
                 ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []).concat(this.extraDetectorOptions.ignore || []),
             });
+            // 检查重复模块
+            const checkDuplicatedHandler = (module, options) => {
+                if (decorator_1.Types.isClass(module)) {
+                    const name = (0, decorator_1.getProviderName)(module);
+                    if (name) {
+                        if (this.duplicateModuleCheckSet.has(name)) {
+                            throw new error_1.MidwayDuplicateClassNameError(name, options.srcPath, this.duplicateModuleCheckSet.get(name));
+                        }
+                        else {
+                            this.duplicateModuleCheckSet.set(name, options.srcPath);
+                        }
+                    }
+                }
+            };
             for (const file of fileResults) {
                 if (this.directoryFilterArray.length) {
                     for (const resolveFilter of this.directoryFilterArray) {
@@ -68,6 +84,7 @@ class DirectoryFileDetector extends AbstractFileDetector {
                             namespace: this.options.namespace,
                             srcPath: file,
                             createFrom: 'file',
+                            bindHook: checkDuplicatedHandler,
                         });
                     }
                 }
@@ -78,10 +95,13 @@ class DirectoryFileDetector extends AbstractFileDetector {
                         namespace: this.options.namespace,
                         srcPath: file,
                         createFrom: 'file',
+                        bindHook: checkDuplicatedHandler,
                     });
                 }
             }
         }
+        // check end
+        this.duplicateModuleCheckSet.clear();
     }
 }
 exports.DirectoryFileDetector = DirectoryFileDetector;

package/dist/common/filterManager.d.ts

@@ -5,6 +5,7 @@ export declare class FilterManager<CTX extends IMidwayContext = IMidwayContext,
     private exceptionMap;
     private defaultErrFilter;
     private matchFnList;
+    private protoMatchList;
     useFilter(Filters: CommonFilterUnion<CTX, R, N>): void;
     init(applicationContext: IMidwayContainer): Promise<void>;
     runErrorFilter(err: Error, ctx: CTX, res?: R, next?: N): Promise<{

package/dist/common/filterManager.js

@@ -10,6 +10,7 @@ class FilterManager {
         this.exceptionMap = new WeakMap();
         this.defaultErrFilter = undefined;
         this.matchFnList = [];
+        this.protoMatchList = [];
     }
     useFilter(Filters) {
         if (!Array.isArray(Filters)) {
@@ -31,7 +32,20 @@ class FilterManager {
             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);
+                    this.exceptionMap.set(Exception, {
+                        filter,
+                        catchOptions: exceptionMetadata.catchOptions || {},
+                    });
+                    if (exceptionMetadata.catchOptions['matchPrototype']) {
+                        this.protoMatchList.push(err => {
+                            if (err instanceof Exception) {
+                                return Exception;
+                            }
+                            else {
+                                return false;
+                            }
+                        });
+                    }
                 }
             }
             else {
@@ -53,14 +67,32 @@ class FilterManager {
     }
     async runErrorFilter(err, ctx, res, next) {
         let result, error;
+        let matched = false;
         if (this.exceptionMap.has(err.constructor)) {
-            const filter = this.exceptionMap.get(err.constructor);
-            result = await filter.catch(err, ctx, res, next);
+            matched = true;
+            const filterData = this.exceptionMap.get(err.constructor);
+            result = await filterData.filter.catch(err, ctx, res, next);
         }
-        else if (this.defaultErrFilter) {
+        // match with prototype
+        if (!matched && this.protoMatchList.length) {
+            let protoException;
+            for (const matchPattern of this.protoMatchList) {
+                protoException = matchPattern(err);
+                if (protoException) {
+                    break;
+                }
+            }
+            if (protoException) {
+                matched = true;
+                const filterData = this.exceptionMap.get(protoException);
+                result = await filterData.filter.catch(err, ctx, res, next);
+            }
+        }
+        if (!matched && this.defaultErrFilter) {
+            matched = true;
             result = await this.defaultErrFilter.catch(err, ctx, res, next);
         }
-        else {
+        if (!matched) {
             error = err;
         }
         return {

package/dist/common/serviceFactory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceFactory = void 0;
 const assert = require("assert");
+const extend_1 = require("../util/extend");
 /**
  * 多客户端工厂实现
  */
@@ -33,7 +34,7 @@ class ServiceFactory {
     }
     async createInstance(config, clientName) {
         // options.default will be merge in to options.clients[id]
-        config = Object.assign({}, this.options['default'], config);
+        config = (0, extend_1.extend)(true, {}, this.options['default'], config);
         const client = await this.createClient(config, clientName);
         if (client) {
             if (clientName) {

package/dist/common/webGenerator.d.ts

@@ -1,15 +1,16 @@
-import { RouterInfo, IMidwayApplication } from '../index';
+import { MidwayWebRouterService, RouterInfo, IMidwayApplication } from '../index';
 export declare abstract class WebControllerGenerator<Router extends {
     use: (...args: any[]) => void;
 }> {
     readonly app: IMidwayApplication;
-    protected constructor(app: IMidwayApplication);
+    readonly midwayWebRouterService: MidwayWebRouterService;
+    protected constructor(app: IMidwayApplication, midwayWebRouterService: MidwayWebRouterService);
     /**
      * wrap controller string to middleware function
      * @param routeInfo
      */
     generateKoaController(routeInfo: RouterInfo): (ctx: any, next: any) => Promise<void>;
-    loadMidwayController(globalPrefix: string, routerHandler?: (newRouter: Router) => void): Promise<void>;
+    loadMidwayController(routerHandler?: (newRouter: Router) => void): Promise<void>;
     abstract createRouter(routerOptions: any): Router;
     abstract generateController(routeInfo: RouterInfo): any;
 }

package/dist/common/webGenerator.js

@@ -12,8 +12,9 @@ const index_1 = require("../index");
 const util = require("util");
 const debug = util.debuglog('midway:debug');
 class WebControllerGenerator {
-    constructor(app) {
+    constructor(app, midwayWebRouterService) {
         this.app = app;
+        this.midwayWebRouterService = midwayWebRouterService;
     }
     /**
      * wrap controller string to middleware function
@@ -22,14 +23,24 @@ class WebControllerGenerator {
     generateKoaController(routeInfo) {
         return async (ctx, next) => {
             const args = [ctx, next];
-            const controller = await ctx.requestContext.getAsync(routeInfo.id);
-            // eslint-disable-next-line prefer-spread
-            const result = await controller[routeInfo.method].apply(controller, args);
-            if (result !== undefined) {
-                ctx.body = result;
+            let result;
+            if (typeof routeInfo.method !== 'string') {
+                result = await routeInfo.method(ctx, next);
+            }
+            else {
+                const controller = await ctx.requestContext.getAsync(routeInfo.id);
+                // eslint-disable-next-line prefer-spread
+                result = await controller[routeInfo.method].apply(controller, args);
             }
-            if (ctx.body === undefined && !ctx.response._explicitStatus) {
-                ctx.body = undefined;
+            if (result !== undefined) {
+                if (result === null) {
+                    // 这样设置可以绕过 koa 的 _explicitStatus 赋值机制
+                    ctx.response._body = null;
+                    ctx.response._midwayControllerNullBody = true;
+                }
+                else {
+                    ctx.body = result;
+                }
             }
             // implement response decorator
             if (Array.isArray(routeInfo.responseMetadata) &&
@@ -56,13 +67,10 @@ class WebControllerGenerator {
             }
         };
     }
-    async loadMidwayController(globalPrefix, routerHandler) {
+    async loadMidwayController(routerHandler) {
         var _a, _b;
-        const collector = new index_1.WebRouterCollector('', {
-            globalPrefix,
-        });
-        const routerTable = await collector.getRouterTable();
-        const routerList = await collector.getRoutePriorityList();
+        const routerTable = await this.midwayWebRouterService.getRouterTable();
+        const routerList = await this.midwayWebRouterService.getRoutePriorityList();
         const applicationContext = this.app.getApplicationContext();
         const logger = this.app.getCoreLogger();
         const middlewareService = applicationContext.get(index_1.MidwayMiddlewareService);
@@ -93,6 +101,7 @@ class WebControllerGenerator {
                     methodMiddlewares.push(routeMiddlewareFn);
                 }
                 if (this.app.getFrameworkType() === decorator_1.MidwayFrameworkType.WEB_KOA) {
+                    // egg use path-to-regexp v1 but koa use v6
                     if (typeof routeInfo.url === 'string' && /\*$/.test(routeInfo.url)) {
                         routeInfo.url = routeInfo.url.replace('*', '(.*)');
                     }
@@ -107,7 +116,7 @@ class WebControllerGenerator {
                 debug(`[core]: Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
                 // apply controller from request context
                 // eslint-disable-next-line prefer-spread
-                newRouter[routeInfo.requestMethod].apply(newRouter, routerArgs);
+                newRouter[routeInfo.requestMethod.toLowerCase()].apply(newRouter, routerArgs);
             }
             routerHandler && routerHandler(newRouter);
         }

package/dist/config/config.default.d.ts

@@ -5,6 +5,9 @@ declare const _default: (appInfo: MidwayAppInfo) => {
     debug?: {
         recordConfigMergeOrder?: boolean;
     };
+    asyncContextManager: {
+        enable: boolean;
+    };
 };
 export default _default;
 //# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -8,6 +8,9 @@ exports.default = (appInfo) => {
     const isDevelopment = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
     const logRoot = (_a = process.env[interface_1.MIDWAY_LOGGER_WRITEABLE_DIR]) !== null && _a !== void 0 ? _a : appInfo.root;
     return {
+        asyncContextManager: {
+            enable: false,
+        },
         midwayLogger: {
             default: {
                 dir: (0, path_1.join)(logRoot, 'logs', appInfo.name),

package/dist/context/container.js

@@ -274,6 +274,9 @@ class MidwayContainer {
             // 如果 definition 存在就不再重复 bind
             return;
         }
+        if (options === null || options === void 0 ? void 0 : options.bindHook) {
+            options.bindHook(target, options);
+        }
         let definition;
         if (decorator_1.Types.isClass(target)) {
             definition = new objectDefinition_1.ObjectDefinition();

package/dist/error/base.d.ts

@@ -22,7 +22,7 @@ export declare class MidwayError extends Error {
 }
 export declare type ResOrMessage = string | {
     message: string;
-};
+} | undefined;
 export declare class MidwayHttpError extends MidwayError {
     status: number;
     constructor(resOrMessage: ResOrMessage, status: number);