@feathersjs/express/src/handlers.ts

import path from 'path';
import { NotFound, GeneralError } from '@feathersjs/errors';
import { Request, Response, NextFunction, ErrorRequestHandler, RequestHandler } from 'express';

const defaults = {
  public: path.resolve(__dirname, '..', 'public'),
  logger: console
};
const defaultHtmlError = path.resolve(defaults.public, 'default.html');

export function notFound ({ verbose = false } = {}): RequestHandler {
  return function (req: Request, _res: Response, next: NextFunction) {
    const url = `${req.url}`;
    const message = `Page not found${verbose ? ': ' + url : ''}`;

    next(new NotFound(message, { url }));
  };
}

export type ErrorHandlerOptions = {
  public?: string;
  logger?: boolean|{ error?: (msg: any) => void, info?: (msg: any) => void };
  html?: any;
  json?: any;
};

export function errorHandler (_options: ErrorHandlerOptions = {}): ErrorRequestHandler {
  const options = Object.assign({}, defaults, _options);

  if (typeof options.html === 'undefined') {
    options.html = {
      401: path.resolve(options.public, '401.html'),
      404: path.resolve(options.public, '404.html'),
      default: defaultHtmlError
    };
  }

  if (typeof options.json === 'undefined') {
    options.json = {};
  }

  return function (error: any, req: Request, res: Response, next: NextFunction) {
    // Set the error code for HTTP processing semantics
    error.code = !isNaN(parseInt(error.code, 10)) ? parseInt(error.code, 10) : 500;

    // Log the error if it didn't come from a service method call
    if (options.logger && typeof options.logger.error === 'function' && !res.hook) {
      if (error.code >= 500) {
        options.logger.error(error);
      } else {
        options.logger.info(error);
      }
    }

    if (error.type !== 'FeathersError') {
      const oldError = error;

      error = oldError.errors ? new GeneralError(oldError.message, {
        errors: oldError.errors
      }) : new GeneralError(oldError.message);

      if (oldError.stack) {
        error.stack = oldError.stack;
      }
    }

    const formatter: { [key: string]: any } = {};

    // If the developer passed a custom function for ALL html errors
    if (typeof options.html === 'function') {
      formatter['text/html'] = options.html;
    } else {
      let file = options.html[error.code];
      if (!file) {
        file = options.html.default || defaultHtmlError;
      }
      // If the developer passed a custom function for individual html errors
      if (typeof file === 'function') {
        formatter['text/html'] = file;
      } else {
        formatter['text/html'] = function () {
          res.set('Content-Type', 'text/html');
          res.sendFile(file);
        };
      }
    }

    // If the developer passed a custom function for ALL json errors
    if (typeof options.json === 'function') {
      formatter['application/json'] = options.json;
    } else {
      const handler = options.json[error.code] || options.json.default;
      // If the developer passed a custom function for individual json errors
      if (typeof handler === 'function') {
        formatter['application/json'] = handler;
      } else {
        // Don't show stack trace if it is a 404 error
        if (error.code === 404) {
          error.stack = null;
        }

        formatter['application/json'] = function () {
          const output = Object.assign({}, error.toJSON());

          if (process.env.NODE_ENV === 'production') {
            delete output.stack;
          }

          res.set('Content-Type', 'application/json');
          res.json(output);
        };
      }
    }

    res.status(error.code);

    const contentType = req.headers['content-type'] || '';
    const accepts = req.headers.accept || '';

    // by default just send back json
    if (contentType.indexOf('json') !== -1 || accepts.indexOf('json') !== -1) {
      formatter['application/json'](error, req, res, next);
    } else if (options.html && (contentType.indexOf('html') !== -1 || accepts.indexOf('html') !== -1)) {
      formatter['text/html'](error, req, res, next);
    } else {
      // TODO (EK): Maybe just return plain text
      formatter['application/json'](error, req, res, next);
    }
  };
}