@midwayjs/express 3.0.0-beta.11 → 3.0.0-beta.12

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 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.12](https://github.com/midwayjs/midway/compare/v3.0.0-beta.11...v3.0.0-beta.12) (2021-12-28)
+
+
+### Features
+
+* custom error code & add @Files/@Fields ([#1438](https://github.com/midwayjs/midway/issues/1438)) ([b0032af](https://github.com/midwayjs/midway/commit/b0032afd2fa9ea0416fe69f4bd0c1a58bea5314e))
+* support throw err status ([#1440](https://github.com/midwayjs/midway/issues/1440)) ([7b98110](https://github.com/midwayjs/midway/commit/7b98110d65c5287a8fcb3eb5356dea2d7a32cee9))
+
+
+
+
+
 # [3.0.0-beta.11](https://github.com/midwayjs/midway/compare/v3.0.0-beta.10...v3.0.0-beta.11) (2021-12-21)
 
 **Note:** Version bump only for package @midwayjs/express

package/dist/framework.js

@@ -12,13 +12,18 @@ 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 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);
@@ -27,25 +32,62 @@ 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;
         // use global middleware
         const globalMiddleware = await this.applyMiddleware();
+        debug('[express]: use and apply all framework and global middleware');
         this.app.use(globalMiddleware);
+        debug('[express]: use user router middleware');
         // load controller
         await this.loadMidwayController();
+        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 {
                     this.sendData(res, result);
                 }
-            }
+            })
+                .catch(err => {
+                next(err);
+            });
         });
         // https config
         if (this.configurationOptions.key && this.configurationOptions.cert) {
@@ -72,7 +114,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);
                 }
@@ -91,16 +133,9 @@ 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);
-            let result;
-            try {
-                result = await controller[routeInfo.method].call(controller, req, res, next);
-            }
-            catch (err) {
-                next(err);
-                return;
-            }
+            const result = await controller[routeInfo.method].call(controller, req, res, next);
             if (res.headersSent) {
                 // return when response send
                 return;
@@ -133,9 +168,10 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
                 throw error;
             }
             this.sendData(res, returnValue);
-        };
+        });
     }
     async loadMidwayController() {
+        var _a, _b;
         const collector = new core_1.WebRouterCollector('', {
             globalPrefix: this.configurationOptions.globalPrefix,
         });
@@ -147,6 +183,7 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
             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
             if (routerInfo.middleware.length) {
                 const routerMiddlewareFn = await this.expressMiddlewareService.compose(routerInfo.middleware, this.app);
@@ -157,6 +194,7 @@ let MidwayExpressFramework = class MidwayExpressFramework extends core_1.BaseFra
             for (const routeInfo of routes) {
                 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);

package/dist/middlewareService.d.ts

@@ -1,11 +1,12 @@
 import { IMidwayContainer, CommonMiddleware, FunctionMiddleware } from '@midwayjs/core';
 import { IMidwayExpressContext, 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>, app: Application, name?: string): Promise<{
-        (req: IMidwayExpressContext, res: Response, next: NextFunction): void;
+        (req: IMidwayExpressContext, res: Response, nextFunction: NextFunction): any;
         _name: string;
     }>;
 }

package/dist/middlewareService.js

@@ -9,9 +9,22 @@ 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.wrapMiddleware = exports.MidwayExpressMiddlewareService = void 0;
+exports.wrapMiddleware = exports.MidwayExpressMiddlewareService = exports.wrapAsyncHandler = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const core_1 = require("@midwayjs/core");
+function wrapAsyncHandler(fn) {
+    if ((0, decorator_1.isAsyncFunction)(fn)) {
+        return (req, res, next) => {
+            return fn(req, res, next).catch(err => {
+                next(err);
+            });
+        };
+    }
+    else {
+        return fn;
+    }
+}
+exports.wrapAsyncHandler = wrapAsyncHandler;
 let MidwayExpressMiddlewareService = class MidwayExpressMiddlewareService {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
@@ -30,6 +43,8 @@ let MidwayExpressMiddlewareService = class MidwayExpressMiddlewareService {
                 const classMiddleware = await this.applicationContext.getAsync(fn);
                 if (classMiddleware) {
                     fn = classMiddleware.resolve(app);
+                    // wrap async middleware
+                    fn = wrapAsyncHandler(fn);
                     if (!classMiddleware.match && !classMiddleware.ignore) {
                         fn._name = classMiddleware.constructor.name;
                         // just got fn
@@ -56,16 +71,36 @@ let MidwayExpressMiddlewareService = class MidwayExpressMiddlewareService {
                 }
             }
             else {
+                // wrap async middleware
+                fn = wrapAsyncHandler(fn);
                 newMiddlewareArr.push(fn);
             }
         }
-        const composeFn = (req, res, next) => {
-            (function iter(i, max) {
-                if (i === max) {
-                    return next();
+        const composeFn = (req, res, nextFunction) => {
+            let index = -1;
+            function dispatch(pos, err) {
+                const handler = newMiddlewareArr[pos];
+                index = pos;
+                if (err || index === newMiddlewareArr.length) {
+                    return nextFunction(err);
                 }
-                newMiddlewareArr[i](req, res, iter.bind(this, i + 1, max));
-            })(0, newMiddlewareArr.length);
+                function next(err) {
+                    if (pos < index) {
+                        throw new TypeError('`next()` called multiple times');
+                    }
+                    return dispatch(pos + 1, err);
+                }
+                try {
+                    return handler(req, res, next);
+                }
+                catch (err) {
+                    // Avoid future errors that could diverge stack execution.
+                    if (index > pos)
+                        throw err;
+                    return next(err);
+                }
+            }
+            return dispatch(0);
         };
         if (name) {
             composeFn._name = name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/express",
-  "version": "3.0.0-beta.11",
+  "version": "3.0.0-beta.12",
   "description": "Midway Web Framework for Express",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -23,16 +23,16 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.0.0-beta.11",
-    "@midwayjs/logger": "^3.0.0-beta.11",
-    "@midwayjs/mock": "^3.0.0-beta.11",
+    "@midwayjs/decorator": "^3.0.0-beta.12",
+    "@midwayjs/logger": "^3.0.0-beta.12",
+    "@midwayjs/mock": "^3.0.0-beta.12",
     "@types/body-parser": "^1.19.2",
     "@types/express": "^4.17.8",
     "fs-extra": "^8.0.1"
   },
   "dependencies": {
-    "@midwayjs/core": "^3.0.0-beta.11",
-    "@midwayjs/express-session": "^3.0.0-beta.11",
+    "@midwayjs/core": "^3.0.0-beta.12",
+    "@midwayjs/express-session": "^3.0.0-beta.12",
     "body-parser": "^1.19.0",
     "cookie-parser": "^1.4.6",
     "express": "^4.17.1"
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "a2b066fd500e815e799e7f421cd216f12e0e9f8e"
+  "gitHead": "1c46e53eb934248007eeb7fe3920f5ac24e272c6"
 }