Express.js Error Handling Middleware

Error handling middleware is essential in any web application to capture and manage errors gracefully. Express provides a simple way to handle errors through custom middleware functions, which can be used to handle synchronous and asynchronous errors in a centralized manner.

 

Key Features of Error Handling Middleware

• Centralized Error Handling: By using error-handling middleware, you can catch and manage errors from various routes in one place.
• Customizable Responses: You can customize error responses to ensure users receive clear and consistent error messages.
• Handles Synchronous and Asynchronous Errors: Express allows error handling for both synchronous and asynchronous errors (e.g., from Promises).

 

Steps to Implement Error Handling Middleware

Basic Error Handling Middleware
Error-handling middleware is defined by having four arguments: err, req, res, and next. This middleware is placed after all route definitions.

Example:

const express = require('express');
const app = express();

// Define a route that generates an error
app.get('/error', (req, res, next) => {
    const error = new Error('Something went wrong!');
    next(error);  // Pass the error to the next middleware
});

// Basic error handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);  // Log the error stack
    res.status(500).send({ message: 'Something went wrong!', error: err.message });
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

In this example:

• A route /error is intentionally causing an error.
• The error is passed to the error-handling middleware via the next() function.
• The error-handling middleware logs the error stack and sends a response to the client with the error message.

Error Handling for Asynchronous Code
For asynchronous code such as Promises or async functions, you can catch errors by passing them to the error-handling middleware.

Example with Promises:

app.get('/async-error', (req, res, next) => {
    Promise.reject(new Error('Async error occurred!'))
        .catch(next);  // Pass the error to the error-handling middleware
});

Example with async/await:

app.get('/async-await-error', async (req, res, next) => {
    try {
        throw new Error('Async/await error occurred!');
    } catch (err) {
        next(err);  // Pass the error to the error-handling middleware
    }
});

Custom Error Types
You can create custom error types to handle different kinds of errors more effectively, for example, validation or authentication errors.

Example:

class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = 'ValidationError';
    }
}

app.get('/validation-error', (req, res, next) => {
    next(new ValidationError('Invalid input data!'));
});

app.use((err, req, res, next) => {
    if (err instanceof ValidationError) {
        res.status(400).send({ message: err.message });
    } else {
        next(err);
    }
});

Default Error Handling Middleware
You can create a default error handler that handles any error not caught by the previous middleware.

Example:

app.use((err, req, res, next) => {
    console.error(err.stack);  // Log the error stack for debugging
    res.status(500).send({ message: 'An unexpected error occurred!' });
});

Error Handling for Specific Routes
You can also handle errors for specific routes or groups of routes by applying custom error-handling middleware within those specific route handlers.

Example:

const userRouter = express.Router();

userRouter.use((err, req, res, next) => {
    if (err instanceof SyntaxError) {
        res.status(400).send({ message: 'Invalid JSON' });
    } else {
        next(err);  // Pass to the next middleware if error type is different
    }
});

userRouter.get('/profile', (req, res, next) => {
    const error = new Error('User profile not found');
    next(error);
});

app.use('/user', userRouter);

 

Example of Complete Error Handling Setup

const express = require('express');
const app = express();

// Middleware to parse JSON body
app.use(express.json());

// Route that throws an error
app.get('/test-error', (req, res, next) => {
    const error = new Error('Test error occurred');
    next(error);  // Pass error to next middleware
});

// Basic error-handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);  // Log error stack for debugging
    res.status(500).send({ message: 'Internal Server Error', error: err.message });
});

// Starting the server
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

 

Summary

Error handling middleware in Express helps you manage errors efficiently by providing a centralized place to catch errors, log them, and return appropriate responses. You can handle both synchronous and asynchronous errors, as well as create custom error types for specific use cases. By using error-handling middleware, your application can respond gracefully to unexpected issues while maintaining a clean and structured error management system.