1. module express-error-handler
   1. function express-error-handler (options)
   2. function express-error-handler.clientError ()
   3. function express-error-handler.httpError (status, message)
   4. function express-error-handler.isClientError (status)

module express-error-handler

function express-error-handler (options)

• description and source-code

  function createHandler(options) {
  
    var o = mixIn({}, defaults, options),
  
      /**
       * In case of an error, wait for a timer to
       * elapse, and then terminate.
       * @param {object} options
       * @param {number} o.exitStatus
       * @param {number} o.timeout
       */
      exit = o.shutdown || function exit(o){
  
        // Give the app time for graceful shutdown.
        setTimeout(function () {
          process.exit(o.exitStatus);
        }, o.timeout);
  
      },
      express = o.framework === 'express',
      restify = o.framework === 'restify',
      errorHandler;
  
    /**
     * Express error handler to handle any
     * uncaught express errors. For error logging,
     * see bunyan-request-logger.
     *
     * @param  {object}   err
     * @param  {object}   req
     * @param  {object}   res
     * @param  {function} next
     */
    errorHandler = function errorHandler(err, req,
        res, next) {
  
      var defaultView = o.views['default'],
        defaultStatic = o.static['default'],
        status = err && err.status ||
          res && res.statusCode,
        handler = o.handlers[status],
        view = o.views[status],
        staticFile = o.static[status],
  
        renderDefault = function
            renderDefault(statusCode) {
  
          res.statusCode = statusCode;
  
          if (defaultView) {
            return res.render(defaultView, err);
          }
  
          if (defaultStatic) {
            return sendFile(defaultStatic, res);
          }
  
          if (restify) {
            send(statusCode, err, res, o);
          }
  
          if (express) {
            return res.format({
              json: function () {
                send(statusCode, err, res, {
                  serializer: o.serializer || function (o) {
                    return o;
                  }
                });
              },
              text: function () {
                send(statusCode, err, res, {
                  serializer: function (o) {
                    return o.message;
                  }
                });
              },
              html: function () {
                send(statusCode, err, res, {
                  serializer: function (o) {
                    return o.message;
                  }
                });
              }
            });
          }
        },
  
        resumeOrClose = function
            resumeOrClose(status) {
          if (!isClientError(status)) {
            return close(o, exit);
          }
        };
  
      if (!res) {
        return resumeOrClose(status);
      }
  
      // If there's a custom handler defined,
      // use it and return.
      if (typeof handler === 'function') {
        handler(err, req, res, next);
        return resumeOrClose(status);
      }
  
      // If there's a custom view defined,
      // render it.
      if (view) {
        res.render(view, err);
        return resumeOrClose(status);
      }
  
      // If there's a custom static file defined,
      // render it.
      if (staticFile) {
        sendFile(staticFile, res);
        return resumeOrClose(status);
      }
  
      // If the error is user generated, send
      // a helpful error message, and don't shut
      // down.
      //
      // If we shutdown on user errors,
      // attackers can send malformed requests
      // for the purpose of creating a Denial
      // Of Service (DOS) attack.
      if (isClientError(status)) {
        return renderDefault(status);
      }
  
      // For all other errors, deliver a 500
      // error and shut down.
      renderDefault(500);
  
      close(o, exit);
    };
  
    if (express) {
      return errorHandler;
    }
  
    if (restify) {
      return function (req, res, route, err) {
        return errorHandler(err, req, res);
      };
    }
  }

• example usage

  n/a

function express-error-handler.clientError ()

• description and source-code

  clientError = function () {
    var args = [].slice.call(arguments);
  
    console.log('WARNING: .clientError() is ' +
      'deprecated. Use isClientError() instead.');
  
    return this.isClientError.apply(this, args);
  }

• example usage

  ...
    }
  };
  
  createHandler.isClientError = isClientError;
  createHandler.clientError = function () {
    var args = [].slice.call(arguments);
  
    console.log('WARNING: .clientError() is ' +
      'deprecated. Use isClientError() instead.');
  
    return this.isClientError.apply(this, args);
  };
  
  // HTTP error generating route.
  createHandler.httpError = httpError;
  ...

function express-error-handler.httpError (status, message)

• description and source-code

  function httpError(status, message) {
    var err = new Error();
    err.status = status;
    err.message = message ||
      statusCodes[status] ||
      'Internal server error';
  
    return function httpErr(req, res, next) {
      next(err);
    };
  }

• example usage

  ...
          // do some custom thing here...
        }
      }
    });
  
  // After all your routes...
  // Pass a 404 into next(err)
  app.use( errorHandler.httpError(404) );
  
  // Handle all unhandled errors:
  app.use( handler );
  ```
  
  Or for a static page:
  ...

function express-error-handler.isClientError (status)

• description and source-code

  function isClientError(status) {
    return (status >= 400 && status <= 499);
  }

• example usage

  ...
  var errorHandler = require('express-error-handler'),
  handler = errorHandler({
    serializer: function(err) {
      var body = {
        status: err.status,
        message: err.message
      };
      if (createHandler.isClientError(err.status)) {
        ['code', 'name', 'type', 'details'].forEach(function(prop) {
          if (err[prop]) body[prop] = err[prop];
        });
      }
      return body;
    }
  });
  ...