@midwayjs/express 3.0.0-beta.1 → 3.0.0-beta.10

package/CHANGELOG.md

@@ -3,6 +3,97 @@
 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.10](https://github.com/midwayjs/midway/compare/v3.0.0-beta.9...v3.0.0-beta.10) (2021-12-20)
+
+
+### Features
+
+* default add session  & bodyparser support for koa/express/faas ([#1420](https://github.com/midwayjs/midway/issues/1420)) ([cdaff31](https://github.com/midwayjs/midway/commit/cdaff317c3e862a95494a167995a28280af639bf))
+* implement i18n for validate ([#1426](https://github.com/midwayjs/midway/issues/1426)) ([4c7ed2f](https://github.com/midwayjs/midway/commit/4c7ed2ff2e7ccf10f88f62abad230f92f5e76b97))
+
+
+
+
+
+# [3.0.0-beta.9](https://github.com/midwayjs/midway/compare/v3.0.0-beta.8...v3.0.0-beta.9) (2021-12-09)
+
+**Note:** Version bump only for package @midwayjs/express
+
+
+
+
+
+# [3.0.0-beta.8](https://github.com/midwayjs/midway/compare/v3.0.0-beta.7...v3.0.0-beta.8) (2021-12-08)
+
+
+### Bug Fixes
+
+* express routing middleware takes effect at the controller level ([#1364](https://github.com/midwayjs/midway/issues/1364)) ([b9272e0](https://github.com/midwayjs/midway/commit/b9272e0971003443304b0c53815be31a0061b4bd))
+* typeorm EntityView missing connectionName ([#1403](https://github.com/midwayjs/midway/issues/1403)) ([30b2b37](https://github.com/midwayjs/midway/commit/30b2b3711db485cb85d825d56aeabf53b1374cae))
+
+
+
+
+
+# [3.0.0-beta.7](https://github.com/midwayjs/midway/compare/v3.0.0-beta.6...v3.0.0-beta.7) (2021-12-03)
+
+**Note:** Version bump only for package @midwayjs/express
+
+
+
+
+
+# [3.0.0-beta.6](https://github.com/midwayjs/midway/compare/v3.0.0-beta.5...v3.0.0-beta.6) (2021-11-26)
+
+
+### Bug Fixes
+
+* class transformer method missing ([#1387](https://github.com/midwayjs/midway/issues/1387)) ([074e839](https://github.com/midwayjs/midway/commit/074e8393598dc95e2742f735df75a2191c5fe25d))
+
+
+
+
+
+# [3.0.0-beta.5](https://github.com/midwayjs/midway/compare/v3.0.0-beta.4...v3.0.0-beta.5) (2021-11-25)
+
+**Note:** Version bump only for package @midwayjs/express
+
+
+
+
+
+# [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)
 
 

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/config/config.default.d.ts

@@ -0,0 +1,22 @@
+import { Options, OptionsJson, OptionsText, OptionsUrlencoded } from 'body-parser';
+import { CookieOptions } from 'express';
+export declare const cookieParser: {
+    secret?: string | string[];
+    options?: CookieOptions;
+};
+export declare const bodyParser: {
+    enable?: boolean;
+    json?: OptionsJson & {
+        enable?: boolean;
+    };
+    raw?: Options & {
+        enable?: boolean;
+    };
+    text?: OptionsText & {
+        enable?: boolean;
+    };
+    urlencoded?: OptionsUrlencoded & {
+        enable?: boolean;
+    };
+};
+//# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyParser = exports.cookieParser = void 0;
+exports.cookieParser = {};
+exports.bodyParser = {
+    enable: true,
+    json: {
+        enable: true,
+        limit: '1mb',
+        strict: true,
+    },
+    raw: {
+        enable: false,
+        limit: '1mb',
+    },
+    text: {
+        enable: true,
+        limit: '1mb',
+    },
+    urlencoded: {
+        enable: true,
+        extended: false,
+        limit: '1mb',
+        parameterLimit: 1000,
+    },
+};
+//# sourceMappingURL=config.default.js.map

package/dist/configuration.d.ts

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

package/dist/configuration.js

@@ -11,27 +11,58 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressConfiguration = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const framework_1 = require("./framework");
 const core_1 = require("@midwayjs/core");
+const session = require("@midwayjs/express-session");
+const framework_1 = require("./framework");
+const bodyParser = require("body-parser");
+const cookieParser = require("cookie-parser");
+const DefaultConfig = require("./config/config.default");
 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.originArgs[0], options.originArgs[1], options.originArgs[2]);
+            return (0, core_1.extractExpressLikeValue)(options.metadata.type, options.metadata.propertyData, options.originParamType)(options.originArgs[0], options.originArgs[1], options.originArgs[2]);
         });
     }
-    async onReady() { }
-    async onServerReady() {
-        await this.framework.run();
+    async onReady() {
+        var _a, _b;
+        const keys = (_a = this.configService.getConfiguration('express.keys')) !== null && _a !== void 0 ? _a : this.configService.getConfiguration('keys');
+        const cookieParserConfig = this.configService.getConfiguration('cookieParser');
+        // add cookie parser middleware
+        this.expressFramework
+            .getMiddleware()
+            .insertFirst(cookieParser((_b = cookieParserConfig.secret) !== null && _b !== void 0 ? _b : keys, cookieParserConfig.options));
+        // add body parser
+        const bodyparserConfig = this.configService.getConfiguration('bodyParser');
+        if (bodyparserConfig.enable) {
+            // create application/json parser
+            if (bodyparserConfig.json.enable) {
+                this.expressFramework.useMiddleware(bodyParser.json(bodyparserConfig.json));
+            }
+            if (bodyparserConfig.raw.enable) {
+                this.expressFramework.useMiddleware(bodyParser.raw(bodyparserConfig.raw));
+            }
+            if (bodyparserConfig.text.enable) {
+                this.expressFramework.useMiddleware(bodyParser.text(bodyparserConfig.text));
+            }
+            // create application/x-www-form-urlencoded parser
+            if (bodyparserConfig.urlencoded.enable) {
+                this.expressFramework.useMiddleware(bodyParser.urlencoded(bodyparserConfig.urlencoded));
+            }
+        }
     }
 };
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], ExpressConfiguration.prototype, "decoratorService", void 0);
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", framework_1.MidwayExpressFramework)
-], ExpressConfiguration.prototype, "framework", void 0);
+], ExpressConfiguration.prototype, "expressFramework", void 0);
 __decorate([
     (0, decorator_1.Inject)(),
-    __metadata("design:type", core_1.MidwayDecoratorService)
-], ExpressConfiguration.prototype, "decoratorService", void 0);
+    __metadata("design:type", core_1.MidwayConfigService)
+], ExpressConfiguration.prototype, "configService", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
@@ -41,6 +72,12 @@ __decorate([
 ExpressConfiguration = __decorate([
     (0, decorator_1.Configuration)({
         namespace: 'express',
+        imports: [session],
+        importConfigs: [
+            {
+                default: DefaultConfig,
+            },
+        ],
     })
 ], ExpressConfiguration);
 exports.ExpressConfiguration = ExpressConfiguration;

package/dist/framework.d.ts

@@ -1,16 +1,12 @@
 /// <reference types="node" />
-import { BaseFramework, ContextMiddlewareManager, FunctionMiddleware, IMidwayBootstrapOptions, MiddlewareRespond, MidwayFrameworkType, ExceptionFilterManager } 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, 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;
     private server;
-    protected middlewareManager: ContextMiddlewareManager<IMidwayExpressContext, Response<any, Record<string, any>>, NextFunction>;
-    protected exceptionFilterManager: ExceptionFilterManager<IMidwayExpressContext, Response<any, Record<string, any>>, NextFunction>;
     private expressMiddlewareService;
     configure(): IMidwayExpressConfigurationOptions;
     applicationInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
@@ -18,27 +14,20 @@ export declare class MidwayExpressFramework extends BaseFramework<IMidwayExpress
     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>;
-    /**
-     * @deprecated
-     */
-    generateMiddleware(middlewareId: string): Promise<FunctionMiddleware<IMidwayExpressContext, Response<any, Record<string, any>>, NextFunction>>;
     /**
      * @param routerOptions
      */
     protected createRouter(routerOptions: {
         sensitive: any;
     }): IRouter;
-    private handlerWebMiddleware;
-    getMiddleware<Response, NextFunction>(): Promise<MiddlewareRespond<IMidwayExpressContext, Response, NextFunction>>;
+    applyMiddleware<Response, NextFunction>(): Promise<MiddlewareRespond<IMidwayExpressContext, Response, NextFunction>>;
     beforeStop(): Promise<void>;
     getServer(): Server;
     getFrameworkName(): string;
     getDefaultContextLoggerClass(): typeof MidwayExpressContextLogger;
+    protected sendData(res: any, data: any): void;
 }
 //# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -5,9 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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");
@@ -16,28 +13,12 @@ const express = require("express");
 const logger_1 = require("./logger");
 const middlewareService_1 = require("./middlewareService");
 let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFramework {
-    constructor() {
-        super(...arguments);
-        this.controllerIds = [];
-        this.middlewareManager = new core_1.ContextMiddlewareManager();
-        this.exceptionFilterManager = new core_1.ExceptionFilterManager();
-    }
     configure() {
         return this.configService.getConfiguration('express');
     }
     async applicationInitialize(options) {
+        this.expressMiddlewareService = await this.applicationContext.getAsync(middlewareService_1.MidwayExpressMiddlewareService, [this.applicationContext]);
         this.app = express();
-        this.defineApplicationProperties({
-            generateController: (controllerMapping) => {
-                return this.generateController(controllerMapping);
-            },
-            /**
-             * @deprecated
-             */
-            generateMiddleware: async (middlewareId) => {
-                return this.generateMiddleware(middlewareId);
-            },
-        });
         this.app.use((req, res, next) => {
             const ctx = req;
             this.app.createAnonymousContext(ctx);
@@ -46,6 +27,26 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
             ctx.requestContext.registerObject('res', res);
             next();
         });
+    }
+    async run() {
+        var _a;
+        // use global middleware
+        const globalMiddleware = await this.applyMiddleware();
+        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 {
+                    this.sendData(res, result);
+                }
+            }
+        });
         // https config
         if (this.configurationOptions.key && this.configurationOptions.cert) {
             this.configurationOptions.key = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.key);
