http-error-handling v1.0.13

http-error-handling

Handling HTTP errors for your Express application easily.

Install

This is a Node.js module available through the npm registry. Installation is done using the npm install command:

npm install http-error-handling

Features

• ErrorObject
• HttpError
• RequestValidator

Examples

CommonJS

var { HttpError } = require("http-error-handling")
var express = require("express")
var app = express()
// in the beginning of your app (important)
app.use(HttpError.initializer)
// your app routes or other middlewares
//sample APIs
app.get("/400", (req, res, next) => {
  return HttpError.BadRequest()
})
app.get("/500", (req, res, next) => {
  return HttpError.InternalServerError("something went wrong")
})
app.get("/custom", (req, res, next) => {
  const customError = {
    statusCode: 502,
    message: "custom message",
    errorKey: "custom_error", // optional parameter
    description: "description", // optional parameter
    help: "https://domain.example/integration/fixes/custom-api", // optional parameter
    invalidParams: [
      {
        message: "invalid value",
        location: "body", // optional parameter
        param: "email",
      },
      //you can add more objects
    ], // optional parameter
  }
  return HttpError.customError(errorObject)
})

//in the end of your app (important)
app.use(HttpError.handler)

ES6

import { ErrorsAttrs, HttpError } from "http-error-handling"
import express, { NextFunction, Request, Response } from "express"
let app = express()
// in the beginning of your app (important)
app.use(HttpError.initializer)
// your app routes or other middlewares
//sample APIs
app.get("/400", (req: Request, res: Response, next: NextFunction) => {
  return HttpError.BadRequest("invalid request data")
})
app.get("/500", (req: Request, res: Response, next: NextFunction) => {
  return HttpError.InternalServerError()
})
app.get("/custom", (req: Request, res: Response, next: NextFunction) => {
  const custom: ErrorsAttrs = {
    statusCode: 502,
    message: "custom message",
    errorKey: "custom_error", // optional parameter
    description: "description", // optional parameter
    help: "https://domain.example/integration/fixes/custom-api", // optional parameter
    invalidParams: [
      {
        message: "invalid value",
        location: "body", // optional parameter
        param: "string",
      },
      //you can add more objects
    ], // optional parameter
  }
  return HttpError.customError(errorObject)
})

//in the end of your app (important)
app.use(HttpError.handler)

ErrorObject

• statusCode: the status code of the error. required
• message: the error message. required
• description: the error description. optional
• help: the error url that can help the client to fix the api issue e.g (https://your-domain.example/integration/fixes/auth-api) optional

• invalidParams: the errors of request in case you need to validate the request data. optional

  • message: the error message. required
  • param: the error parameter name e.g (email, password, name, etc). optional
  • location: the location of parameter key. required

• errorKey: the error key and the main purpose we can use it for localization part and in this case we will have a generic errors we can catch any error message by key for example: we can store local.en.json and local.en.json includes

  { "bad_request": "invalid user request data" }

  and local.ar.json includes

  { "bad_request": "بايانات غير صحيحة" }

  and the both files located in the frontend so by using the response errorKey we can localize the error message easily. optional

HttpError

Initializer

it's a middleware should be used in the top of your app or at lest before your routes that include HttpError

// in the beginning of your app (important)
app.use(HttpError.initializer)
// OR
app.use((req, res, next) => {
  HttpError.initializer(req, res, next)
})

Handler

it's a middleware and it will handle all the errors returned by HttpError functions and it will send it back to the client but if the error not belong ot the lib it will pass it using next fun

// in the end of your app (important)
app.use(HttpError.handler)
// OR
app.use((err, req, res, next) => {
  HttpError.handler(err, req, res, next)
})

customError

it's a helper function can help you to create your custom error.

HttpError.{{ any function from the next list }}

• they are helper functions allow you to send sepecific error to the client

• attrs error object to customize your error response optional

  • message: the error message. required
  • errorKey: the error key. optional
  • help: the error help location/url. optional
  • description: the error description optional
  • invalidParams: the request parameters errors optional

RequestValidator

it's a middleware should be used after validating the request body/parameter/query using express-validator library

import { body } from "express-validator"
import { RequestValidator } from "http-error-handling"
import express, { NextFunction, Request, Response } from "express"
let app = express()
//sample API
app.get("/validate", body("email").isEmail(), RequestValidator, (req: Request, res: Response, next: NextFunction) => {
  return res.send(req.body)
})

License

MIT