@midwayjs/core 3.0.0-beta.7 → 3.0.1

package/README.md

@@ -5,7 +5,7 @@
 
 this is a sub package for midway.
 
-Document: [https://midwayjs.org/midway](https://midwayjs.org/midway)
+Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 

package/dist/baseFramework.d.ts

@@ -72,7 +72,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
      * @deprecated
      */
     protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    getMiddleware<R, N>(lastMiddleware?: CommonMiddleware<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
+    applyMiddleware<R, N>(lastMiddleware?: CommonMiddleware<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): ILogger;
     getCoreLogger(): ILogger;
     createLogger(name: string, option?: LoggerOptions): ILogger;
@@ -80,6 +80,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     getFrameworkName(): string;
     getDefaultContextLoggerClass(): any;
     useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
+    getMiddleware(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
     useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>): void;
     protected createMiddlewareManager(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected createFilterManager(): FilterManager<CTX, ResOrNext, Next>;

package/dist/baseFramework.js

@@ -21,6 +21,8 @@ const loggerService_1 = require("./service/loggerService");
 const middlewareManager_1 = require("./common/middlewareManager");
 const middlewareService_1 = require("./service/middlewareService");
 const filterManager_1 = require("./common/filterManager");
+const util = require("util");
+const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
@@ -173,13 +175,13 @@ class BaseFramework {
                 return this.getApplicationContext().getAttr(key);
             },
             useMiddleware: (middleware) => {
-                this.middlewareManager.insertLast(middleware);
+                return this.useMiddleware(middleware);
             },
             getMiddleware: () => {
-                return this.middlewareManager;
+                return this.getMiddleware();
             },
             useFilter: (Filter) => {
-                this.filterManager.useFilter(Filter);
+                return this.useFilter(Filter);
             },
         };
         for (const method of whiteList) {
@@ -204,7 +206,7 @@ class BaseFramework {
      * @deprecated
      */
     async afterContainerReady(options) { }
-    async getMiddleware(lastMiddleware) {
+    async applyMiddleware(lastMiddleware) {
         if (!this.composeMiddleware) {
             this.middlewareManager.insertFirst((async (ctx, next) => {
                 let returnResult = undefined;
@@ -220,14 +222,12 @@ class BaseFramework {
                 }
                 return returnResult.result;
             }));
-            this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager);
+            debug(`[core]: Compose middleware = [${this.middlewareManager.getNames()}]`);
+            this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager, this.app);
             await this.filterManager.init(this.applicationContext);
         }
         if (lastMiddleware) {
-            return await this.middlewareService.compose([
-                this.composeMiddleware,
-                lastMiddleware,
-            ]);
+            return await this.middlewareService.compose([this.composeMiddleware, lastMiddleware], this.app);
         }
         else {
             return this.composeMiddleware;
@@ -255,8 +255,11 @@ class BaseFramework {
     useMiddleware(Middleware) {
         this.middlewareManager.insertLast(Middleware);
     }
+    getMiddleware() {
+        return this.middlewareManager;
+    }
     useFilter(Filter) {
-        this.filterManager.useFilter(Filter);
+        return this.filterManager.useFilter(Filter);
     }
     createMiddlewareManager() {
         return new middlewareManager_1.ContextMiddlewareManager();

package/dist/common/applicationManager.d.ts

@@ -0,0 +1,11 @@
+import { IMidwayApplication, IMidwayFramework } from '../interface';
+import { FrameworkType } from '@midwayjs/decorator';
+export declare class MidwayApplicationManager {
+    private globalFrameworkMap;
+    private globalFrameworkTypeMap;
+    addFramework(namespace: any, framework: IMidwayFramework<any, any, any>): void;
+    getFramework(namespaceOrFrameworkType: string | FrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
+    getApplication(namespaceOrFrameworkType: string | FrameworkType): IMidwayApplication;
+    getApplications(namespaces?: Array<string | FrameworkType>): IMidwayApplication[];
+}
+//# sourceMappingURL=applicationManager.d.ts.map

package/dist/common/applicationManager.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidwayApplicationManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayApplicationManager = class MidwayApplicationManager {
+    constructor() {
+        this.globalFrameworkMap = new Map();
+        this.globalFrameworkTypeMap = new WeakMap();
+    }
+    addFramework(namespace, framework) {
+        this.globalFrameworkMap.set(namespace, framework);
+        this.globalFrameworkTypeMap.set(framework.getFrameworkType(), framework);
+    }
+    getFramework(namespaceOrFrameworkType) {
+        if (typeof namespaceOrFrameworkType === 'string') {
+            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkMap.get(namespaceOrFrameworkType);
+            }
+        }
+        else {
+            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkTypeMap.get(namespaceOrFrameworkType);
+            }
+        }
+    }
+    getApplication(namespaceOrFrameworkType) {
+        if (typeof namespaceOrFrameworkType === 'string') {
+            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkMap
+                    .get(namespaceOrFrameworkType)
+                    .getApplication();
+            }
+        }
+        else {
+            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkTypeMap
+                    .get(namespaceOrFrameworkType)
+                    .getApplication();
+            }
+        }
+    }
+    getApplications(namespaces) {
+        if (!namespaces) {
+            return Array.from(this.globalFrameworkMap.values()).map(framework => {
+                return framework.getApplication();
+            });
+        }
+        else {
+            return namespaces
+                .map(namespace => {
+                return this.getApplication(namespace);
+            })
+                .filter(app => {
+                return !!app;
+            });
+        }
+    }
+};
+MidwayApplicationManager = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayApplicationManager);
+exports.MidwayApplicationManager = MidwayApplicationManager;
+//# sourceMappingURL=applicationManager.js.map

package/dist/common/dataListener.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class DataListener<T> {
+    private innerData;
+    protected init(): Promise<void>;
+    abstract initData(): T;
+    abstract onData(callback: (data: T) => void): any;
+    protected setData(data: T): void;
+    getData(): T;
+    stop(): Promise<void>;
+    protected destroyListener(): Promise<void>;
+}
+//# sourceMappingURL=dataListener.d.ts.map

package/dist/common/dataListener.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataListener = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+class DataListener {
+    async init() {
+        this.innerData = await this.initData();
+        await this.onData(this.setData.bind(this));
+    }
+    setData(data) {
+        this.innerData = data;
+    }
+    getData() {
+        return this.innerData;
+    }
+    async stop() {
+        await this.destroyListener();
+    }
+    async destroyListener() { }
+}
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DataListener.prototype, "init", null);
+__decorate([
+    (0, decorator_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DataListener.prototype, "stop", null);
+exports.DataListener = DataListener;
+//# sourceMappingURL=dataListener.js.map

package/dist/common/fileDetector.js

@@ -47,7 +47,7 @@ class DirectoryFileDetector extends AbstractFileDetector {
                                 continue;
                             }
                         }
-                        else if ((0, decorator_1.isRegExp)(resolveFilter.pattern)) {
+                        else if (decorator_1.Types.isRegExp(resolveFilter.pattern)) {
                             if (resolveFilter.pattern.test(file)) {
                                 const exports = resolveFilter.ignoreRequire
                                     ? undefined

package/dist/common/middlewareManager.d.ts

@@ -1,11 +1,68 @@
 import { CommonMiddleware, CommonMiddlewareUnion, IMidwayContext } from '../interface';
 export declare class ContextMiddlewareManager<CTX extends IMidwayContext, R, N> extends Array<CommonMiddleware<CTX, R, N>> {
+    /**
+     * insert a middleware or middleware array to first
+     * @param middleware
+     */
     insertFirst(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
-    insertBefore(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrBeforeMiddleware: number): any;
-    insertBefore(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrBeforeMiddleware: CommonMiddlewareUnion<CTX, R, N>): any;
-    insertAfter(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrAfterMiddleware: number): any;
-    insertAfter(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrAfterMiddleware: CommonMiddlewareUnion<CTX, R, N>): any;
+    /**
+     * insert a middleware or middleware array to last
+     * @param middleware
+     */
     insertLast(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
-    private findItemIndex;
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrBeforeMiddleware
+     */
+    insertBefore(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrBeforeMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrAfterMiddleware
+     */
+    insertAfter(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrAfterMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * move a middleware after another middleware
+     * @param middlewareOrName
+     * @param afterMiddleware
+     */
+    findAndInsertAfter(middlewareOrName: CommonMiddleware<CTX, R, N> | string, afterMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * move a middleware before another middleware
+     * @param middlewareOrName
+     * @param beforeMiddleware
+     */
+    findAndInsertBefore(middlewareOrName: CommonMiddleware<CTX, R, N> | string, beforeMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * find middleware and move to first
+     * @param middlewareOrName
+     */
+    findAndInsertFirst(middlewareOrName: CommonMiddleware<CTX, R, N> | string): void;
+    /**
+     * find middleware and move to last
+     * @param middlewareOrName
+     */
+    findAndInsertLast(middlewareOrName: CommonMiddleware<CTX, R, N> | string): void;
+    /**
+     * find a middleware and return index
+     * @param middlewareOrName
+     */
+    findItemIndex(middlewareOrName: CommonMiddleware<CTX, R, N> | string | number): number;
+    findItem(middlewareOrName: CommonMiddleware<CTX, R, N> | string | number): CommonMiddleware<CTX, R, N>;
+    /**
+     * get name from middleware
+     * @param middleware
+     */
+    getMiddlewareName(middleware: CommonMiddleware<CTX, R, N>): string;
+    /**
+     * remove a middleware
+     * @param middlewareOrNameOrIdx
+     */
+    remove(middlewareOrNameOrIdx: CommonMiddleware<CTX, R, N> | string | number): CommonMiddleware<CTX, R, N>;
+    /**
+     * get middleware name list
+     */
+    getNames(): string[];
 }
 //# sourceMappingURL=middlewareManager.d.ts.map

package/dist/common/middlewareManager.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextMiddlewareManager = void 0;
 class ContextMiddlewareManager extends Array {
+    /**
+     * insert a middleware or middleware array to first
+     * @param middleware
+     */
     insertFirst(middleware) {
         if (Array.isArray(middleware)) {
             this.unshift(...middleware);
@@ -10,6 +14,23 @@ class ContextMiddlewareManager extends Array {
             this.unshift(middleware);
         }
     }
+    /**
+     * insert a middleware or middleware array to last
+     * @param middleware
+     */
+    insertLast(middleware) {
+        if (Array.isArray(middleware)) {
+            this.push(...middleware);
+        }
+        else {
+            this.push(middleware);
+        }
+    }
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrBeforeMiddleware
+     */
     insertBefore(middleware, idxOrBeforeMiddleware) {
         if (typeof idxOrBeforeMiddleware !== 'number') {
             idxOrBeforeMiddleware = this.findItemIndex(idxOrBeforeMiddleware);
@@ -21,6 +42,11 @@ class ContextMiddlewareManager extends Array {
             this.splice(idxOrBeforeMiddleware, 0, middleware);
         }
     }
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrAfterMiddleware
+     */
     insertAfter(middleware, idxOrAfterMiddleware) {
         if (typeof idxOrAfterMiddleware !== 'number') {
             idxOrAfterMiddleware = this.findItemIndex(idxOrAfterMiddleware);
@@ -32,16 +58,125 @@ class ContextMiddlewareManager extends Array {
             this.splice(idxOrAfterMiddleware + 1, 0, middleware);
         }
     }
-    insertLast(middleware) {
-        if (Array.isArray(middleware)) {
-            this.push(...middleware);
+    /**
+     * move a middleware after another middleware
+     * @param middlewareOrName
+     * @param afterMiddleware
+     */
+    findAndInsertAfter(middlewareOrName, afterMiddleware) {
+        middlewareOrName = this.findItem(middlewareOrName);
+        afterMiddleware = this.findItem(afterMiddleware);
+        if (!middlewareOrName ||
+            !afterMiddleware ||
+            middlewareOrName === afterMiddleware) {
+            return;
+        }
+        if (afterMiddleware) {
+            const mw = this.remove(middlewareOrName);
+            if (mw) {
+                this.insertAfter(mw, afterMiddleware);
+            }
+        }
+    }
+    /**
+     * move a middleware before another middleware
+     * @param middlewareOrName
+     * @param beforeMiddleware
+     */
+    findAndInsertBefore(middlewareOrName, beforeMiddleware) {
+        middlewareOrName = this.findItem(middlewareOrName);
+        beforeMiddleware = this.findItem(beforeMiddleware);
+        if (!middlewareOrName ||
+            !beforeMiddleware ||
+            middlewareOrName === beforeMiddleware) {
+            return;
+        }
+        if (beforeMiddleware) {
+            const mw = this.remove(middlewareOrName);
+            if (mw) {
+                this.insertBefore(mw, beforeMiddleware);
+            }
+        }
+    }
+    /**
+     * find middleware and move to first
+     * @param middlewareOrName
+     */
+    findAndInsertFirst(middlewareOrName) {
+        const mw = this.remove(middlewareOrName);
+        if (mw) {
+            this.insertFirst(mw);
+        }
+    }
+    /**
+     * find middleware and move to last
+     * @param middlewareOrName
+     */
+    findAndInsertLast(middlewareOrName) {
+        const mw = this.remove(middlewareOrName);
+        if (mw) {
+            this.insertLast(mw);
+        }
+    }
+    /**
+     * find a middleware and return index
+     * @param middlewareOrName
+     */
+    findItemIndex(middlewareOrName) {
+        if (typeof middlewareOrName === 'number') {
+            return middlewareOrName;
+        }
+        else if (typeof middlewareOrName === 'string') {
+            return this.findIndex(item => this.getMiddlewareName(item) === middlewareOrName);
         }
         else {
-            this.push(middleware);
+            return this.findIndex(item => item === middlewareOrName);
+        }
+    }
+    findItem(middlewareOrName) {
+        if (typeof middlewareOrName === 'number') {
+            if (middlewareOrName >= 0 && middlewareOrName <= this.length - 1) {
+                return this[middlewareOrName];
+            }
+        }
+        else if (typeof middlewareOrName === 'string') {
+            return this.find(item => this.getMiddlewareName(item) === middlewareOrName);
+        }
+        else {
+            return middlewareOrName;
+        }
+    }
+    /**
+     * get name from middleware
+     * @param middleware
+     */
+    getMiddlewareName(middleware) {
+        var _a, _b;
+        return ((_b = (_a = (middleware.getName && middleware.getName())) !== null && _a !== void 0 ? _a : middleware._name) !== null && _b !== void 0 ? _b : middleware.name);
+    }
+    /**
+     * remove a middleware
+     * @param middlewareOrNameOrIdx
+     */
+    remove(middlewareOrNameOrIdx) {
+        if (typeof middlewareOrNameOrIdx === 'number' &&
+            middlewareOrNameOrIdx !== -1) {
+            return this.splice(middlewareOrNameOrIdx, 1)[0];
+        }
+        else {
+            const idx = this.findItemIndex(middlewareOrNameOrIdx);
+            if (idx !== -1) {
+                return this.splice(idx, 1)[0];
+            }
         }
     }
-    findItemIndex(middleware) {
-        return this.findIndex(item => item === middleware);
+    /**
+     * get middleware name list
+     */
+    getNames() {
+        return this.map(item => {
+            return this.getMiddlewareName(item);
+        });
     }
 }
 exports.ContextMiddlewareManager = ContextMiddlewareManager;

package/dist/common/webGenerator.d.ts

@@ -1,19 +1,9 @@
-/**
- * wrap controller string to middleware function
- * @param controllerMapping like FooController.index
- * @param routeArgsInfo
- * @param routerResponseData
- */
-import { MidwayFrameworkType } from '@midwayjs/decorator';
-import { IMidwayContainer, RouterInfo } from '../index';
-import { ILogger } from '@midwayjs/logger';
+import { RouterInfo, IMidwayApplication } from '../index';
 export declare abstract class WebControllerGenerator<Router extends {
     use: (...args: any[]) => void;
 }> {
-    readonly applicationContext: IMidwayContainer;
-    readonly frameworkType: MidwayFrameworkType;
-    readonly logger?: ILogger;
-    protected constructor(applicationContext: IMidwayContainer, frameworkType: MidwayFrameworkType, logger?: ILogger);
+    readonly app: IMidwayApplication;
+    protected constructor(app: IMidwayApplication);
     /**
      * wrap controller string to middleware function
      * @param routeInfo
@@ -22,6 +12,5 @@ export declare abstract class WebControllerGenerator<Router extends {
     loadMidwayController(globalPrefix: string, routerHandler?: (newRouter: Router) => void): Promise<void>;
     abstract createRouter(routerOptions: any): Router;
     abstract generateController(routeInfo: RouterInfo): any;
-    protected handlerWebMiddleware(middlewares: any[], handlerCallback: (middlewareImpl: any) => void): Promise<void>;
 }
 //# sourceMappingURL=webGenerator.d.ts.map

package/dist/common/webGenerator.js

@@ -9,11 +9,11 @@ exports.WebControllerGenerator = void 0;
  */
 const decorator_1 = require("@midwayjs/decorator");
 const index_1 = require("../index");
+const util = require("util");
+const debug = util.debuglog('midway:debug');
 class WebControllerGenerator {
-    constructor(applicationContext, frameworkType, logger) {
-        this.applicationContext = applicationContext;
-        this.frameworkType = frameworkType;
-        this.logger = logger;
+    constructor(app) {
+        this.app = app;
     }
     /**
      * wrap controller string to middleware function
@@ -63,29 +63,36 @@ class WebControllerGenerator {
         });
         const routerTable = await collector.getRouterTable();
         const routerList = await collector.getRoutePriorityList();
+        const applicationContext = this.app.getApplicationContext();
+        const logger = this.app.getCoreLogger();
+        const middlewareService = applicationContext.get(index_1.MidwayMiddlewareService);
         for (const routerInfo of routerList) {
             // bind controller first
-            this.applicationContext.bindClass(routerInfo.routerModule);
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
+            applicationContext.bindClass(routerInfo.routerModule);
+            logger.debug(`Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
+            debug(`[core]: Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
             // new router
             const newRouter = this.createRouter({
                 prefix: routerInfo.prefix,
                 ...routerInfo.routerOptions,
             });
             // add router middleware
-            await this.handlerWebMiddleware(routerInfo.middleware, middlewareImpl => {
-                newRouter.use(middlewareImpl);
-            });
+            routerInfo.middleware = (_a = routerInfo.middleware) !== null && _a !== void 0 ? _a : [];
+            if (routerInfo.middleware.length) {
+                const routerMiddlewareFn = await middlewareService.compose(routerInfo.middleware, this.app);
+                newRouter.use(routerMiddlewareFn);
+            }
             // add route
             const routes = routerTable.get(routerInfo.prefix);
             for (const routeInfo of routes) {
                 // get middleware
-                const middlewares2 = routeInfo.middleware;
                 const methodMiddlewares = [];
-                await this.handlerWebMiddleware(middlewares2, middlewareImpl => {
-                    methodMiddlewares.push(middlewareImpl);
-                });
-                if (this.frameworkType === decorator_1.MidwayFrameworkType.WEB_KOA) {
+                routeInfo.middleware = (_b = routeInfo.middleware) !== null && _b !== void 0 ? _b : [];
+                if (routeInfo.middleware.length) {
+                    const routeMiddlewareFn = await middlewareService.compose(routeInfo.middleware, this.app);
+                    methodMiddlewares.push(routeMiddlewareFn);
+                }
+                if (this.app.getFrameworkType() === decorator_1.MidwayFrameworkType.WEB_KOA) {
                     if (typeof routeInfo.url === 'string' && /\*$/.test(routeInfo.url)) {
                         routeInfo.url = routeInfo.url.replace('*', '(.*)');
                     }
@@ -96,7 +103,8 @@ class WebControllerGenerator {
                     ...methodMiddlewares,
                     this.generateController(routeInfo),
                 ];
-                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
+                logger.debug(`Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
+                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);
@@ -104,22 +112,6 @@ class WebControllerGenerator {
             routerHandler && routerHandler(newRouter);
         }
     }
-    async handlerWebMiddleware(middlewares, handlerCallback) {
-        if (middlewares && middlewares.length) {
-            for (const middleware of middlewares) {
-                if (typeof middleware === 'function') {
-                    // web function middleware
-                    handlerCallback(middleware);
-                }
-                else {
-                    const middlewareImpl = await this.applicationContext.getAsync(middleware);
-                    if (middlewareImpl && typeof middlewareImpl.resolve === 'function') {
-                        handlerCallback(middlewareImpl.resolve());
-                    }
-                }
-            }
-        }
-    }
 }
 exports.WebControllerGenerator = WebControllerGenerator;
 //# sourceMappingURL=webGenerator.js.map

package/dist/common/webRouterCollector.js

@@ -6,6 +6,7 @@ const util_1 = require("../util");
 const container_1 = require("../context/container");
 const fileDetector_1 = require("./fileDetector");
 const util = require("util");
+const error_1 = require("../error");
 const debug = util.debuglog('midway:debug');
 class WebRouterCollector {
     constructor(baseDir = '', options = {}) {
@@ -57,7 +58,7 @@ class WebRouterCollector {
     collectRoute(module, functionMeta = false) {
         var _a;
         const controllerId = (0, decorator_1.getProviderName)(module);
-        debug(`[core:webCollector]: Found Controller ${controllerId}.`);
+        debug(`[core]: Found Controller ${controllerId}.`);
         const id = (0, decorator_1.getProviderUUId)(module);
         const controllerOption = (0, decorator_1.getClassMetadata)(decorator_1.CONTROLLER_KEY, module);
         let priority;
@@ -70,6 +71,9 @@ class WebRouterCollector {
         if (controllerIgnoreGlobalPrefix) {
             prefix = ignorePrefix;
         }
+        if (/\*/.test(prefix)) {
+            throw new error_1.MidwayCommonError(`Router prefix ${prefix} can't set string with *`);
+        }
         // set prefix
         if (!this.routes.has(prefix)) {
             this.routes.set(prefix, []);
@@ -228,7 +232,7 @@ class WebRouterCollector {
         return urlMatchList
             .map(item => {
             const urlString = item.url.toString();
-            const weightArr = (0, decorator_1.isRegExp)(item.url)
+            const weightArr = decorator_1.Types.isRegExp(item.url)
                 ? urlString.split('\\/')
                 : urlString.split('/');
             let weight = 0;
@@ -315,7 +319,7 @@ class WebRouterCollector {
                 item.requestMethod === routerInfo.requestMethod);
         });
         if (matched && matched.length) {
-            throw new Error(`Duplicate router "${routerInfo.requestMethod} ${routerInfo.url}" at "${matched[0].handlerName}" and "${routerInfo.handlerName}"`);
+            throw new error_1.MidwayDuplicateRouteError(`${routerInfo.requestMethod} ${routerInfo.url}`, `${matched[0].handlerName}`, `${routerInfo.handlerName}`);
         }
         prefixList.push(routerInfo);
     }