@@ -68,26 +69,8 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
         }
         // register httpServer to applicationContext
         this.applicationContext.registerObject(core_1.HTTP_SERVER_KEY, this.server);
-    }
-    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.exceptionFilterManager.run(err, req, res, next);
-                if (error) {
-                    next(error);
-                }
-                else {
-                    res.send(result);
-                }
-            }
-        });
-        if (this.configurationOptions.port) {
+        const customPort = (_a = process.env.MIDWAY_HTTP_PORT) !== null && _a !== void 0 ? _a : this.configurationOptions.port;
+        if (customPort) {
             new Promise(resolve => {
                 const args = [this.configurationOptions.port];
                 if (this.configurationOptions.hostname) {
@@ -97,6 +80,7 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
                     resolve();
                 });
                 this.server.listen(...args);
+                process.env.MIDWAY_HTTP_PORT = String(customPort);
             });
         }
     }
@@ -105,15 +89,18 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
     }
     /**
      * 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 controller = await req.requestContext.getAsync(controllerId);
-            const result = await controller[methodName].call(controller, req, res, next);
+            const controller = await req.requestContext.getAsync(routeInfo.id);
+            let result;
+            try {
+                result = await controller[routeInfo.method].call(controller, req, res, next);
+            }
+            catch (err) {
+                next(err);
+                return;
+            }
             if (res.headersSent) {
                 // return when response send
                 return;
@@ -122,8 +109,9 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
                 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);
@@ -140,64 +128,56 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
                     }
                 }
             }
-            res.send(result);
+            const { result: returnValue, error } = await this.filterManager.runResultFilter(result, req, res, next);
+            if (error) {
+                throw error;
+            }
+            this.sendData(res, 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) {
             // bind controller first
             this.getApplicationContext().bindClass(routerInfo.routerModule);
-            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}`);
+            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) => {
-                newRouter.use(middlewareImpl);
-            });
+            if (routerInfo.middleware.length) {
+                const routerMiddlewareFn = await this.expressMiddlewareService.compose(routerInfo.middleware, this.app);
+                newRouter.use(routerMiddlewareFn);
+            }
             // add route
             const routes = routerTable.get(routerInfo.prefix);
             for (const routeInfo of routes) {
-                // router middleware
-                await this.handlerWebMiddleware(routeInfo.middleware, (middlewareImpl) => {
-                    newRouter.use(middlewareImpl);
-                });
+                const routeMiddlewareList = [];
+                // routeInfo middleware
+                if (routeInfo.middleware.length) {
+                    const routeMiddlewareFn = await this.expressMiddlewareService.compose(routeInfo.middleware, this.app);
+                    routeMiddlewareList.push(routeMiddlewareFn);
+                }
                 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, ...routeMiddlewareList, this.generateController(routeInfo));
             }
             this.app.use(routerInfo.prefix, newRouter);
         }
     }
-    /**
-     * @deprecated
-     */
-    async generateMiddleware(middlewareId) {
-        const mwIns = await this.getApplicationContext().getAsync(middlewareId);
-        return mwIns.resolve();
-    }
     /**
      * @param routerOptions
      */
     createRouter(routerOptions) {
         return express.Router({ caseSensitive: routerOptions.sensitive });
     }
