ang-errors/lib/errors/index.js

errors management for the ANG API'S

const restifyErrors = require('restify-errors');
const { StatusCodes, ReasonPhrases } = require('http-status-codes');
const { constants, errorMessages } = require('../config');
const log = require('ang-logger');
/**
 * Creates a custom Error
 * @param customError Object
 * @returns err RestifyError
 */
const createError = (customError) => {
    let statusCode = customError.httpCode
        || customError.statusCode
        || customError.code;

    if (!statusCode) statusCode = StatusCodes.unavailable;
    let err;

    console.log(statusCode);
    console.log(customError);
    switch (statusCode) {
        case StatusCodes.BAD_REQUEST:
            err = new restifyErrors.BadRequestError(errorMessages.badRequest);
            break;
        case StatusCodes.UNAUTHORIZED:
            err = new restifyErrors.UnauthorizedError(errorMessages.unauthorized);
            break;
        case StatusCodes.FORBIDDEN:
            err = new restifyErrors.ForbiddenError(errorMessages.forbidden);
            break;
        case StatusCodes.NOT_FOUND:
            err = new restifyErrors.NotFoundError(errorMessages.notFound);
            break;
        case StatusCodes.UNPROCESSABLE_ENTITY:
            err = new restifyErrors.UnprocessableEntityError(errorMessages.unprocessableEntity);
            break;
        case StatusCodes.NOT_IMPLEMENTED:
            err = new restifyErrors.NotImplementedError(errorMessages.notImplemented);
            break;
        default:
            err = new restifyErrors.ServiceUnavailableError(errorMessages.unavailable);
            break;
    }

    return err;
};

const returnTypeOfError = (stack) => {
    let jsonError = {};

     if (stack.includes(constants.INPUT_VALIDATION_ERROR)) {
         jsonError.code = StatusCodes.BAD_REQUEST;
         jsonError.message = ReasonPhrases.BAD_REQUEST;
     }
     else if (stack.includes(constants.METHOD_NOT_ALLOWED_ERROR)
            ||stack.includes(constants.RESOURCE_NOT_FOUND_ERROR)) {
         jsonError.code = StatusCodes.NOT_FOUND;
         jsonError.message = ReasonPhrases.NOT_FOUND;
     }
     else {
         jsonError.code = StatusCodes.SERVICE_UNAVAILABLE;
         jsonError.message = ReasonPhrases.SERVICE_UNAVAILABLE;
     }

    return jsonError;
};

/**
 * Formats the error response
 * @param server Object
 */
const errors = (server) => {
    server.on('restifyError', (req, res, customError, callback) => {
        let jsonError = {};
        let restifyError = null;

        /** Error with stack no need to create one*/
        if (customError.stack) {
            jsonError = returnTypeOfError(customError.stack);
        } else {
            /** Error is from other side */
            restifyError = createError(customError);
            jsonError.code = restifyError.statusCode;
            jsonError.message = restifyError.message;
        }

        /** mandatory to be validator compliant */
        if (customError.errors) jsonError.details = customError.errors;
        if (customError.details) jsonError.details = customError.details;

        /** If customError is not a validation error logging restifyError, else
         * logging customError
         */
        const err = restifyError || customError;

        if (jsonError.code !== StatusCodes.SERVICE_UNAVAILABLE) {
            /** Log errors */
            log.error({ req, err, customError });
        } else {
            /** Log fatal */
            log.fatal({ req, err, customError });
        }

        res.status(jsonError.code);
        res.send(jsonError);

        return callback();
    });
};

module.exports = { createError, errors };