@midwayjs/express 3.0.0-beta.7 → 3.0.1

package/README.md

@@ -1,11 +1,11 @@
-# midway-web
+# midway for express
 
-[![Package Quality](http://npm.packagequality.com/shield/midway-web.svg)](http://packagequality.com/#?package=midway-web)
+[![Package Quality](http://npm.packagequality.com/shield/@midwayjs/express.svg)](http://packagequality.com/#?package=@midwayjs/express)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/midwayjs/midway/pulls)
 
 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,6 +1,9 @@
-import { MidwayDecoratorService } from '@midwayjs/core';
+import { MidwayConfigService, MidwayDecoratorService } from '@midwayjs/core';
+import { MidwayExpressFramework } from './framework';
 export declare class ExpressConfiguration {
     decoratorService: MidwayDecoratorService;
+    expressFramework: MidwayExpressFramework;
+    configService: MidwayConfigService;
     init(): void;
     onReady(): Promise<void>;
 }

package/dist/configuration.js

@@ -12,18 +12,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressConfiguration = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 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.originParamType)(options.originArgs[0], options.originArgs[1], options.originArgs[2]);
         });
     }
-    async onReady() { }
+    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, "expressFramework", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayConfigService)
+], ExpressConfiguration.prototype, "configService", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
@@ -33,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,10 +1,10 @@
 /// <reference types="node" />
 import { BaseFramework, IMidwayBootstrapOptions, MiddlewareRespond, MidwayFrameworkType, RouterInfo } from '@midwayjs/core';
