strong-error-handler 1.0.1 → 1.2.1

package/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,36 @@
+<!--
+- Please ask questions at https://groups.google.com/forum/#!forum/loopbackjs or
+  https://gitter.im/strongloop/loopback
+
+- Immediate support is available through our subscription plans, see
+  https://strongloop.com/api-connect-faqs/
+-->
+
+### Bug or feature request
+
+<!--
+Mark your choice with an "x" (eg. [x], NOT [*]).
+-->
+
+- [ ] Bug
+- [ ] Feature request
+
+### Description of feature (or steps to reproduce if bug)
+
+
+
+### Link to sample repo to reproduce issue (if bug)
+
+
+
+### Expected result
+
+
+
+### Actual result (if bug)
+
+
+
+### Additional information (Node.js version, LoopBack version, etc)
+
+

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,24 @@
+### Description
+
+
+#### Related issues
+
+<!--
+Please use the following link syntaxes:
+
+- #49 (to reference issues in the current repository)
+- strongloop/loopback#49 (to reference issues in another repository)
+-->
+
+- None
+
+### Checklist
+
+<!--
+Please mark your choice with an "x" (i.e. [x], see
+https://github.com/blog/1375-task-lists-in-gfm-issues-pulls-comments)
+-->
+
+- [ ] New tests added or existing tests modified to cover all changes
+- [ ] Code conforms with the [style
+  guide](http://loopback.io/doc/en/contrib/style-guide.html)

package/CHANGES.md

@@ -1,3 +1,57 @@
+2017-01-30, Version 1.2.1
+=========================
+
+ * Stop adding safeFields to original options arg (Miroslav Bajtoš)
+
+
+2017-01-30, Version 1.2.0
+=========================
+
+ * Support options.safeFields (Zak Barbuto)
+
+ * Readme cleanup (#36) (Rand McKinney)
+
+ * xml support added (Ahmet Ozisik)
+
+ * Update paid support URL (Siddhi Pai)
+
+ * Downstream ignore dashboard-controller (Simon Ho)
+
+ * Update pt translation file (Candy)
+
+ * Make the examples more clear (Amir Jafarian)
+
+ * Fix readme (Amir Jafarian)
+
+
+2016-10-07, Version 1.1.1
+=========================
+
+ * Update pt translation file (Candy)
+
+ * Update translation files - round#2 (Candy)
+
+ * globalization: add translated strings (gunjpan)
+
+
+2016-09-05, Version 1.1.0
+=========================
+
+ * Fix minor Syntax error (Loay)
+
+ * Globalize strong-error-handler (David Cheung)
+
+ * Update eslint infrastructure (Loay)
+
+ * Add documentation (Loay)
+
+ * Improve grammar in readme. (Richard Pringle)
+
+ * Test with express instead of http server (David Cheung)
+
+ * HTML response for accepted headers (David Cheung)
+
+
 2016-05-26, Version 1.0.1
 =========================
 

package/README.md

@@ -1,26 +1,25 @@
 # strong-error-handler
 
-Error handler for use in development (debug) and production environments.
+This package is an error handler for use in both development (debug) and production environments.
 
- - When run in production mode, error responses are purposely undetailed
-   in order to prevent leaking sensitive information.
+In production mode, `strong-error-handler` omits details from error responses to prevent leaking sensitive information:
 
- - When in debug mode, detailed information such as stack traces
-   are returned in the HTTP responses.
+- For 5xx errors, the output contains only the status code and the status name from the HTTP specification.
+- For 4xx errors, the output contains the full error message (`error.message`) and the contents of the `details`
+  property (`error.details`) that `ValidationError` typically uses to provide machine-readable details
+  about validation problems.
 
-JSON is the only supported response format at this time.
+In debug mode, `strong-error-handler` returns full error stack traces and internal details of any error objects to the client in the HTTP responses.
 
-*There are plans to support other formats such as Text, HTML, and XML.*
-
-## Install
+## Installation
 
 ```bash
-$ npm install strong-error-handler
+$ npm install --save strong-error-handler
 ```
 
-## Usage
+## Use
 
-In an express-based application:
+In an Express-based application:
 
 ```js
 var express = require('express');
@@ -28,45 +27,177 @@ var errorHandler = require('strong-error-handler');
 
 var app = express();
 // setup your routes
-app.use(errorHandler({ /* options, see below */ }));
+// `options` are set to default values. For more info, see `options` below.
+// app.use(errorHandler({ /* options, see below */ }));
+app.use(errorHandler({
+  debug: app.get('env') === 'development',
+  log: true,
+}));
 
 app.listen(3000);
 ```
 
-In LoopBack applications, add the following entry to your
-`server/middleware.json` file.
+In LoopBack applications, add the following entry to `server/middleware.json`:
 
 ```json
 {
   "final:after": {
     "strong-error-handler": {
       "params": {
+         "debug": false,
+         "log": true
        }
     }
   }
 }
 ```
 
-## Options
+In general, `strong-error-handler` must be the last middleware function registered.
+
+The above configuration will log errors to the server console, but not return stack traces in HTTP responses.
+For details on configuration options, see below.
+
+### Response format and content type
+
+The `strong-error-handler` package supports HTML and JSON responses:
 
-#### debug
+- When the object is a standard Error object, it returns the string provided by the stack property in HTML/text
+  responses.
+- When the object is a non-Error object, it returns the result of `util.inspect` in HTML/text responses.
+- For JSON responses, the result is an object with all enumerable properties from the object in the response.
 
-`boolean`, defaults to `false`.
+The content type of the response depends on the request's `Accepts` header.
 
-When enabled, HTTP responses include all error properties, including
-sensitive data such as file paths, URLs and stack traces.
+-  For Accepts header `json` or `application/json`, the response content type is JSON.
+-  For Accepts header `html` or `text/html`, the response content type is HTML.
 
-#### log
+*There are plans to support other formats such as Text and XML.*
 
-`boolean`, defaults to `true`.
+## Options
+
+| Option | Type | Default | Description |
+| ---- | ---- | ---- | ---- |
+| debug | Boolean    | `false` | If `true`, HTTP responses include all error properties, including sensitive data such as file paths, URLs and stack traces. See [Example output](#example) below. |
+| log | Boolean | `true` |  If `true`, all errors are printed via `console.error`, including an array of fields (custom error properties) that are safe to include in response messages (both 4xx and 5xx). <br/> If `false`, sends only the error back in the response. |
+
+### Customizing log format
 
-When enabled, all errors are printed via `console.error`.
+**Express** 
 
-Customization of the log format is intentionally not allowed. If you would like
-to use a different format/logger, disable this option and add your own custom
-error-handling middleware.
+To use a different log format, add your own custom error-handling middleware then disable `errorHandler.log`. 
+For example, in an Express application:
 
 ```js
 app.use(myErrorLogger());
 app.use(errorHandler({ log: false }));
 ```
+
+In general, add `strong-error-handler` as the last middleware function, just before calling `app.listen()`.
+
+**LoopBack**
+
+For LoopBack applications, put custom error-logging middleware in a separate file; for example, `server/middleware/error-logger.js`:
+
+```
+module.exports = function(options) {
+  return function logError(err, req, res, next) {
+    console.log('unhandled error' ,err);
+    next(err);
+  };
+};
+```
+
+Then in `server/middleware.json`, specify your custom error logging function as follows:
+
+```
+{
+  // ...
+  "final:after": {
+    "./middleware/error-logger": {},
+    "strong-error-handler": {
+      "params": {
+        log: false
+      }
+    }
+}
+```
+
+The default `middleware.development.json` file explicitly enables logging in strong-error-handler params, so you will need to change that file too.
+
+## Migration from old LoopBack error handler
+
+NOTE: This is only required for applications scaffolded with old versions of the `slc loopback` tool.
+
+To migrate a LoopBack 2.x application to use `strong-error-handler`:
+
+1. In `package.json` dependencies, remove `"errorhandler": "^x.x.x”,`
+1. Install the new error handler by entering the command:
+    <pre>npm install --save strong-error-handler</pre>
+1. In `server/config.json`, remove:
+    <pre>
+    "remoting": {
+      ...
+      "errorHandler": {
+        "disableStackTrace": false
+      }</pre>
+  and replace it with:
+  <pre>
+  "remoting": {
+    ...,
+    "rest": {
+      "handleErrors": false
+    }</pre>
+1. In `server/middleware.json`, remove:
+    <pre>
+    "final:after": {
+      "loopback#errorHandler": {}
+    }</pre>
+  and replace it with:
+    <pre>
+    "final:after": {
+      "strong-error-handler": {}
+    }</pre>
+1. Delete `server/middleware.production.json`.
+1. Create `server/middleware.development.json` containing:
+  <pre>
+  "final:after": {
+    "strong-error-handler": {
+      "params": {
+        "debug": true,
+        "log": true
+      }
+    }
+  }
+</pre>
+
+For more information, see 
+[Migrating apps to LoopBack 3.0](http://loopback.io/doc/en/lb3/Migrating-to-3.0.html#update-use-of-rest-error-handler).
+
+## Example
+
+Error generated when `debug: false` :
+
+```
+{ error: { statusCode: 500, message: 'Internal Server Error' } }
+```
+
+Error generated when `debug: true` :
+
+```
+{ error:
+  { statusCode: 500,
+  name: 'Error',
+  message: 'a test error message',
+  stack: 'Error: a test error message    
+  at Context.<anonymous> (User/strong-error-handler/test/handler.test.js:220:21)    
+  at callFnAsync (User/strong-error-handler/node_modules/mocha/lib/runnable.js:349:8)    
+  at Test.Runnable.run (User/strong-error-handler/node_modules/mocha/lib/runnable.js:301:7)    
+  at Runner.runTest (User/strong-error-handler/node_modules/mocha/lib/runner.js:422:10)    
+  at User/strong-error-handler/node_modules/mocha/lib/runner.js:528:12    
+  at next (User/strong-error-handler/node_modules/mocha/lib/runner.js:342:14)    
+  at User/strong-error-handler/node_modules/mocha/lib/runner.js:352:7    
+  at next (User/strong-error-handler/node_modules/mocha/lib/runner.js:284:14)    
+  at Immediate._onImmediate (User/strong-error-handler/node_modules/mocha/lib/runner.js:320:5)    
+  at tryOnImmediate (timers.js:543:15)    
+  at processImmediate [as _immediateCallback] (timers.js:523:5)' }}
+```

package/intl/de/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Nicht verarbeitetes Array mit Fehlern für Anforderung {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Nicht verarbeiteter Fehler für Anforderung {0} {1}: {2}"
+}
+

package/intl/en/messages.json

@@ -0,0 +1,4 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Unhandled array of errors for request {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Unhandled error for request {0} {1}: {2}"
+}

package/intl/es/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Matriz de errores no gestionada para la solicitud {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Error no gestionado para la solicitud {0} {1}: {2}"
+}
+

package/intl/fr/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Tableau d'erreurs non traitées pour la demande {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Erreur non traitée pour la demande {0} {1} : {2}"
+}
+

package/intl/it/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Array di errori non gestito per la richieste {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Errore non gestito per la richiesta {0} {1}: {2}"
+}
+

package/intl/ja/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "要求 {0} {1} に対する一連のエラーが処理されていません\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "要求 {0} {1} のエラーが処理されていません: {2}"
+}
+

package/intl/ko/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "요청 {0} {1}에 대해 처리되지 않는 오류 배열\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "요청 {0} {1}에 대해 처리되지 않는 오류: {2}"
+}
+

package/intl/nl/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Onverwerkte array van fouten voor opdracht {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Onverwerkte fout opgetreden voor opdracht {0} {1}: {2}"
+}
+

package/intl/pt/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "Matriz não manipulada de erros para solicitação {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "Erro não manipulado para solicitação {0} {1}: {2}"
+}
+

package/intl/tr/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "İstek için işlenemeyen hata dizisi: {0} {1}\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "{0} {1} isteği için işlenemeyen hata: {2}"
+}
+

package/intl/zh-Hans/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "未处理请求 {0} {1} 的错误数组\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "未处理请求 {0} {1} 的错误：{2}"
+}
+

package/intl/zh-Hant/messages.json

@@ -0,0 +1,5 @@
+{
+  "85312d2b987e2e44001db3d6963a1364": "要求 {0} {1} 發生許多未處理的錯誤\n",
+  "adcbd4c562b19f45fb5d3427619646d5": "要求 {0} {1} 發生未處理的錯誤：{2}"
+}
+

package/lib/clone.js

@@ -1,3 +1,4 @@
+'use strict';
 module.exports = cloneAllProperties;
 
 /**

package/lib/content-negotiation.js

@@ -0,0 +1,91 @@
+// Copyright IBM Corp. 2016. All Rights Reserved.
+// Node module: strong-error-handler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+'use strict';
+var accepts = require('accepts');
+var debug = require('debug')('strong-error-handler:http-response');
+var sendJson = require('./send-json');
+var sendHtml = require('./send-html');
+var sendXml = require('./send-xml');
+var util = require('util');
+
+module.exports = negotiateContentProducer;
+
+/**
+ * Handles req.accepts and req.query._format and options.defaultType
+ * to resolve the correct operation
+ *
+ * @param req request object
+ * @param {Object} options options of strong-error-handler
+ * @returns {Function} Opeartion function with signature `fn(res, data)`
+ */
+function negotiateContentProducer(req, options) {
+  var SUPPORTED_TYPES = [
+    'application/json', 'json',
+    'text/html', 'html',
+    'text/xml', 'xml',
+  ];
+
+  options = options || {};
+  var defaultType = 'json';
+
+  // checking if user provided defaultType is supported
+  if (options.defaultType) {
+    if (SUPPORTED_TYPES.indexOf(options.defaultType) > -1) {
+      debug('Accepting options.defaultType `%s`', options.defaultType);
+      defaultType = options.defaultType;
+    } else {
+      debug('defaultType: `%s` is not supported, ' +
+        'falling back to defaultType: `%s`', options.defaultType, defaultType);
+    }
+  }
+
+  // decide to use resolvedType or defaultType
+  // Please note that accepts assumes the order of content-type is provided
+  // in the priority returned
+  // example
+  // Accepts: text/html, */*, application/json ---> will resolve as text/html
+  // Accepts: application/json, */*, text/html ---> will resolve as application/json
+  // Accepts: */*, application/json, text/html ---> will resolve as application/json
+  // eg. Chrome accepts defaults to `text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*`
+  // In this case `resolvedContentType` will result as: `text/html` due to the order given
+  var resolvedContentType = accepts(req).types(SUPPORTED_TYPES);
+  debug('Resolved content-type', resolvedContentType);
+  var contentType = resolvedContentType || defaultType;
+
+  // to receive _format from user's url param to overide the content type
+  // req.query (eg /api/Users/1?_format=json will overide content negotiation
+  // https://github.com/strongloop/strong-remoting/blob/ac3093dcfbb787977ca0229b0f672703859e52e1/lib/http-context.js#L643-L645
+  var query = req.query || {};
+  if (query._format) {
+    if (SUPPORTED_TYPES.indexOf(query._format) > -1) {
+      contentType = query._format;
+    } else {
+      // format passed through query but not supported
+      var msg = util.format('Response _format "%s" is not supported' +
+        'used "%s" instead"', query._format, defaultType);
+      res.header('X-Warning', msg);
+      debug(msg);
+    }
+  }
+
+  debug('Content-negotiation: req.headers.accept: `%s` Resolved as: `%s`',
+    req.headers.accept, contentType);
+  return resolveOperation(contentType);
+}
+
+function resolveOperation(contentType) {
+  switch (contentType) {
+    case 'application/json':
+    case 'json':
+      return sendJson;
+    case 'text/html':
+    case 'html':
+      return sendHtml;
+    case 'text/xml':
+    case 'xml':
+      return sendXml;
+  }
+}

package/lib/data-builder.js

@@ -8,7 +8,11 @@
 var cloneAllProperties = require('../lib/clone.js');
 var httpStatus = require('http-status');
 
-module.exports = function buildResponseData(err, isDebugMode) {
+module.exports = function buildResponseData(err, options) {
+  // Debugging mode is disabled by default. When turned on (in dev),
+  // all error properties (including) stack traces are sent in the response
+  var isDebugMode = options.debug;
+
   if (Array.isArray(err) && isDebugMode) {
     err = serializeArrayOfErrors(err);
   }
@@ -31,6 +35,9 @@ module.exports = function buildResponseData(err, isDebugMode) {
     fillInternalError(data, err);
   }
 
+  var safeFields = options.safeFields || [];
+  fillSafeFields(data, err, safeFields);
+
   return data;
 };
 
@@ -76,3 +83,13 @@ function fillBadRequestError(data, err) {
 function fillInternalError(data, err) {
   data.message = httpStatus[data.statusCode] || 'Unknown Error';
 }
+
+function fillSafeFields(data, err, safeFields) {
+  if (!Array.isArray(safeFields)) {
+    safeFields = [safeFields];
+  }
+
+  safeFields.forEach(function(field) {
+    data[field] = err[field];
+  });
+}

package/lib/handler.js

@@ -5,11 +5,14 @@
 
 'use strict';
 
+var path = require('path');
+var SG = require('strong-globalize');
+SG.SetRootDir(path.resolve(__dirname, '..'));
 var buildResponseData = require('./data-builder');
 var debug = require('debug')('strong-error-handler');
 var format = require('util').format;
 var logToConsole = require('./logger');
-var sendJson = require('./send-json');
+var negotiateContentProducer = require('./content-negotiation');
 
 function noop() {
 }
@@ -25,10 +28,6 @@ exports = module.exports = function createStrongErrorHandler(options) {
 
   debug('Initializing with options %j', options);
 
-  // Debugging mode is disabled by default. When turned on (in dev),
-  // all error properties (including) stack traces are sent in the response
-  var isDebugMode = options.debug;
-
   // Log all errors via console.error (enabled by default)
   var logError = options.log !== false ? logToConsole : noop;
 
@@ -46,17 +45,13 @@ exports = module.exports = function createStrongErrorHandler(options) {
     if (!err.status && !err.statusCode && res.statusCode >= 400)
       err.statusCode = res.statusCode;
 
-    var data = buildResponseData(err, isDebugMode);
+    var data = buildResponseData(err, options);
     debug('Response status %s data %j', data.statusCode, data);
 
     res.setHeader('X-Content-Type-Options', 'nosniff');
     res.statusCode = data.statusCode;
 
-    // TODO: negotiate the content-type, take into account options.defaultType
-    // For now, we always return JSON. See
-    //  - https://github.com/strongloop/strong-error-handler/issues/4
-    //  - https://github.com/strongloop/strong-error-handler/issues/5
-    //  - https://github.com/strongloop/strong-error-handler/issues/6
-    sendJson(res, data);
+    var sendResponse = negotiateContentProducer(req, options);
+    sendResponse(res, data);
   };
 };

package/lib/logger.js

@@ -6,17 +6,19 @@
 'use strict';
 
 var format = require('util').format;
+var g = require('strong-globalize')();
 
 module.exports = function logToConsole(req, err) {
   if (!Array.isArray(err)) {
-    console.error('Unhandled error for request %s %s: %s',
+    g.error('Unhandled error for request %s %s: %s',
       req.method, req.url, err.stack || err);
     return;
   }
 
+  var errMsg = g.f('Unhandled array of errors for request %s %s\n',
+    req.method, req.url);
   var errors = err.map(formatError).join('\n');
-  console.error('Unhandled array of errors for request %s %s\n',
-    req.method, req.url, errors);
+  console.error(errMsg, errors);
 };
 
 function formatError(err) {

package/lib/send-html.js

@@ -0,0 +1,47 @@
+// Copyright IBM Corp. 2016. All Rights Reserved.
+// Node module: strong-error-handler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+'use strict';
+var ejs = require('ejs');
+var fs = require('fs');
+var path = require('path');
+
+var assetDir = path.resolve(__dirname, '../views');
+var compiledTemplates = {
+  // loading default template and stylesheet
+  default: loadDefaultTemplates(),
+};
+
+module.exports = sendHtml;
+
+function sendHtml(res, data, options) {
+  var toRender = {options: {}, data: data};
+  // TODO: ability to call non-default template functions from options
+  var body = compiledTemplates.default(toRender);
+  sendReponse(res, body);
+}
+
+/**
+ * Compile and cache the file with the `filename` key in options
+ *
+ * @param filepath (description)
+ * @returns {Function} render function with signature fn(data);
+ */
+function compileTemplate(filepath) {
+  var options = {cache: true, filename: filepath};
+  var fileContent = fs.readFileSync(filepath, 'utf8');
+  return ejs.compile(fileContent, options);
+}
+
+// loads and cache default error templates
+function loadDefaultTemplates() {
+  var defaultTemplate = path.resolve(assetDir, 'default-error.ejs');
+  return compileTemplate(defaultTemplate);
+}
+
+function sendReponse(res, body) {
+  res.setHeader('Content-Type', 'text/html; charset=utf-8');
+  res.end(body);
+}

package/lib/send-xml.js

@@ -0,0 +1,14 @@
+// Copyright IBM Corp. 2016. All Rights Reserved.
+// Node module: strong-error-handler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+'use strict';
+
+var js2xmlparser = require('js2xmlparser');
+
+module.exports = function sendXml(res, data) {
+  var content = js2xmlparser.parse('error', data);
+  res.setHeader('Content-Type', 'text/xml; charset=utf-8');
+  res.end(content, 'utf-8');
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "strong-error-handler",
   "description": "Error handler for use in development and production environments.",
   "license": "MIT",
-  "version": "1.0.1",
+  "version": "1.2.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/strongloop/strong-error-handler.git"
@@ -14,14 +14,27 @@
     "posttest": "npm run lint"
   },
   "dependencies": {
+    "accepts": "^1.3.3",
     "debug": "^2.2.0",
-    "http-status": "^0.2.2"
+    "ejs": "^2.4.2",
+    "http-status": "^0.2.2",
+    "js2xmlparser": "^2.0.2",
+    "strong-globalize": "^2.6.7"
   },
   "devDependencies": {
     "chai": "^2.1.1",
-    "eslint": "^2.5.3",
-    "eslint-config-loopback": "^3.0.0",
+    "eslint": "^2.13.1",
+    "eslint-config-loopback": "^4.0.0",
+    "express": "^4.13.4",
     "mocha": "^2.1.0",
     "supertest": "^1.1.0"
+  },
+  "browser": {
+    "strong-error-handler": false
+  },
+  "ci": {
+    "downstreamIgnoreList": [
+      "dashboard-controller"
+    ]
   }
 }

package/views/default-error.ejs

@@ -0,0 +1,25 @@
+<html>
+  <head>
+    <meta charset='utf-8'>
+    <title><%- data.name || data.message %></title>
+    <style><%- include style.css %></style>
+  </head>
+  <body>
+    <div id="wrapper">
+      <h1><%- data.name %></h1>
+      <h2><em><%- data.statusCode %></em> <%- data.message %></h2>
+      <%
+        // display all the non-standard properties
+        var standardProps = ['name', 'statusCode', 'message', 'stack'];
+        for (var prop in data) {
+          if (standardProps.indexOf(prop) == -1 && data[prop]) { %>
+            <div><b><%- prop %></b>: <%- data[prop] %></div>
+          <% }
+        }
+        if (data.stack) { %>
+          <pre id="stacktrace"><%- data.stack %></pre>
+        <% }
+      %>
+    </div>
+  </body>
+</html>

package/views/style.css

@@ -0,0 +1,31 @@
+* {
+  margin: 0;
+  padding: 0;
+  outline: 0;
+}
+body {
+  padding: 80px 100px;
+  font: 13px "Helvetica Neue", "Lucida Grande", "Arial";
+  background: #ECE9E9 -webkit-gradient(linear, 0% 0%, 0% 100%, from(#fff), to(#ECE9E9));
+  background: #ECE9E9 -moz-linear-gradient(top, #fff, #ECE9E9);
+  background-repeat: no-repeat;
+  color: #555;
+  -webkit-font-smoothing: antialiased;
+}
+h1, h2 {
+  font-size: 22px;
+  color: #343434;
+}
+h1 em, h2 em {
+  padding: 0 5px;
+  font-weight: normal;
+}
+h1 {
+  font-size: 60px;
+}
+h2 {
+  margin: 10px 0;
+}
+ul li {
+  list-style: none;
+}