-    async handlerWebMiddleware(middlewares, handlerCallback) {
-        const fn = await this.expressMiddlewareService.compose(middlewares);
-        handlerCallback(fn);
-    }
-    async getMiddleware() {
+    async applyMiddleware() {
         if (!this.composeMiddleware) {
-            this.composeMiddleware = await this.expressMiddlewareService.compose(this.middlewareManager);
-            await this.exceptionFilterManager.init(this.applicationContext);
+            this.composeMiddleware = await this.expressMiddlewareService.compose(this.middlewareManager, this.app);
+            await this.filterManager.init(this.applicationContext);
         }
         return this.composeMiddleware;
     }
@@ -213,11 +193,15 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
     getDefaultContextLoggerClass() {
         return logger_1.MidwayExpressContextLogger;
     }
+    sendData(res, data) {
+        if (typeof data === 'number') {
+            res.status(res.statusCode).send('' + data);
+        }
+        else {
+            res.status(res.statusCode).send(data);
+        }
+    }
 };
-__decorate([
-    (0, decorator_1.Inject)(),
-    __metadata("design:type", middlewareService_1.MidwayExpressMiddlewareService)
-], MidwayExpressFramework.prototype, "expressMiddlewareService", void 0);
 MidwayExpressFramework = __decorate([
     (0, decorator_1.Framework)()
 ], MidwayExpressFramework);