-import { IMidwayExpressApplication, IMidwayExpressConfigurationOptions, IMidwayExpressContext } from './interface';
+import { IMidwayExpressApplication, IMidwayExpressConfigurationOptions, Context } 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, Response, NextFunction> {
+export declare class MidwayExpressFramework extends BaseFramework<IMidwayExpressApplication, Context, IMidwayExpressConfigurationOptions, Response, NextFunction> {
     app: IMidwayExpressApplication;
     private server;
     private expressMiddlewareService;
@@ -16,17 +16,20 @@ export declare class MidwayExpressFramework extends BaseFramework<IMidwayExpress
      * wrap controller string to middleware function
      */
     protected generateController(routeInfo: RouterInfo): IRouterHandler<any>;
-    loadMidwayController(): Promise<void>;
+    loadMidwayController(): Promise<Array<{
+        prefix: string;
+        middleware: any;
+    }>>;
     /**
      * @param routerOptions
      */
     protected createRouter(routerOptions: {
         sensitive: any;
     }): IRouter;
-    private handlerWebMiddleware;
-    getMiddleware<Response, NextFunction>(): Promise<MiddlewareRespond<IMidwayExpressContext, Response, NextFunction>>;
+    applyMiddleware<Response, NextFunction>(): Promise<MiddlewareRespond<Context, Response, NextFunction>>;
     beforeStop(): Promise<void>;
     getServer(): Server;
+    getPort(): string;
     getFrameworkName(): string;
     getDefaultContextLoggerClass(): typeof MidwayExpressContextLogger;
 }

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");
@@ -15,12 +12,19 @@ const decorator_1 = require("@midwayjs/decorator");
 const express = require("express");
 const logger_1 = require("./logger");
 const middlewareService_1 = require("./middlewareService");
+const util_1 = require("util");
+const util_2 = require("./util");
+const debug = (0, util_1.debuglog)('midway:debug');
 let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFramework {
     configure() {
         return this.configService.getConfiguration('express');
     }
     async applicationInitialize(options) {
+        this.expressMiddlewareService = await this.applicationContext.getAsync(middlewareService_1.MidwayExpressMiddlewareService, [this.applicationContext]);
+        debug('[express]: create express app');
         this.app = express();
+        debug('[express]: use root middleware');
+        // use root middleware
         this.app.use((req, res, next) => {
             const ctx = req;
             this.app.createAnonymousContext(ctx);
@@ -29,25 +33,71 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
             ctx.requestContext.registerObject('res', res);
             next();
         });
+        this.defineApplicationProperties();
+        // hack use method
+        this.app.originUse = this.app.use;
+        this.app.use = this.app.useMiddleware;
     }
     async run() {
         var _a;
+        debug(`[express]: use middlewares = "${this.getMiddleware().getNames()}"`);
+        // restore use method
+        this.app.use = this.app.originUse;
+        debug('[express]: use user router middleware');
+        // load controller，must apply router filter here
+        const routerMiddlewares = await this.loadMidwayController();
         // use global middleware
-        const globalMiddleware = await this.getMiddleware();
+        const globalMiddleware = await this.applyMiddleware();
+        debug('[express]: use and apply all framework and global middleware');
         this.app.use(globalMiddleware);
-        // load controller
-        await this.loadMidwayController();
+        // load router after global middleware
+        for (const info of routerMiddlewares) {
+            this.app.use(info.prefix, info.middleware);
+        }
+        debug('[express]: use 404 not found middleware');
+        // eslint-disable-next-line
+        this.app.use(function notFound(req, res, next) {
+            next(new core_1.httpError.NotFoundError());
+        });
+        debug('[express]: use global error handler middleware');
         // 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);
+        this.app.use((err, req, res, next) => {
+            this.filterManager
+                .runErrorFilter(err, req, res, next)
+                .then(data => {
+                var _a, _b;
+                const { result, error } = data;
                 if (error) {
+                    const status = (_b = (_a = error.status) !== null && _a !== void 0 ? _a : res.statusCode) !== null && _b !== void 0 ? _b : 500;
+                    // 5xx
+                    if (status >= 500) {
+                        try {
+                            req.logger.error(err);
+                        }
+                        catch (ex) {
+                            this.logger.error(err);
+                            this.logger.error(ex);
+                        }
+                        return;
+                    }
+                    // 4xx
+                    try {
+                        req.logger.warn(err);
+                    }
+                    catch (ex) {
+                        this.logger.warn(err);
+                        this.logger.error(ex);
+                    }
+                    res.status(status);
                     next(error);
                 }
                 else {
-                    res.send(result);
+                    (0, util_2.sendData)(res, result);
                 }
-            }
+            })
+                .catch(err => {
+                next(err);
+            });
         });
         // https config
         if (this.configurationOptions.key && this.configurationOptions.cert) {
@@ -74,7 +124,7 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
         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];
+                const args = [customPort];
                 if (this.configurationOptions.hostname) {
                     args.push(this.configurationOptions.hostname);
                 }
@@ -93,7 +143,7 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
      * wrap controller string to middleware function
      */
     generateController(routeInfo) {
-        return async (req, res, next) => {
+        return (0, middlewareService_1.wrapAsyncHandler)(async (req, res, next) => {
             const controller = await req.requestContext.getAsync(routeInfo.id);
             const result = await controller[routeInfo.method].call(controller, req, res, next);
             if (res.headersSent) {
@@ -127,38 +177,49 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
             if (error) {
                 throw error;
             }
-            res.send(returnValue);
-        };
+            (0, util_2.sendData)(res, returnValue);
+        });
     }
     async loadMidwayController() {
+        var _a, _b;
         const collector = new core_1.WebRouterCollector('', {
             globalPrefix: this.configurationOptions.globalPrefix,
         });
         const routerTable = await collector.getRouterTable();
         const routerList = await collector.getRoutePriorityList();
+        const routerMiddlewares = [];
         for (const routerInfo of routerList) {
             // 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);
+            routerInfo.middleware = (_a = routerInfo.middleware) !== null && _a !== void 0 ? _a : [];
             // 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
+                routeInfo.middleware = (_b = routeInfo.middleware) !== null && _b !== void 0 ? _b : [];
+                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));
+                newRouter[routeInfo.requestMethod].call(newRouter, routeInfo.url, ...routeMiddlewareList, this.generateController(routeInfo));
             }
-            this.app.use(routerInfo.prefix, newRouter);
+            routerMiddlewares.push({
+                prefix: routerInfo.prefix,
+                middleware: newRouter,
+            });
         }
+        return routerMiddlewares;
     }
     /**
      * @param routerOptions
@@ -166,13 +227,9 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
     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);
+            this.composeMiddleware = await this.expressMiddlewareService.compose(this.middlewareManager, this.app);
             await this.filterManager.init(this.applicationContext);
         }
         return this.composeMiddleware;
@@ -183,6 +240,9 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
     getServer() {
         return this.server;
     }
+    getPort() {
+        return process.env.MIDWAY_HTTP_PORT;
+    }
     getFrameworkName() {
         return 'midway:express';
     }
@@ -190,10 +250,6 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
         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);

package/dist/interface.d.ts

@@ -1,20 +1,37 @@
 /// <reference types="node" />
 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> {
+import { Application as ExpressApplication, NextFunction as ExpressNextFunction, Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { Options, OptionsJson, OptionsText, OptionsUrlencoded } from 'body-parser';
+declare type Request = IMidwayContext<ExpressRequest>;
+export declare type Response = ExpressResponse;
+export declare type NextFunction = ExpressNextFunction;
+export interface Context extends Request {
+}
+/**
+ * @deprecated use Context
+ */
+export declare type IMidwayExpressRequest = Context;
+/**
+ * @deprecated use Context
+ */
+export declare type IMidwayExpressContext = Context;
+export declare type IMidwayExpressMiddleware = IMiddleware<Context, ExpressResponse, ExpressNextFunction>;
+export interface IMidwayExpressApplication extends IMidwayApplication<Context, ExpressApplication> {
     /**
      * add global middleware to app
      * @param Middleware
      */
-    useMiddleware<Response, NextFunction>(Middleware: CommonMiddlewareUnion<IMidwayExpressContext, Response, NextFunction>): void;
+    useMiddleware<Response, NextFunction>(Middleware: CommonMiddlewareUnion<Context, Response, NextFunction>): void;
     /**
      * get global middleware
      */
-    getMiddleware<Response, NextFunction>(): ContextMiddlewareManager<IMidwayExpressContext, Response, NextFunction>;
+    getMiddleware<Response, NextFunction>(): ContextMiddlewareManager<Context, Response, NextFunction>;
 }
 export interface IMidwayExpressConfigurationOptions extends IConfigurationOptions {
+    /**
+     * session or cookie secret key
+     */
+    keys?: string | string[];
     /**
      * application http port
      */
@@ -45,12 +62,25 @@ export interface IMidwayExpressConfigurationOptions extends IConfigurationOption
     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;
+            };
+        };
     }
 }
+export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/logger.d.ts

@@ -1,6 +1,6 @@
 import { MidwayContextLogger } from '@midwayjs/logger';
-import { IMidwayExpressContext } from './interface';
-export declare class MidwayExpressContextLogger extends MidwayContextLogger<IMidwayExpressContext> {
+import { Context } from './interface';
+export declare class MidwayExpressContextLogger extends MidwayContextLogger<Context> {
     formatContextLabel(): string;
 }
 //# sourceMappingURL=logger.d.ts.map

package/dist/middlewareService.d.ts

@@ -1,13 +1,14 @@
-import { IMidwayContainer, CommonMiddleware } from '@midwayjs/core';
-import { IMidwayExpressContext } from './interface';
+import { IMidwayContainer, CommonMiddleware, FunctionMiddleware } from '@midwayjs/core';
+import { Context, Application } from './interface';
 import { NextFunction, Response } from 'express';
+export declare function wrapAsyncHandler(fn: any): any;
 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;
+    compose(middleware: Array<CommonMiddleware<Context, Response, NextFunction> | string>, app: Application, name?: string): Promise<{
+        (req: Context, res: Response, nextFunction: NextFunction): any;
         _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