Central Error Handling in Express
Tags: express, node, tutorial
Published: 2019-07-15 19:38:41

---
title: "Central Error Handling in Express"
published: true
description: 
cover_image: https://thepracticaldev.s3.amazonaws.com/i/prk3l7zarj3ksrdk66z7.png
tags: 
 - Express
 - NodeJs,
 - tutorial
---

> Express is a fast, unopinionated, minimalist web framework for Node.js - [docs](https://expressjs.com/)

Error handling is a routine that one can not do without while building an application either in Express or in any other language.

When building API endpoints using Express or any other framework/library, validation checks are always necessary for each use case, and there's always a need to return an error response to the user. Handling these errors and returning a response for every validation becomes very tedious and makes the codebase messy. 
Let's consider an example below:

```js
const validateUser = async (req, res, next) => {
  try {
    const { email, password } = req.body
    if (!email || !password) {
      return res.status(400).json({
        status: 'error',
        message: 'Missing required email and password fields',
      })
    }
    const user = await db.User.findOne({ where: { email }});
    if (!user) {
      return res.status(404).json({
        status: 'error',
        message: 'User with the specified email does not exists',
      })
    }
    next()
  } catch (error) {
    return res.status(500).json({
      status: 'error',
      message: 'An error occurred trying to process your request',
    })
  }
}
```
Looking at the snippet above, you'd agree with me that it's already looking messy with the returning of error response at every checkpoint. If only that's the code in your codebase, then it wouldn't matter, the matter arises when you have to repeat the same approach across several methods or functions in your codebase.

Before we dive deep to finding a solution to make the snippet above better, let's look at what we need to have for this article:

## Requirements

- NodeJs installed
- npm or yarn installed
- Knowledge of Nodejs/Express 

> Note: This article assumes that the reader already has a basic knowledge of NodeJs/Express. Hence some details may be skipped.

__To follow along, clone the repository used for this article [here](https://github.com/oriechinedu/express-error-handling.git).__

__Step 1__. *Create a custom **Error** constructor*
We need to create a custom Error constructor which extends the [JavaScript Error constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error).

In the project you cloned earlier, create a directory called **helpers**. Inside the **helpers** directory, create a file called **error.js**

Add the snippet below into the **error.js**
```js
class ErrorHandler extends Error {
  constructor(statusCode, message) {
    super();
    this.statusCode = statusCode;
    this.message = message;
  }
}
module.exports = {
  ErrorHandler
}
```
Notice that we exported the ErrorHandler so that we can import it from the **index.js** file.

Next up, we need to create a function for returning a formatted error response to the user.

Add the snippet below into the `error.js` file.

```js
const handleError = (err, res) => {
  const { statusCode, message } = err;
  res.status(statusCode).json({
    status: "error",
    statusCode,
    message
  });
};
```
Update the `module.exports` block to contain the `handleError` function as show below:

```
module.exports = {
  ErrorHandler,
  handleError
}
```


__Step 2__. *Create the Error-handling middleware*

> Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle. 
> The next middleware function is commonly denoted by a variable named next. [Express docs](https://expressjs.com/en/guide/using-middleware.html)

The error-handling middleware is a special type of middleware that accepts four arguments as opposed to a regular middleware. The first argument is the **error** object.
The snippet below shows an example of an error-handling middleware:

```js
function(err, req, res, next) {
  //code goes here
}
```

In the `index.js`, let's add an error-handling middleware, before then, let's import the `handleError` function inside the `index.js`;

The `index.js` file should look like shown below:

```js
const express = require('express')
const { handleError } = require('./helpers/error')
const app = express()

app.use(express.json())
const PORT = process.env.PORT || 3000

app.get('/', (req, res) => {
  return res.status(200).json('Hello world'); 
})

app.use((err, req, res, next) => {
  handleError(err, res);
});
app.listen(PORT, () => console.log(`server listening at port ${PORT}`))
```
Notice how we called the `handleError` function passing the error object and the response object to it.

> Note: The error-handling middleware must be the last among other middleware and routes for it to function correctly.

Now anywhere in the application that you want to check for error, all you need to do is to throw the `ErrorHandler` constructor.
We can now apply the error-handling mechanism to refactor the messy code we had earlier. It should look like shown below:

```js
const validateUser = async (req, res, next) => {
  try {
    const { email, password } = req.body
    if (!email || !password) {
      throw new ErrorHandler(404, 'Missing required email and password fields')
    }
    const user = await  db.User.findOne({ where: { email }});
    if (!user) {
      throw new ErrorHandler(404, 'User with the specified email does not exists')
    }
    next()
  } catch (error) {
    next(error)
  }
}
```
Notice how we passed the error to the `next` function above. What that simply does is to pass the error to the error-handling middleware we defined in `index.js`.

Let's add a route to test our error-handling mechanism that we just created. In the `index.js` add the snippet below:

```js
app.get('/error', (req, res) => {
  throw new ErrorHandler(500, 'Internal server error');
})
```
Remember to import the ErrorHandler in `index.js`. It should look like shown below:

```js
const { handleError, ErrorHandler } = require('./helpers/error')
```

Start the server by running, npm start and then visit the route `/error`. You'd get a response similar to the one shown below:

```js
{
    "status": "error",
    "statusCode": 500,
    "message": "Internal server error"
}
```
### Conclusion
In this article, we've established the need to have a central error handler in our Express application. We also demonstrated the steps that we need to take to implement a central error handler. 

If you have any question or contributions to make this article better, kindly reach out to me via [Twitter](https://twitter.com/iam_nedsoft).
Thanks for reading through. ✌️