Error Handling Examples in Node.js API

Understanding Error Handling in a Node.js API

Error handling is a critical aspect of building robust APIs in Node.js. Proper error handling ensures that your API can gracefully manage unexpected issues, providing clear feedback to users and maintaining system stability. Below are three diverse examples showcasing effective error handling strategies in a Node.js API.

Example 1: Handling Validation Errors with Express

Use Case

In this example, we’ll handle validation errors when a user submits data that does not meet the required criteria. This is particularly useful for APIs that accept user input.

const express = require('express');
const app = express();
app.use(express.json());

app.post('/api/users', (req, res) => {
    const { name, email } = req.body;
    if (!name || !email) {
        return res.status(400).json({ error: 'Name and email are required.' });
    }
    // Assume user creation logic here
    res.status(201).json({ message: 'User created successfully!' });
});

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

Notes

• In this example, we check for the presence of ’name’ and ‘email’ in the request body. If either is missing, we return a 400 Bad Request status with a descriptive error message.

Example 2: Centralized Error Handling Middleware

Use Case

This example demonstrates how to implement centralized error handling using middleware in an Express application. This approach helps in managing different types of errors in one place, improving code organization.

const express = require('express');
const app = express();
app.use(express.json());

app.get('/api/resource', (req, res) => {
    throw new Error('Resource not found'); // Simulating an error
});

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({ error: 'Something went wrong!' });
});

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

Notes

• Here, we simulate an error when accessing a resource. The centralized error handling middleware captures the error and returns a 500 Internal Server Error response. This setup makes it easier to manage errors without repeating code in each route handler.

Example 3: Handling Asynchronous Errors with Promises

Use Case

This example illustrates error handling in asynchronous operations, such as database queries. Proper handling ensures that unhandled promise rejections do not crash the application.

const express = require('express');
const app = express();
app.use(express.json());

const fakeDatabaseQuery = () => {
    return new Promise((resolve, reject) => {
        // Simulating an error
        reject(new Error('Database connection failed')); 
    });
};

app.get('/api/data', async (req, res) => {
    try {
        const data = await fakeDatabaseQuery();
        res.json(data);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

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

Notes

• In this case, we simulate a database query that fails. By using a try-catch block within an async route handler, we can gracefully handle the error and send a 500 status response with the error message. This approach improves the overall resilience of the API.

These examples of error handling in a Node.js API showcase different strategies for managing errors effectively. By implementing these practices, you can create a more reliable and user-friendly API.