package/dist/interface.d.ts

@@ -1,17 +1,29 @@
 /// <reference types="node" />
-import { IConfigurationOptions, IMiddleware, IMidwayApplication, IMidwayContext } from '@midwayjs/core';
-import { Application as ExpressApplication, NextFunction, Request, Response } from 'express';
-import { RouterParamValue } from "@midwayjs/decorator";
+import { CommonMiddlewareUnion, ContextMiddlewareManager, IConfigurationOptions, IMiddleware, IMidwayApplication, IMidwayContext } from '@midwayjs/core';
+import { Application as ExpressApplication, NextFunction as ExpressNextFunction, Request, Response } from 'express';
+import { Options, OptionsJson, OptionsText, OptionsUrlencoded } from 'body-parser';
 export declare type IMidwayExpressContext = IMidwayContext<Request>;
-export declare type IMidwayExpressMiddleware = IMiddleware<IMidwayExpressContext, Response, NextFunction>;
-export declare type IMidwayExpressApplication = IMidwayApplication<IMidwayExpressContext, ExpressApplication & {
-    generateController(controllerMapping: string, routeArgsInfo?: RouterParamValue[], routerResponseData?: any[]): IMidwayExpressMiddleware;
+/**
+ * @deprecated use IMidwayExpressContext
+ */
+export declare type IMidwayExpressRequest = IMidwayExpressContext;
+export declare type IMidwayExpressMiddleware = IMiddleware<IMidwayExpressContext, Response, ExpressNextFunction>;
+export interface IMidwayExpressApplication extends IMidwayApplication<IMidwayExpressContext, ExpressApplication> {
     /**
-     * @deprecated
+     * add global middleware to app
+     * @param Middleware
      */
-    generateMiddleware(middlewareId: string): Promise<IMidwayExpressMiddleware>;
-}>;
+    useMiddleware<Response, NextFunction>(Middleware: CommonMiddlewareUnion<IMidwayExpressContext, Response, NextFunction>): void;
+    /**
+     * get global middleware
+     */
+    getMiddleware<Response, NextFunction>(): ContextMiddlewareManager<IMidwayExpressContext, Response, NextFunction>;
+}
 export interface IMidwayExpressConfigurationOptions extends IConfigurationOptions {
+    /**
+     * session or cookie secret key
+     */
+    keys?: string | string[];
     /**
      * application http port
      */
@@ -36,8 +48,33 @@ export interface IMidwayExpressConfigurationOptions extends IConfigurationOption
      * 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;
+        bodyParser?: {
+            enable?: boolean;
+            json?: OptionsJson & {
+                enable?: boolean;
+            };
+            raw?: Options & {
+                enable?: boolean;
+            };
+            text?: OptionsText & {
+                enable?: boolean;
+            };
+            urlencoded?: OptionsUrlencoded & {
+                enable?: boolean;
+            };
+        };
+    }
+}
 //# sourceMappingURL=interface.d.ts.map

