Centralized error handler in Express - Mini Project: Build & Apply

Centralized error handler

📖 Scenario: You are building a simple Express server that handles user requests. To keep your code clean and easy to maintain, you want to create a centralized error handler that catches all errors in one place and sends a friendly error message to the client.

🎯 Goal: Build an Express server with a centralized error handler middleware that catches errors from routes and sends a JSON response with the error message and status code.

📋 What You'll Learn

Create an Express app with a basic route that throws an error

Add a configuration variable for the default error status code

Implement a centralized error handler middleware function

Use the error handler middleware in the Express app

💡 Why This Matters

🌍 Real World

Centralized error handling is used in real web servers to keep code clean and provide consistent error messages to users.

💼 Career

Knowing how to implement error handling middleware is essential for backend developers working with Express or similar frameworks.

1

Create Express app with a route that throws an error

Create an Express app by requiring express and calling express(). Then create a route GET / that throws an error with the message 'Something went wrong!'.

Express

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

// Your code here

Hint

Use require('express') to import Express and express() to create the app. Define a route with app.get('/', (req, res) => { ... }) and throw an error inside it.

2

Add a default error status code variable

Create a constant variable called DEFAULT_ERROR_STATUS and set it to 500 to represent the default HTTP status code for server errors.

Express

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

const DEFAULT_ERROR_STATUS = 500;

// Your code here

Hint

Use const DEFAULT_ERROR_STATUS = 500; to set the default error status code.

3

Implement centralized error handler middleware

Create an error handler middleware function called errorHandler that takes four parameters: err, req, res, and next. Inside it, send a JSON response with status set to err.status || DEFAULT_ERROR_STATUS and message set to err.message.

Express

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

const DEFAULT_ERROR_STATUS = 500;

function errorHandler(err, req, res, next) {
    // Your code here
}

Hint

The error handler middleware has four parameters. Use res.status(...).json(...) to send the error status and message as JSON.

4

Use the error handler middleware in the Express app

Add the errorHandler middleware to the Express app using app.use(errorHandler) after all routes.

Express

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

const DEFAULT_ERROR_STATUS = 500;

app.get('/', (req, res) => {
    throw new Error('Something went wrong!');
});

function errorHandler(err, req, res, next) {
    res.status(err.status || DEFAULT_ERROR_STATUS).json({
        status: err.status || DEFAULT_ERROR_STATUS,
        message: err.message
    });
}

// Your code here

Hint

Use app.use(errorHandler) after all routes to catch errors.

Practice

1. What is the main purpose of a centralized error handler in an Express app?

easy

A. To serve static files efficiently

B. To speed up the server response time

C. To catch and handle all errors in one place

D. To manage user sessions

Solution

1. Step 1: Understand error handling in Express

   Express allows middleware to catch errors and handle them centrally.

2. Step 2: Identify the role of centralized error handler

   It collects all errors from routes and middleware to respond consistently.

3. Final Answer:

   To catch and handle all errors in one place -> Option C

4. Quick Check:

   Centralized error handler = catch all errors [OK]

Hint: Centralized error handler catches errors globally, not locally [OK]

Common Mistakes:

• Thinking it improves server speed
• Confusing with static file serving
• Mixing with session management

2. Which of the following is the correct way to define a centralized error handler middleware in Express?

easy

A. app.use((req, res) => { res.status(500).send('Error'); });

B. app.use((err, req, res, next) => { res.status(500).send(err.message); });

C. app.get('/error', (err, req, res) => { res.send('Error'); });

D. app.use((req, res, next) => { res.send('Error'); });

Solution

1. Step 1: Recall Express error handler signature

   Error handlers have four parameters: (err, req, res, next).

2. Step 2: Match the correct middleware signature

   app.use((err, req, res, next) => { res.status(500).send(err.message); }); uses all four parameters correctly and sends error message.

3. Final Answer:

   app.use((err, req, res, next) => { res.status(500).send(err.message); }); -> Option B

4. Quick Check:

   Error handler middleware needs 4 params [OK]

Hint: Error handler middleware always has 4 parameters (err, req, res, next) [OK]

Common Mistakes:

• Using only 3 parameters in error handler
• Defining error handler as route handler
• Missing the 'err' parameter

3. Given this Express code snippet, what will be the response if an error occurs in the route?

app.get('/test', (req, res, next) => {
  next(new Error('Oops!'));
});

app.use((err, req, res, next) => {
  res.status(500).send('Error caught: ' + err.message);
});

medium

A. Status 500 with body 'Error caught: Oops!'

B. Status 200 with body 'Oops!'

C. Status 404 with body 'Not Found'

D. No response, server crashes

Solution

1. Step 1: Understand error propagation in route

   The route calls next() with an Error object, triggering error middleware.

2. Step 2: Check error handler response

   The error handler sends status 500 and message including error text.

3. Final Answer:

   Status 500 with body 'Error caught: Oops!' -> Option A

4. Quick Check:

   Error passed to handler = 500 response with message [OK]

Hint: next(error) triggers centralized error handler with status 500 [OK]

Common Mistakes:

• Expecting status 200 instead of 500
• Thinking error handler is skipped
• Assuming server crashes on error

4. Identify the error in this Express app setup for centralized error handling:

app.use((req, res, next) => {
  throw new Error('Fail');
});

app.use((req, res, next) => {
  res.status(500).send('Error occurred');
});

medium

A. Error handler middleware missing 'err' parameter

B. Throwing error inside middleware is not allowed

C. Error handler middleware should be placed before routes

D. Middleware order is correct, no error

Solution

1. Step 1: Check error handler signature

   Error handlers must have 4 parameters: (err, req, res, next).

2. Step 2: Analyze given error handler

   The second middleware has only (req, res, next), so it won't catch errors.

3. Final Answer:

   Error handler middleware missing 'err' parameter -> Option A

4. Quick Check:

   Error handler needs 4 params to catch errors [OK]

Hint: Error handler must have 4 parameters to work [OK]

Common Mistakes:

• Forgetting the 'err' parameter in error handler
• Placing error handler before routes
• Thinking throwing error is disallowed

5. You want to create a centralized error handler that logs errors and sends a JSON response with status code and message. Which code snippet correctly implements this?

hard

A. app.use((req, res, next) => { console.error('Error'); res.json({ error: 'Unknown' }); });

B. app.use((err, req, res, next) => { res.send('Error occurred'); });

C. app.use((err, req, res) => { res.status(500).send('Error'); });

D. app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); });

Solution

1. Step 1: Confirm error handler signature and logging

   app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); }); uses (err, req, res, next) and logs error with console.error.

2. Step 2: Check response format and status code

   app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); }); sends JSON with error message and status code from error or 500.

3. Final Answer:

   app.use((err, req, res, next) => { console.error(err); res.status(err.status || 500).json({ error: err.message }); }); -> Option D

4. Quick Check:

   Proper error handler logs and sends JSON with status [OK]

Hint: Error handler needs 4 params, logs error, sends JSON with status [OK]

Common Mistakes:

• Missing 'next' parameter in error handler
• Not logging the error
• Sending plain text instead of JSON