feat: add biz handler

app.js

@@ -12,6 +12,8 @@ const {
 } = require('./lib/utils');
 
 module.exports = app => {
+  app.config.coreMiddleware.push('eggOnerrorHandler');
+
   // logging error
   const config = app.config.onerror;
   const viewTemplate = fs.readFileSync(config.templatePath, 'utf8');
@@ -43,9 +45,9 @@ module.exports = app => {
 
   const errorOptions = {
     // support customize accepts function
-    accepts() {
+    accepts(...args) {
       const fn = config.accepts || accepts;
-      return fn(this);
+      return fn(this, ...args);
     },
 
     html(err) {

app/middleware/egg_onerror_handler.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const { EggError, ErrorType, InternalServerErrorError } = require('egg-errors');
+const accepts = require('accepts');
+
+class UnknownError extends InternalServerErrorError {
+  constructor(message) {
+    super(message);
+    this.message = message;
+    this.code = 'UNKNOWN_ERROR';
+  }
+}
+
+module.exports = (_, app) => {
+  const errorHandler = app.config.onerror.errorHandler;
+  const acceptFn = app.config.onerror.accepts ||
+    ((ctx, ...args) => accepts(ctx.req).type(args));
+
+  return async function onerrorBizHandler(ctx, next) {
+    try {
+      await next();
+    } catch (e) {
+      let err = e;
+      const errorType = EggError.getType(err);
+      switch (errorType) {
+        case ErrorType.ERROR: break;
+        // if error is an EggError Exception, it will pring error log
+        case ErrorType.EXCEPTION: {
+          ctx.logger.error(err);
+          // force set error status
+          err.status = 500;
+          break;
+        }
+        // if error is not recognized by EggError,
+        // it will be converted to UnknownError
+        case ErrorType.BUILTIN: {
+          err = UnknownError.from(err);
+          ctx.logger.error(err);
+          break;
+        }
+        // getType not work
+        default:
+          throw err;
+      }
+
+      // handle the error
+      const contentType = acceptFn(ctx, 'html', 'text', 'json');
+
+      if (contentType === 'json' && errorHandler.json) {
+        await errorHandler.json(ctx, err);
+      } else if (contentType === 'text' && errorHandler.text) {
+        await errorHandler.text(ctx, err);
+      } else if (contentType === 'html' && errorHandler.html) {
+        await errorHandler.html(ctx, err);
+      } else if (errorHandler.any) {
+        await errorHandler.any(ctx, err);
+      }
+    }
+  };
+};

config/config.default.js

@@ -11,4 +11,24 @@ exports.onerror = {
   appErrorFilter: null,
   // default template path
   templatePath: path.join(__dirname, '../lib/onerror_page.mustache'),
+  // handler your error response
+  errorHandler: {
+    enable: false,
+    json: (ctx, err) => {
+      ctx.status = err.status || 500;
+      ctx.body = {
+        code: err.code,
+        message: err.message,
+      };
+    },
+    text: (ctx, err) => {
+      ctx.status = err.status || 500;
+      ctx.body = err.message;
+    },
+    html: (ctx, err) => {
+      ctx.status = err.status || 500;
+      ctx.body = `<h2>${err.code}</h2>\n<div>${err.message}</div>`;
+    },
+    any: null,
+  },
 };

package.json

@@ -25,6 +25,7 @@
   ],
   "dependencies": {
     "cookie": "^0.3.1",
+    "egg-errors": "^1.0.1",
     "koa-onerror": "^4.0.0",
     "mustache": "^2.3.0",
     "stack-trace": "^0.0.10"

test/error_handler.test.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const fs = require('fs');
+const pedding = require('pedding');
+const mm = require('egg-mock');
+const rimraf = require('rimraf');
+const path = require('path');
+const assert = require('assert');
+
+describe.only('test/error_handler.test.js', () => {
+  describe.only('default error handler', () => {
+    let app;
+    before(() => {
+      app = mm.app({
+        baseDir: 'default-error-handler',
+      });
+      return app.ready();
+    });
+    after(() => app.close());
+
+    describe('error', () => {
+      it('should handler error when accept json', async () => {
+        await app.httpRequest()
+          .get('/error')
+          .set('Accept', 'application/json')
+          .expect({
+            code: 'UNKNOWN_ERROR',
+            message: 'error',
+          })
+          .expect(500);
+      });
+
+      it('should handler error when accept text', async () => {
+        await app.httpRequest()
+          .get('/error')
+          .set('Accept', 'text/plain')
+          .expect('error')
+          .expect(500);
+      });
+
+      it('should handler error when accept html', async () => {
+        await app.httpRequest()
+          .get('/error')
+          .set('Accept', 'text/html')
+          .expect('error')
+          .expect(500);
+      });
+    });
+
+    describe('egg error', () => {
+      it('should handler egg error when accept json', async () => {
+        await app.httpRequest()
+          .get('/egg-error')
+          .set('Accept', 'application/json')
+          .expect({
+            code: 'CUSTOM_ERROR',
+            message: 'egg error',
+          })
+          .expect(422);
+      });
+
+      it('should handler egg error when accept text', async () => {
+        await app.httpRequest()
+          .get('/egg-error')
+          .set('Accept', 'text/plain')
+          .expect('egg error')
+          .expect(422);
+      });
+
+      it('should handler egg error when accept html', async () => {
+        await app.httpRequest()
+          .get('/egg-error')
+          .set('Accept', 'text/html')
+          .expect('<h2>CUSTOM_ERROR</h2>\n<div>egg error</div>')
+          .expect(422);
+      });
+    });
+
+    describe('egg exception', () => {
+      it('should handler egg exception when accept json', async () => {
+        await app.httpRequest()
+          .get('/egg-exception')
+          .set('Accept', 'application/json')
+          .expect({
+            code: 'CUSTOM_EXCEPTION',
+            message: 'egg exception',
+          })
+          .expect(500);
+      });
+
+      it('should handler egg exception when accept text', async () => {
+        await app.httpRequest()
+          .get('/egg-exception')
+          .set('Accept', 'text/plain')
+          .expect('egg exception')
+          .expect(500);
+      });
+
+      it('should handler egg exception when accept html', async () => {
+        await app.httpRequest()
+          .get('/egg-exception')
+          .set('Accept', 'text/html')
+          .expect('<h2>CUSTOM_EXCEPTION</h2>\n<div>egg exception</div>')
+          .expect(500);
+      });
+    });
+
+  });
+
+  describe('default error handler', () => {
+    let app;
+    before(() => {
+      app = mm.app({
+        baseDir: 'custom-error-handler',
+      });
+      return app.ready();
+    });
+    after(() => app.close());
+
+    it('should format error', async () => {
+      await app.httpRequest()
+        .get('/error')
+        .set('Accept', 'application/json')
+        .expect({
+
+        })
+        .expect(200);
+    });
+  });
+});

test/fixtures/default-error-handler/app/router.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { EggError, EggException } = require('egg-errors');
+
+class CustomError extends EggError {
+  constructor(message) {
+    super(message);
+    this.code = 'CUSTOM_ERROR';
+    this.status = 422;
+  }
+}
+
+class CustomException extends EggException {
+  constructor(message) {
+    super(message);
+    this.code = 'CUSTOM_EXCEPTION';
+    this.status = 422;
+  }
+}
+
+module.exports = app => {
+  app.get('/error', async () => {
+    throw new Error('error');
+  });
+
+  app.get('/egg-error', async () => {
+    throw new CustomError('egg error');
+  });
+
+  app.get('/egg-exception', async () => {
+    throw new CustomException('egg exception');
+  });
+};

test/fixtures/default-error-handler/config/config.default.js

@@ -0,0 +1,9 @@
+'use strict';
+
+exports.onerror = {
+  errorHandler: {
+    enable: true,
+  },
+};
+
+exports.keys = 'foo,bar';

test/fixtures/default-error-handler/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "egg-onerror"
+}

test/fixtures/onerror-biz/app/controller/home.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { Controller } = require('egg');
+const { EggError, EggException } = require('egg-errors');
+
+
+class HomeController extends Controller {
+  async throwError() {
+    throw new Error('error');
+  }
+
+  async throwEggError() {
+    throw new EggError('egg error');
+  }
+
+  async throwEggException() {
+    throw new EggException('egg exception');
+  }
+
+}
+
+module.exports = HomeController;

test/fixtures/onerror-biz/app/router.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = app => {
+  app.get('/error', app.controller.home.throwError);
+  app.get('/eggerror', app.controller.home.throwEggError);
+  app.post('/eggexception', app.controller.home.throwEggException);
+};

test/fixtures/onerror-biz/config/config.default.js

@@ -0,0 +1,37 @@
+'use strict';
+
+exports.logger = {
+  level: 'NONE',
+  consoleLevel: 'NONE',
+};
+
+exports.keys = 'foo,bar';
+
+exports.security = {
+  csrf: false,
+};
+
+exports.onerror = {
+  accepts(ctx, ...args) {
+    console.log(ctx.type, ctx.headers);
+    const a = ctx.accepts(...args);
+    console.log(a, ...args);
+    return a;
+  },
+  application: {
+    formatJSON(err) {
+      return {
+        message: err.message,
+        code: err.code,
+        status: err.status,
+        data: err.data,
+      };
+    },
+    formatText(err) {
+      return err.message;
+    },
+    formatHtml(err) {
+      return '<h2>' + err.message + '</h2>';
+    },
+  },
+};

test/fixtures/onerror-biz/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "onerror"
+}

test/onerror.test.js

@@ -473,4 +473,5 @@ describe('test/onerror.test.js', () => {
     });
 
   });
+
 });