package/dist/middlewareService.d.ts

@@ -1,13 +1,13 @@
-import { IMidwayContainer, CommonMiddleware } from '@midwayjs/core';
-import { IMidwayExpressContext } from './interface';
+import { IMidwayContainer, CommonMiddleware, FunctionMiddleware } from '@midwayjs/core';
+import { IMidwayExpressContext, Application } 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<{
+    compose(middleware: Array<CommonMiddleware<IMidwayExpressContext, Response, NextFunction> | string>, app: Application, name?: string): Promise<{
         (req: IMidwayExpressContext, res: Response, next: NextFunction): void;
         _name: string;
     }>;
 }
-export declare function pathMatching(options: any): (ctx?: any) => any;
+export declare function wrapMiddleware(mw: FunctionMiddleware<any, any, any>, options: any): (context: any, next: any, options?: any) => any;
 //# sourceMappingURL=middlewareService.d.ts.map

package/dist/middlewareService.js

@@ -9,14 +9,14 @@ 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;
+exports.wrapMiddleware = 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) {
+    async compose(middleware, app, name) {
         if (!Array.isArray(middleware)) {
             throw new core_1.MidwayCommonError('Middleware stack must be an array');
         }
@@ -29,7 +29,7 @@ let MidwayExpressMiddlewareService = class MidwayExpressMiddlewareService {
                 }
                 const classMiddleware = await this.applicationContext.getAsync(fn);
                 if (classMiddleware) {
-                    fn = classMiddleware.resolve();
+                    fn = classMiddleware.resolve(app);
                     if (!classMiddleware.match && !classMiddleware.ignore) {
                         fn._name = classMiddleware.constructor.name;
                         // just got fn
@@ -38,7 +38,7 @@ let MidwayExpressMiddlewareService = class MidwayExpressMiddlewareService {
                     else {
                         // wrap ignore and match
                         const mw = fn;
-                        const match = pathMatching({
+                        const match = (0, core_1.pathMatching)({
                             match: classMiddleware.match,
                             ignore: classMiddleware.ignore,
                         });
@@ -79,41 +79,21 @@ MidwayExpressMiddlewareService = __decorate([
     __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');
+function wrapMiddleware(mw, options) {
+    // support options.enable
+    if (options.enable === false)
+        return null;
+    // support options.match and options.ignore
     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;
+        return mw;
+    const match = (0, core_1.pathMatching)(options);
+    const fn = (req, res, next) => {
+        if (!match(req))
+            return next();
+        return mw(req, res, next);
     };
+    fn._name = mw._name + 'middlewareWrapper';
+    return fn;
 }
-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);
-}
+exports.wrapMiddleware = wrapMiddleware;
 //# sourceMappingURL=middlewareService.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/express",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.10",
   "description": "Midway Web Framework for Express",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -23,14 +23,18 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.0.0-beta.1",
-    "@midwayjs/mock": "^3.0.0-beta.1",
+    "@midwayjs/decorator": "^3.0.0-beta.10",
+    "@midwayjs/logger": "^3.0.0-beta.10",
+    "@midwayjs/mock": "^3.0.0-beta.10",
+    "@types/body-parser": "^1.19.2",
     "@types/express": "^4.17.8",
     "fs-extra": "^8.0.1"
   },
   "dependencies": {
-    "@midwayjs/core": "^3.0.0-beta.1",
-    "@midwayjs/logger": "^3.0.0-beta.1",
+    "@midwayjs/core": "^3.0.0-beta.10",
+    "@midwayjs/express-session": "^3.0.0-beta.10",
+    "body-parser": "^1.19.0",
+    "cookie-parser": "^1.4.6",
     "express": "^4.17.1"
   },
   "author": "Harry Chen <czy88840616@gmail.com>",
@@ -41,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "72e4d20c678e65a5440c4e9a6d3b70046daa497c"
+  "gitHead": "153870f2e2dd6b17673ec7591e49224a6bd51b36"
 }