@midwayjs/express 3.0.0-alpha.9 → 3.0.0-beta.4

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.0.0-beta.4](https://github.com/midwayjs/midway/compare/v3.0.0-beta.3...v3.0.0-beta.4) (2021-11-24)
+
+
+### Features
+
+* add i18n ([#1375](https://github.com/midwayjs/midway/issues/1375)) ([bffefe0](https://github.com/midwayjs/midway/commit/bffefe07afe45777d49b5a76b9ab17fc2b9d9a55))
+* auto transform args to type ([#1372](https://github.com/midwayjs/midway/issues/1372)) ([bb3f7d2](https://github.com/midwayjs/midway/commit/bb3f7d2028a034e1926d9df554849332354c3762))
+* support global prefix url ([#1371](https://github.com/midwayjs/midway/issues/1371)) ([cc5fe44](https://github.com/midwayjs/midway/commit/cc5fe44e1d221590562dc71e1f33ae96093e0da7))
+
+
+
+
+
+# [3.0.0-beta.3](https://github.com/midwayjs/midway/compare/v3.0.0-beta.2...v3.0.0-beta.3) (2021-11-18)
+
+
+### Features
+
+* add component and framework config definition ([#1367](https://github.com/midwayjs/midway/issues/1367)) ([b2fe615](https://github.com/midwayjs/midway/commit/b2fe6157f99659471ff1333eca0b86bb889f61a3))
+
+
+
+
+
+# [3.0.0-beta.2](https://github.com/midwayjs/midway/compare/v3.0.0-beta.1...v3.0.0-beta.2) (2021-11-16)
+
+**Note:** Version bump only for package @midwayjs/express
+
+
+
+
+
+# [3.0.0-beta.1](https://github.com/midwayjs/midway/compare/v2.12.4...v3.0.0-beta.1) (2021-11-14)
+
+
+### Features
+
+* add http2 support ([#1242](https://github.com/midwayjs/midway/issues/1242)) ([6cda27e](https://github.com/midwayjs/midway/commit/6cda27e9e22689e46ace543326b43ae21b134911))
+
+
+
+
+
 ## [2.12.3](https://github.com/midwayjs/midway/compare/v2.12.2...v2.12.3) (2021-08-09)
 
 **Note:** Version bump only for package @midwayjs/express

package/dist/configuration.d.ts

@@ -0,0 +1,7 @@
+import { MidwayDecoratorService } from '@midwayjs/core';
+export declare class ExpressConfiguration {
+    decoratorService: MidwayDecoratorService;
+    init(): void;
+    onReady(): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,39 @@
+"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.ExpressConfiguration = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const core_1 = require("@midwayjs/core");
+let ExpressConfiguration = class ExpressConfiguration {
+    init() {
+        this.decoratorService.registerParameterHandler(decorator_1.WEB_ROUTER_PARAM_KEY, options => {
+            return (0, core_1.extractExpressLikeValue)(options.metadata.type, options.metadata.propertyData, options.originParamType)(options.originArgs[0], options.originArgs[1], options.originArgs[2]);
+        });
+    }
+    async onReady() { }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], ExpressConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ExpressConfiguration.prototype, "init", null);
+ExpressConfiguration = __decorate([
+    (0, decorator_1.Configuration)({
+        namespace: 'express',
+    })
+], ExpressConfiguration);
+exports.ExpressConfiguration = ExpressConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/framework.d.ts

@@ -1,39 +1,30 @@
 /// <reference types="node" />
-import { BaseFramework, IMidwayBootstrapOptions, MidwayFrameworkType } from '@midwayjs/core';
-import { RouterParamValue } from '@midwayjs/decorator';
+import { BaseFramework, IMidwayBootstrapOptions, MiddlewareRespond, MidwayFrameworkType, RouterInfo } from '@midwayjs/core';
 import { IMidwayExpressApplication, IMidwayExpressConfigurationOptions, IMidwayExpressContext } from './interface';
-import type { IRouter, IRouterHandler } from 'express';
+import type { IRouter, IRouterHandler, Response, NextFunction } from 'express';
 import { Server } from 'net';
 import { MidwayExpressContextLogger } from './logger';
-export declare class MidwayExpressFramework extends BaseFramework<IMidwayExpressApplication, IMidwayExpressContext, IMidwayExpressConfigurationOptions> {
+export declare class MidwayExpressFramework extends BaseFramework<IMidwayExpressApplication, IMidwayExpressContext, IMidwayExpressConfigurationOptions, Response, NextFunction> {
     app: IMidwayExpressApplication;
-    private controllerIds;
-    prioritySortRouters: Array<{
-        priority: number;
-        router: IRouter;
-        prefix: string;
-    }>;
     private server;
+    private expressMiddlewareService;
+    configure(): IMidwayExpressConfigurationOptions;
     applicationInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
     run(): Promise<void>;
     getFrameworkType(): MidwayFrameworkType;
     /**
      * wrap controller string to middleware function
-     * @param controllerMapping like FooController.index
-     * @param routeArgsInfo
-     * @param routerResponseData
      */
-    generateController(controllerMapping: string, routeArgsInfo?: RouterParamValue[], routerResponseData?: any[]): IRouterHandler<any>;
+    protected generateController(routeInfo: RouterInfo): IRouterHandler<any>;
     loadMidwayController(): Promise<void>;
-    generateMiddleware(middlewareId: string): Promise<import("./interface").Middleware>;
     /**
-     * @param controllerOption
+     * @param routerOptions
      */
     protected createRouter(routerOptions: {
         sensitive: any;
     }): IRouter;
     private handlerWebMiddleware;
+    getMiddleware<Response, NextFunction>(): Promise<MiddlewareRespond<IMidwayExpressContext, Response, NextFunction>>;
     beforeStop(): Promise<void>;
     getServer(): Server;
     getFrameworkName(): string;

package/dist/framework.js

@@ -1,51 +1,75 @@
 "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.MidwayExpressFramework = void 0;
 const core_1 = require("@midwayjs/core");
 const decorator_1 = require("@midwayjs/decorator");
 const express = require("express");
 const logger_1 = require("./logger");
-class MidwayExpressFramework extends core_1.BaseFramework {
-    constructor() {
-        super(...arguments);
-        this.controllerIds = [];
-        this.prioritySortRouters = [];
+const middlewareService_1 = require("./middlewareService");
+let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFramework {
+    configure() {
+        return this.configService.getConfiguration('express');
     }
     async applicationInitialize(options) {
         this.app = express();
-        this.defineApplicationProperties({
-            generateController: (controllerMapping) => {
-                return this.generateController(controllerMapping);
-            },
-            generateMiddleware: async (middlewareId) => {
-                return this.generateMiddleware(middlewareId);
-            },
-        });
         this.app.use((req, res, next) => {
-            const ctx = { req, res };
+            const ctx = req;
             this.app.createAnonymousContext(ctx);
             req.requestContext = ctx.requestContext;
             ctx.requestContext.registerObject('req', req);
             ctx.requestContext.registerObject('res', res);
             next();
         });
+    }
+    async run() {
+        // use global middleware
+        const globalMiddleware = await this.getMiddleware();
+        this.app.use(globalMiddleware);
+        // load controller
+        await this.loadMidwayController();
+        // use global error handler
+        this.app.use(async (err, req, res, next) => {
+            if (err) {
+                const { result, error } = await this.filterManager.runErrorFilter(err, req, res, next);
+                if (error) {
+                    next(error);
+                }
+                else {
+                    res.send(result);
+                }
+            }
+        });
         // https config
         if (this.configurationOptions.key && this.configurationOptions.cert) {
             this.configurationOptions.key = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.key);
             this.configurationOptions.cert = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.cert);
             this.configurationOptions.ca = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.ca);
-            this.server = require('https').createServer(this.configurationOptions, this.app);
+            if (this.configurationOptions.http2) {
+                this.server = require('http2').createSecureServer(this.configurationOptions, this.app);
+            }
+            else {
+                this.server = require('https').createServer(this.configurationOptions, this.app);
+            }
         }
         else {
-            this.server = require('http').createServer(this.app);
+            if (this.configurationOptions.http2) {
+                this.server = require('http2').createServer(this.app);
+            }
+            else {
+                this.server = require('http').createServer(this.app);
+            }
         }
         // register httpServer to applicationContext
         this.applicationContext.registerObject(core_1.HTTP_SERVER_KEY, this.server);
-    }
-    async afterContainerReady(options) {
-        await this.loadMidwayController();
-    }
-    async run() {
         if (this.configurationOptions.port) {
             new Promise(resolve => {
                 const args = [this.configurationOptions.port];
@@ -64,22 +88,11 @@ class MidwayExpressFramework extends core_1.BaseFramework {
     }
     /**
      * wrap controller string to middleware function
-     * @param controllerMapping like FooController.index
-     * @param routeArgsInfo
-     * @param routerResponseData
      */
-    generateController(controllerMapping, routeArgsInfo, routerResponseData) {
-        const [controllerId, methodName] = controllerMapping.split('.');
+    generateController(routeInfo) {
         return async (req, res, next) => {
-            const args = [req, res, next];
-            if (Array.isArray(routeArgsInfo)) {
-                await Promise.all(routeArgsInfo.map(async ({ index, type, propertyData }) => {
-                    args[index] = await core_1.extractExpressLikeValue(type, propertyData)(req, res, next);
-                }));
-            }
-            const controller = await req.requestContext.getAsync(controllerId);
-            // eslint-disable-next-line prefer-spread
-            const result = await controller[methodName].apply(controller, args);
+            const controller = await req.requestContext.getAsync(routeInfo.id);
+            const result = await controller[routeInfo.method].call(controller, req, res, next);
             if (res.headersSent) {
                 // return when response send
                 return;
@@ -88,8 +101,9 @@ class MidwayExpressFramework extends core_1.BaseFramework {
                 res.status(204);
             }
             // implement response decorator
-            if (Array.isArray(routerResponseData) && routerResponseData.length) {
-                for (const routerRes of routerResponseData) {
+            if (Array.isArray(routeInfo.responseMetadata) &&
+                routeInfo.responseMetadata.length) {
+                for (const routerRes of routeInfo.responseMetadata) {
                     switch (routerRes.type) {
                         case decorator_1.WEB_RESPONSE_HTTP_CODE:
                             res.status(routerRes.code);
@@ -106,66 +120,59 @@ class MidwayExpressFramework extends core_1.BaseFramework {
                     }
                 }
             }
-            res.send(result);
+            const { result: returnValue, error } = await this.filterManager.runResultFilter(result, req, res, next);
+            if (error) {
+                throw error;
+            }
+            res.send(returnValue);
         };
     }
     async loadMidwayController() {
-        const collector = new core_1.WebRouterCollector();
+        const collector = new core_1.WebRouterCollector('', {
+            globalPrefix: this.configurationOptions.globalPrefix,
+        });
         const routerTable = await collector.getRouterTable();
         const routerList = await collector.getRoutePriorityList();
         for (const routerInfo of routerList) {
-            const providerId = routerInfo.controllerId;
-            // controller id check
-            if (this.controllerIds.indexOf(providerId) > -1) {
-                throw new Error(`Controller identifier [${providerId}] already exists!`);
-            }
-            this.controllerIds.push(providerId);
-            this.logger.debug(`Load Controller "${providerId}", prefix=${routerInfo.prefix}`);
+            // bind controller first
+            this.getApplicationContext().bindClass(routerInfo.routerModule);
+            this.logger.debug(`Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
             // new router
             const newRouter = this.createRouter(routerInfo.routerOptions);
             // add router middleware
-            await this.handlerWebMiddleware(routerInfo.middleware, (middlewareImpl) => {
+            await this.handlerWebMiddleware(routerInfo.middleware, middlewareImpl => {
                 newRouter.use(middlewareImpl);
             });
             // add route
             const routes = routerTable.get(routerInfo.prefix);
             for (const routeInfo of routes) {
                 // router middleware
-                await this.handlerWebMiddleware(routeInfo.middleware, (middlewareImpl) => {
+                await this.handlerWebMiddleware(routeInfo.middleware, middlewareImpl => {
                     newRouter.use(middlewareImpl);
                 });
                 this.logger.debug(`Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
                 // apply controller from request context
-                newRouter[routeInfo.requestMethod].call(newRouter, routeInfo.url, this.generateController(routeInfo.handlerName, routeInfo.requestMetadata, routeInfo.responseMetadata));
+                newRouter[routeInfo.requestMethod].call(newRouter, routeInfo.url, this.generateController(routeInfo));
             }
             this.app.use(routerInfo.prefix, newRouter);
         }
     }
-    async generateMiddleware(middlewareId) {
-        const mwIns = await this.getApplicationContext().getAsync(middlewareId);
-        return mwIns.resolve();
-    }
     /**
-     * @param controllerOption
+     * @param routerOptions
      */
     createRouter(routerOptions) {
         return express.Router({ caseSensitive: routerOptions.sensitive });
     }
     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.getApplicationContext().getAsync(middleware);
-                    if (middlewareImpl && typeof middlewareImpl.resolve === 'function') {
-                        handlerCallback(middlewareImpl.resolve());
-                    }
-                }
-            }
+        const fn = await this.expressMiddlewareService.compose(middlewares);
+        handlerCallback(fn);
+    }
+    async getMiddleware() {
+        if (!this.composeMiddleware) {
+            this.composeMiddleware = await this.expressMiddlewareService.compose(this.middlewareManager);
+            await this.filterManager.init(this.applicationContext);
         }
+        return this.composeMiddleware;
     }
     async beforeStop() {
         this.server.close();
@@ -179,6 +186,13 @@ class MidwayExpressFramework extends core_1.BaseFramework {
     getDefaultContextLoggerClass() {
         return logger_1.MidwayExpressContextLogger;
     }
-}
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", middlewareService_1.MidwayExpressMiddlewareService)
+], MidwayExpressFramework.prototype, "expressMiddlewareService", void 0);
+MidwayExpressFramework = __decorate([
+    (0, decorator_1.Framework)()
+], MidwayExpressFramework);
 exports.MidwayExpressFramework = MidwayExpressFramework;
 //# sourceMappingURL=framework.js.map

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export * from './interface';
 export { MidwayExpressFramework as Framework } from './framework';
+export { ExpressConfiguration as Configuration } from './configuration';
+export * from './middlewareService';
+export * from './logger';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -10,8 +10,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Framework = void 0;
+exports.Configuration = exports.Framework = void 0;
 __exportStar(require("./interface"), exports);
 var framework_1 = require("./framework");
 Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return framework_1.MidwayExpressFramework; } });
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.ExpressConfiguration; } });
+__exportStar(require("./middlewareService"), exports);
+__exportStar(require("./logger"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -1,27 +1,19 @@
 /// <reference types="node" />
-import { IConfigurationOptions, IMidwayApplication, IMidwayContext } from '@midwayjs/core';
-import { Application as ExpressApplication, Request, Response, RequestHandler, NextFunction } from 'express';
-import { RouterParamValue } from "@midwayjs/decorator";
-/**
- * @deprecated use Request from express
- */
-export declare type IMidwayExpressRequest = Request;
-/**
- * @deprecated use Response from express
- */
-export declare type IMidwayExpressResponse = Response;
-/**
- * @deprecated use NextFunction from express
- */
-export declare type IMidwayExpressNext = NextFunction;
-export declare type IMidwayExpressContext = IMidwayContext<{
-    req: Request;
-    res: Response;
-}>;
-export declare type IMidwayExpressApplication = IMidwayApplication<IMidwayExpressContext, ExpressApplication & {
-    generateController(controllerMapping: string, routeArgsInfo?: RouterParamValue[], routerResponseData?: any[]): Middleware;
-    generateMiddleware(middlewareId: string): Promise<Middleware>;
-}>;
+import { CommonMiddlewareUnion, ContextMiddlewareManager, IConfigurationOptions, IMiddleware, IMidwayApplication, IMidwayContext } from '@midwayjs/core';
+import { Application as ExpressApplication, NextFunction as ExpressNextFunction, Request, Response } from 'express';
+export declare type IMidwayExpressContext = IMidwayContext<Request>;
+export declare type IMidwayExpressMiddleware = IMiddleware<IMidwayExpressContext, Response, ExpressNextFunction>;
+export interface IMidwayExpressApplication extends IMidwayApplication<IMidwayExpressContext, ExpressApplication> {
+    /**
+     * add global middleware to app
+     * @param Middleware
+     */
+    useMiddleware<Response, NextFunction>(Middleware: CommonMiddlewareUnion<IMidwayExpressContext, Response, NextFunction>): void;
+    /**
+     * get global middleware
+     */
+    getMiddleware<Response, NextFunction>(): ContextMiddlewareManager<IMidwayExpressContext, Response, NextFunction>;
+}
 export interface IMidwayExpressConfigurationOptions extends IConfigurationOptions {
     /**
      * application http port
@@ -43,13 +35,22 @@ export interface IMidwayExpressConfigurationOptions extends IConfigurationOption
      * https ca
      */
     ca?: string | Buffer | Array<string | Buffer>;
-}
-export declare type MiddlewareParamArray = RequestHandler[];
-export declare type Middleware = RequestHandler;
-export interface IWebMiddleware {
-    resolve(): Middleware;
+    /**
+     * http2 support
+     */
+    http2?: boolean;
+    /**
+     * http global prefix
+     */
+    globalPrefix?: string;
 }
 export declare type Application = IMidwayExpressApplication;
+export declare type NextFunction = ExpressNextFunction;
 export interface Context extends IMidwayExpressContext {
 }
+declare module '@midwayjs/core/dist/interface' {
+    interface MidwayConfig {
+        express?: IMidwayExpressConfigurationOptions;
+    }
+}
 //# sourceMappingURL=interface.d.ts.map

package/dist/logger.js

@@ -5,7 +5,7 @@ const logger_1 = require("@midwayjs/logger");
 class MidwayExpressContextLogger extends logger_1.MidwayContextLogger {
     formatContextLabel() {
         var _a;
-        const req = this.ctx.req;
+        const req = this.ctx;
         // format: '[$userId/$ip/$traceId/$use_ms $method $url]'
         const userId = ((_a = req === null || req === void 0 ? void 0 : req['session']) === null || _a === void 0 ? void 0 : _a['userId']) || '-';
         const traceId = '-';

package/dist/middlewareService.d.ts

@@ -0,0 +1,13 @@
+import { IMidwayContainer, CommonMiddleware } from '@midwayjs/core';
+import { IMidwayExpressContext } from './interface';
+import { NextFunction, Response } from 'express';
+export declare class MidwayExpressMiddlewareService {
+    readonly applicationContext: IMidwayContainer;
+    constructor(applicationContext: IMidwayContainer);
+    compose(middleware: Array<CommonMiddleware<IMidwayExpressContext, Response, NextFunction> | string>, name?: string): Promise<{
+        (req: IMidwayExpressContext, res: Response, next: NextFunction): void;
+        _name: string;
+    }>;
+}
+export declare function pathMatching(options: any): (ctx?: any) => any;
+//# sourceMappingURL=middlewareService.d.ts.map

package/dist/middlewareService.js

@@ -0,0 +1,119 @@
+"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.pathMatching = exports.MidwayExpressMiddlewareService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const core_1 = require("@midwayjs/core");
+let MidwayExpressMiddlewareService = class MidwayExpressMiddlewareService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+    }
+    async compose(middleware, name) {
+        if (!Array.isArray(middleware)) {
+            throw new core_1.MidwayCommonError('Middleware stack must be an array');
+        }
+        const newMiddlewareArr = [];
+        for (let fn of middleware) {
+            if ((0, decorator_1.isClass)(fn) || typeof fn === 'string') {
+                if (typeof fn === 'string' &&
+                    !this.applicationContext.hasDefinition(fn)) {
+                    throw new core_1.MidwayCommonError('Middleware definition not found in midway container');
+                }
+                const classMiddleware = await this.applicationContext.getAsync(fn);
+                if (classMiddleware) {
+                    fn = classMiddleware.resolve();
+                    if (!classMiddleware.match && !classMiddleware.ignore) {
+                        fn._name = classMiddleware.constructor.name;
+                        // just got fn
+                        newMiddlewareArr.push(fn);
+                    }
+                    else {
+                        // wrap ignore and match
+                        const mw = fn;
+                        const match = pathMatching({
+                            match: classMiddleware.match,
+                            ignore: classMiddleware.ignore,
+                        });
+                        fn = (req, res, next) => {
+                            if (!match(req))
+                                return next();
+                            return mw(req, res, next);
+                        };
+                        fn._name = classMiddleware.constructor.name;
+                        newMiddlewareArr.push(fn);
+                    }
+                }
+                else {
+                    throw new core_1.MidwayCommonError('Middleware must have resolve method!');
+                }
+            }
+            else {
+                newMiddlewareArr.push(fn);
+            }
+        }
+        const composeFn = (req, res, next) => {
+            (function iter(i, max) {
+                if (i === max) {
+                    return next();
+                }
+                newMiddlewareArr[i](req, res, iter.bind(this, i + 1, max));
+            })(0, newMiddlewareArr.length);
+        };
+        if (name) {
+            composeFn._name = name;
+        }
+        return composeFn;
+    }
+};
+MidwayExpressMiddlewareService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayExpressMiddlewareService);
+exports.MidwayExpressMiddlewareService = MidwayExpressMiddlewareService;
+function pathMatching(options) {
+    options = options || {};
+    if (options.match && options.ignore)
+        throw new core_1.MidwayCommonError('options.match and options.ignore can not both present');
+    if (!options.match && !options.ignore)
+        return () => true;
+    const matchFn = options.match
+        ? toPathMatch(options.match)
+        : toPathMatch(options.ignore);
+    return function pathMatch(ctx) {
+        const matched = matchFn(ctx);
+        return options.match ? matched : !matched;
+    };
+}
+exports.pathMatching = pathMatching;
+function toPathMatch(pattern) {
+    if (typeof pattern === 'string') {
+        const reg = (0, core_1.pathToRegexp)(pattern, [], { end: false });
+        if (reg.global)
+            reg.lastIndex = 0;
+        return ctx => reg.test(ctx.path);
+    }
+    if (pattern instanceof RegExp) {
+        return ctx => {
+            if (pattern.global)
+                pattern.lastIndex = 0;
+            return pattern.test(ctx.path);
+        };
+    }
+    if (typeof pattern === 'function')
+        return pattern;
+    if (Array.isArray(pattern)) {
+        const matchs = pattern.map(item => toPathMatch(item));
+        return ctx => matchs.some(match => match(ctx));
+    }
+    throw new core_1.MidwayCommonError('match/ignore pattern must be RegExp, Array or String, but got ' + pattern);
+}
+//# sourceMappingURL=middlewareService.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/express",
-  "version": "3.0.0-alpha.9+d5acc750",
+  "version": "3.0.0-beta.4",
   "description": "Midway Web Framework for Express",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -23,14 +23,14 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.0.0-alpha.2",
-    "@midwayjs/mock": "^3.0.0-alpha.9+d5acc750",
+    "@midwayjs/decorator": "^3.0.0-beta.4",
+    "@midwayjs/mock": "^3.0.0-beta.4",
     "@types/express": "^4.17.8",
     "fs-extra": "^8.0.1"
   },
   "dependencies": {
-    "@midwayjs/core": "^3.0.0-alpha.9+d5acc750",
-    "@midwayjs/logger": "^2.11.3",
+    "@midwayjs/core": "^3.0.0-beta.4",
+    "@midwayjs/logger": "^3.0.0-beta.4",
     "express": "^4.17.1"
   },
   "author": "Harry Chen <czy88840616@gmail.com>",
@@ -38,5 +38,8 @@
     "type": "git",
     "url": "http://github.com/midwayjs/midway.git"
   },
-  "gitHead": "d5acc7505275ea9d566edd38e5e0377141e0abc1"
+  "engines": {
+    "node": ">=12"
+  },
+  "gitHead": "02e2144e302f807770b512b0d89da3145b1cbf2e"
 }