From d4291c29319dee23d745bb7f7a37ca1e86741691 Mon Sep 17 00:00:00 2001 From: fengmk2 Date: Sun, 19 Aug 2018 23:37:16 +0800 Subject: [PATCH] fix: the req data should be consumed on error (#33) closes https://github.com/eggjs/egg/issues/2897 --- .travis.yml | 2 +- LICENSE | 2 +- appveyor.yml | 2 +- index.js | 4 + package.json | 12 +- test/accepts.test.js | 32 +- test/fixtures/bigdata.txt | 55860 ++++++++++++++++++++++++++++++++++++ test/fluid.test.js | 10 - test/form_app.js | 40 + test/html.test.js | 30 +- test/json.test.js | 74 +- test/multipart.test.js | 55 + test/redirect.test.js | 28 +- test/text.test.js | 48 +- 14 files changed, 56076 insertions(+), 123 deletions(-) create mode 100644 test/fixtures/bigdata.txt create mode 100644 test/form_app.js create mode 100644 test/multipart.test.js diff --git a/.travis.yml b/.travis.yml index 960bc57..ce21122 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,7 +2,7 @@ sudo: false language: node_js node_js: - '8' - - '9' + - '10' install: - npm i npminstall && npminstall script: diff --git a/LICENSE b/LICENSE index 73d6280..0a8a8e7 100644 --- a/LICENSE +++ b/LICENSE @@ -1,7 +1,7 @@ The MIT License (MIT) Copyright (c) 2014 node_modules. -Copyright (c) 2015 - 2016 koajs and other contributors. +Copyright (c) 2015 - present koajs and other contributors. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/appveyor.yml b/appveyor.yml index d0aa47e..981e82b 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,7 +1,7 @@ environment: matrix: - nodejs_version: '8' - - nodejs_version: '9' + - nodejs_version: '10' install: - ps: Install-Product node $env:nodejs_version diff --git a/index.js b/index.js index 47f67ec..bc23a5c 100644 --- a/index.js +++ b/index.js @@ -4,6 +4,7 @@ const http = require('http'); const path = require('path'); const fs = require('fs'); const escapeHtml = require('escape-html'); +const sendToWormhole = require('stream-wormhole'); const env = process.env.NODE_ENV || 'development'; const isDev = env === 'development'; @@ -30,6 +31,9 @@ module.exports = function onerror(app, options) { // to node-style callbacks. if (err == null) return; + // ignore all pedding request stream + if (this.req) sendToWormhole(this.req); + // wrap non-error object if (!(err instanceof Error)) { const newError = new Error('non-error thrown: ' + err); diff --git a/package.json b/package.json index ed45d1e..1666abb 100644 --- a/package.json +++ b/package.json @@ -30,22 +30,26 @@ "homepage": "https://github.com/koajs/onerror", "devDependencies": { "autod": "*", + "co-busboy": "^1.4.0", "egg-bin": "^4.3.5", "egg-ci": "1", "eslint": "4", "eslint-config-egg": "5", - "ko-sleep": "*", + "formstream": "^1.1.0", "koa": "2", + "mz-modules": "^2.1.0", "pedding": "1", - "supertest": "3" + "supertest": "3", + "urllib": "^2.29.1" }, "engines": { "node": ">= 8.0.0" }, "ci": { - "version": "8, 9" + "version": "8, 10" }, "dependencies": { - "escape-html": "^1.0.3" + "escape-html": "^1.0.3", + "stream-wormhole": "^1.1.0" } } diff --git a/test/accepts.test.js b/test/accepts.test.js index 3648070..f915bf6 100644 --- a/test/accepts.test.js +++ b/test/accepts.test.js @@ -21,18 +21,18 @@ describe('accepts.test.js', function() { app.use(commonError); request(app.callback()) - .get('/user.json') - .set('Accept', '*/*') - .expect(500) - .expect('Content-Type', 'application/json; charset=utf-8') - .expect({ error: 'foo is not defined' }, done); + .get('/user.json') + .set('Accept', '*/*') + .expect(500) + .expect('Content-Type', 'application/json; charset=utf-8') + .expect({ error: 'foo is not defined' }, done); request(app.callback()) - .get('/user') - .set('Accept', 'application/json') - .expect(500) - .expect('Content-Type', 'text/plain; charset=utf-8') - .expect('foo is not defined', done); + .get('/user') + .set('Accept', 'application/json') + .expect(500) + .expect('Content-Type', 'text/plain; charset=utf-8') + .expect('foo is not defined', done); }); it('should redrect when accepts type not json', function(done) { @@ -50,12 +50,12 @@ describe('accepts.test.js', function() { app.use(commonError); request(app.callback()) - .get('/user') - .set('Accept', '*/*') - .expect('Content-Type', 'text/html; charset=utf-8') - .expect('Location', 'http://foo.com/500.html') - .expect('Redirecting to http://foo.com/500.html.') - .expect(302, done); + .get('/user') + .set('Accept', '*/*') + .expect('Content-Type', 'text/html; charset=utf-8') + .expect('Location', 'http://foo.com/500.html') + .expect('Redirecting to http://foo.com/500.html.') + .expect(302, done); }); }); diff --git a/test/fixtures/bigdata.txt b/test/fixtures/bigdata.txt new file mode 100644 index 0000000..a1d855b --- /dev/null +++ b/test/fixtures/bigdata.txt @@ -0,0 +1,55860 @@ +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. +an error handler for koa, hack ctx.onerror. + +different with [koa-error](https://github.com/koajs/error): +- we can not just use try catch to handle all errors, steams' and events' +errors are directly handle by `ctx.onerror`, so if we want to handle all +errors in one place, the only way i can see is to hack `ctx.onerror`. +- it is more customizable. diff --git a/test/fluid.test.js b/test/fluid.test.js index afb7aec..a5fb3d1 100644 --- a/test/fluid.test.js +++ b/test/fluid.test.js @@ -1,15 +1,5 @@ -/* ! - * koa-onerror - test/text.test.js - * Copyright(c) 2014 dead_horse - * MIT Licensed - */ - 'use strict'; -/** - * Module dependencies. - */ - const koa = require('koa'); const assert = require('assert'); const onerror = require('..'); diff --git a/test/form_app.js b/test/form_app.js new file mode 100644 index 0000000..e404025 --- /dev/null +++ b/test/form_app.js @@ -0,0 +1,40 @@ +'use strict'; + +const Koa = require('koa'); +const sleep = require('mz-modules/sleep'); +const parse = require('co-busboy'); +const onerror = require('..'); + +const app = new Koa(); +app.on('error', () => {}); +onerror(app); +app.use(async ctx => { + if (ctx.path === '/') { + ctx.body = ` +

Upload File

+
+
    +
  • File Name:
    • +
    • +
    • +
+
+ `; + return; + } + await sleep(10); + if (!ctx.is('multipart')) { + ctx.throw(400, 'Content-Type must be multipart/*'); + } + const parts = parse(ctx, { autoFields: true }); + const stream = await parts(); + console.log(stream.filename, parts.field); + stream.undefiend.error(); +}); + +if (!module.parent) { + app.listen(8080); + console.log('Listen at http://127.0.0.1:8080'); +} + +module.exports = app; diff --git a/test/html.test.js b/test/html.test.js index cfa4040..e074a72 100644 --- a/test/html.test.js +++ b/test/html.test.js @@ -3,7 +3,7 @@ const fs = require('fs'); const koa = require('koa'); const request = require('supertest'); -const sleep = require('ko-sleep'); +const sleep = require('mz-modules/sleep'); const onerror = require('..'); describe('html.test.js', function() { @@ -14,9 +14,9 @@ describe('html.test.js', function() { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'text/html') - .expect(/

Looks like something broke!<\/p>/, done); + .get('/') + .set('Accept', 'text/html') + .expect(/

Looks like something broke!<\/p>/, done); }); it('should common error after sleep a little while ok', function(done) { @@ -26,9 +26,9 @@ describe('html.test.js', function() { app.use(commonSleepError); request(app.callback()) - .get('/') - .set('Accept', 'text/html') - .expect(/

Looks like something broke!<\/p>/, done); + .get('/') + .set('Accept', 'text/html') + .expect(/

Looks like something broke!<\/p>/, done); }); it('should stream error ok', function(done) { @@ -38,10 +38,10 @@ describe('html.test.js', function() { app.use(streamError); request(app.callback()) - .get('/') - .set('Accept', 'text/html') - .expect(/

Looks like something broke!<\/p>/) - .expect(/ENOENT/, done); + .get('/') + .set('Accept', 'text/html') + .expect(/

Looks like something broke!<\/p>/) + .expect(/ENOENT/, done); }); it('should unsafe error ok', function(done) { @@ -51,10 +51,10 @@ describe('html.test.js', function() { app.use(unsafeError); request(app.callback()) - .get('/') - .set('Accept', 'text/html') - .expect(/

Looks like something broke!<\/p>/) - .expect(/<anonymous>/, done); + .get('/') + .set('Accept', 'text/html') + .expect(/

Looks like something broke!<\/p>/) + .expect(/<anonymous>/, done); }); }); diff --git a/test/json.test.js b/test/json.test.js index a972878..3507378 100644 --- a/test/json.test.js +++ b/test/json.test.js @@ -15,10 +15,10 @@ describe('json.test.js', () => { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(500) - .expect({ error: 'foo is not defined' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(500) + .expect({ error: 'foo is not defined' }, done); }); it('should stream error ok', done => { @@ -28,14 +28,14 @@ describe('json.test.js', () => { app.use(streamError); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(404, (err, res) => { - assert(!err); - assert(typeof res.body.error === 'string'); - assert(res.body.error.match(/ENOENT/)); - done(); - }); + .get('/') + .set('Accept', 'application/json') + .expect(404, (err, res) => { + assert(!err); + assert(typeof res.body.error === 'string'); + assert(res.body.error.match(/ENOENT/)); + done(); + }); }); it('should custom handler', done => { @@ -52,10 +52,10 @@ describe('json.test.js', () => { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(500) - .expect({ message: 'error' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(500) + .expect({ message: 'error' }, done); }); it('should show status error when err.message not present', done => { @@ -65,10 +65,10 @@ describe('json.test.js', () => { app.use(emptyError); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(500) - .expect({ error: 'Internal Server Error' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(500) + .expect({ error: 'Internal Server Error' }, done); }); it('should wrap non-error object', done => { @@ -80,10 +80,10 @@ describe('json.test.js', () => { }); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(500) - .expect({ error: 'non-error thrown: 1' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(500) + .expect({ error: 'non-error thrown: 1' }, done); }); it('should wrap mock error obj instead of Error instance', done => { @@ -109,11 +109,11 @@ describe('json.test.js', () => { }); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(404) - .expect('foo', 'bar') - .expect({ error: 'mock error' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(404) + .expect('foo', 'bar') + .expect({ error: 'mock error' }, done); }); it('should custom handler with ctx', done => { @@ -130,10 +130,10 @@ describe('json.test.js', () => { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(500) - .expect({ message: 'error' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(500) + .expect({ message: 'error' }, done); }); it('should get headerSent in error listener', done => { @@ -157,10 +157,10 @@ describe('json.test.js', () => { }); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect(500) - .expect({ message: 'error' }, done); + .get('/') + .set('Accept', 'application/json') + .expect(500) + .expect({ message: 'error' }, done); }); }); diff --git a/test/multipart.test.js b/test/multipart.test.js new file mode 100644 index 0000000..830e73c --- /dev/null +++ b/test/multipart.test.js @@ -0,0 +1,55 @@ +'use strict'; + +const path = require('path'); +const assert = require('assert'); +const urllib = require('urllib'); +const Agent = require('http').Agent; +const formstream = require('formstream'); +const sleep = require('mz-modules/sleep'); + +describe('multipart.test.js', () => { + let app; + let host; + before(done => { + app = require('./form_app'); + const server = app.listen(0, err => { + host = `http://127.0.0.1:${server.address().port}`; + done(err); + }); + }); + + it('should consume all request data after error throw', async () => { + const keepAliveAgent = new Agent({ + keepAlive: true, + }); + // retry 10 times + for (let i = 0; i < 10; i++) { + const form = formstream(); + form.file('file1', path.join(__dirname, 'fixtures/bigdata.txt')); + form.field('foo', 'fengmk2') + .field('love', 'koa') + .field('index', `${i}`); + + const headers = form.headers(); + const result = await urllib.request(`${host}/upload`, { + method: 'POST', + headers, + stream: form, + timing: true, + agent: keepAliveAgent, + }); + + const data = result.data; + const response = result.res; + if (i === 0) { + assert(response.keepAliveSocket === false); + } else { + assert(response.keepAliveSocket === true); + } + assert(response.status === 500); + assert(data.toString().includes('Cannot read property 'error' of undefined')); + // wait for the request data is consumed by onerror + await sleep(200); + } + }); +}); diff --git a/test/redirect.test.js b/test/redirect.test.js index 6d1eaae..17aea6e 100644 --- a/test/redirect.test.js +++ b/test/redirect.test.js @@ -14,11 +14,11 @@ describe('redirect.test.js', function() { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'text/html') - .expect('Content-Type', 'text/html; charset=utf-8') - .expect('Redirecting to http://example/500.html.') - .expect('Location', 'http://example/500.html', done); + .get('/') + .set('Accept', 'text/html') + .expect('Content-Type', 'text/html; charset=utf-8') + .expect('Redirecting to http://example/500.html.') + .expect('Location', 'http://example/500.html', done); }); it('should got text/plain header', function(done) { @@ -30,11 +30,11 @@ describe('redirect.test.js', function() { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect('Content-Type', 'text/plain; charset=utf-8') - .expect('Redirecting to http://example/500.html.') - .expect('Location', 'http://example/500.html', done); + .get('/') + .set('Accept', 'text/plain') + .expect('Content-Type', 'text/plain; charset=utf-8') + .expect('Redirecting to http://example/500.html.') + .expect('Location', 'http://example/500.html', done); }); it('should show json when accept is json', function(done) { @@ -46,10 +46,10 @@ describe('redirect.test.js', function() { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'application/json') - .expect('Content-Type', 'application/json; charset=utf-8') - .expect({ error: 'foo is not defined' }, done); + .get('/') + .set('Accept', 'application/json') + .expect('Content-Type', 'application/json; charset=utf-8') + .expect({ error: 'foo is not defined' }, done); }); }); diff --git a/test/text.test.js b/test/text.test.js index e24cccc..b0f2a1e 100644 --- a/test/text.test.js +++ b/test/text.test.js @@ -13,10 +13,10 @@ describe('text.test.js', function() { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect(500) - .expect('foo is not defined', done); + .get('/') + .set('Accept', 'text/plain') + .expect(500) + .expect('foo is not defined', done); }); it('should show error message ok', function(done) { @@ -26,10 +26,10 @@ describe('text.test.js', function() { app.use(exposeError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect(500) - .expect('this message will be expose', done); + .get('/') + .set('Accept', 'text/plain') + .expect(500) + .expect('this message will be expose', done); }); it('should show status error when err.message not present', function(done) { @@ -39,10 +39,10 @@ describe('text.test.js', function() { app.use(emptyError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect(500) - .expect('Internal Server Error', done); + .get('/') + .set('Accept', 'text/plain') + .expect(500) + .expect('Internal Server Error', done); }); it('should set headers from error.headers ok', function(done) { @@ -52,10 +52,10 @@ describe('text.test.js', function() { app.use(headerError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect(500) - .expect('foo', 'bar', done); + .get('/') + .set('Accept', 'text/plain') + .expect(500) + .expect('foo', 'bar', done); }); it('should stream error ok', function(done) { @@ -65,10 +65,10 @@ describe('text.test.js', function() { app.use(streamError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect(404) - .expect(/ENOENT/, done); + .get('/') + .set('Accept', 'text/plain') + .expect(404) + .expect(/ENOENT/, done); }); it('should custom handler', function(done) { @@ -83,10 +83,10 @@ describe('text.test.js', function() { app.use(commonError); request(app.callback()) - .get('/') - .set('Accept', 'text/plain') - .expect(500) - .expect('error', done); + .get('/') + .set('Accept', 'text/plain') + .expect(500) + .expect('error', done); }); });