Error-handling middleware in Express - Mini Project: Build & Apply

Error-handling middleware

📖 Scenario: You are building a simple Express server that handles user requests. Sometimes errors happen, like when a user asks for a page that does not exist. To keep your server friendly and clear, you want to add a special error-handling middleware that catches errors and sends a nice message back to the user.

🎯 Goal: Create an Express app with a route that triggers an error, then add an error-handling middleware that catches the error and sends a JSON response with the error message and a 500 status code.

📋 What You'll Learn

Create an Express app instance called app

Add a route /cause-error that throws an error with message 'Something went wrong!'

Create an error-handling middleware function with four parameters: err, req, res, next

In the error handler, send a JSON response with status 500 and message from the error

Use app.use to add the error-handling middleware after the route

💡 Why This Matters

🌍 Real World

Error-handling middleware helps keep web servers stable and user-friendly by catching unexpected problems and sending clear messages.

💼 Career

Understanding error-handling middleware is essential for backend developers working with Express to build reliable and maintainable web applications.

1

Create the Express app and route

Write code to import Express, create an app instance called app, and add a GET route /cause-error that throws a new Error with the message 'Something went wrong!'.

Express

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

// Your code here

Hint

Use const app = express() to create the app. Then use app.get('/cause-error', (req, res) => { throw new Error('Something went wrong!') }) to add the route.

2

Create the error-handling middleware function

Write a function called errorHandler that takes four parameters: err, req, res, and next. Inside the function, send a JSON response with status code 500 and a message property set to err.message.

Express

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

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

// Write errorHandler function below
// Your code here

Hint

The error handler must have four parameters. Use res.status(500).json({ message: err.message }) to send the error message.

3

Add the error-handling middleware to the app

Use app.use to add the errorHandler middleware to the Express app after the route definition.

Express

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

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

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

// Add errorHandler middleware below
// Your code here

Hint

Use app.use(errorHandler) to add the error handler after all routes.

4

Start the Express server

Add code to start the Express server on port 3000 using app.listen. Inside the listen callback, log the message 'Server running on port 3000'.

Express

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

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

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

app.use(errorHandler);

// Start server on port 3000
// Your code here

Hint

Use app.listen(3000, () => { console.log('Server running on port 3000') }) to start the server.

Practice

1. What is the main purpose of error-handling middleware in Express?

easy

A. To serve static files like images and CSS

B. To parse incoming JSON request bodies

C. To catch errors and prevent the server from crashing

D. To log every request made to the server

Solution

1. Step 1: Understand middleware roles

   Middleware can serve many roles, but error-handling middleware specifically catches errors.

2. Step 2: Identify error-handling middleware purpose

   Error-handling middleware prevents the server from crashing by catching errors and responding properly.

3. Final Answer:

   To catch errors and prevent the server from crashing -> Option C

4. Quick Check:

   Error-handling middleware = catch errors [OK]

Hint: Error middleware catches errors to keep server running [OK]

Common Mistakes:

• Confusing error middleware with static file serving
• Thinking it parses request bodies
• Assuming it logs requests

2. Which of the following is the correct signature for an Express error-handling middleware function?

easy

A. (err, req, res, next)

B. (req, res, next)

C. (req, res)

D. (err, res, next)

Solution

1. Step 1: Recall error middleware parameters

   Error-handling middleware always has four parameters: err, req, res, next.

2. Step 2: Match the correct parameter order

   Only (err, req, res, next) has all four parameters in the correct order.

3. Final Answer:

   (err, req, res, next) -> Option A

4. Quick Check:

   Error middleware signature = (err, req, res, next) [OK]

Hint: Error middleware always has 4 parameters starting with err [OK]

Common Mistakes:

• Using only three parameters
• Omitting the err parameter
• Wrong parameter order

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

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

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

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

app.listen(3000);

medium

A. The client receives 'Error caught: Oops!' with status 500

B. The server crashes and stops running

C. The client receives a 404 Not Found error

D. The client receives an empty response with status 200

Solution

1. Step 1: Identify error thrown in route

   The route throws an error with message 'Oops!'.

2. Step 2: Check error-handling middleware response

   The error middleware catches the error and sends a 500 status with message including 'Oops!'.

3. Final Answer:

   The client receives 'Error caught: Oops!' with status 500 -> Option A

4. Quick Check:

   Error thrown = caught and sent with 500 [OK]

Hint: Thrown errors go to error middleware response [OK]

Common Mistakes:

• Expecting server crash on error
• Confusing 404 with error response
• Missing error message in response

4. What is wrong with the following error-handling middleware?

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

medium

A. It should be placed before routes

B. The parameters are in the wrong order

C. It is missing the next() call

D. It should not have four parameters

Solution

1. Step 1: Check parameter order for error middleware

   Error middleware must have parameters in order: err, req, res, next.

2. Step 2: Identify incorrect order in code

   The code has (req, res, next, err) which is incorrect.

3. Final Answer:

   The parameters are in the wrong order -> Option B

4. Quick Check:

   Error middleware params order = err, req, res, next [OK]

Hint: Error middleware params start with err, not req [OK]

Common Mistakes:

• Swapping err and req parameters
• Placing error middleware before routes
• Forgetting to call next() when needed

5. You want to create an error-handling middleware that logs the error message and then passes the error to the next middleware. Which of the following implementations is correct?

A) app.use((err, req, res, next) => {
  console.log(err.message);
  next(err);
});

B) app.use((req, res, next, err) => {
  console.log(err.message);
  next();
});

C) app.use((err, req, res) => {
  console.log(err.message);
  next(err);
});

D) app.use((err, req, res, next) => {
  console.log(err.message);
  res.send('Error logged');
});

hard

A. app.use((err, req, res, next) => {
console.log(err.message);
res.send('Error logged');
});

B. app.use((req, res, next, err) => {
console.log(err.message);
next();
});

C. app.use((err, req, res) => {
console.log(err.message);
next(err);
});

D. app.use((err, req, res, next) => {
console.log(err.message);
next(err);
});

Solution

1. Step 1: Recall requirements for error-handling middleware that chains

   It must have four parameters starting with err, log err.message, and call next(err) to pass the error to the next handler.

2. Step 2: Match against provided implementations

   Implementations with incorrect parameter order or count fail to receive or handle err properly; those that respond instead of calling next(err) break the chain.

3. Final Answer:

   app.use((err, req, res, next) => {
     console.log(err.message);
     next(err);
   }); -> Option D

4. Quick Check:

   4 params + next(err) = correct chaining [OK]

Hint: Error middleware must have 4 params and call next(err) to continue [OK]

Common Mistakes:

• Wrong parameter order
• Forgetting next parameter
• Not calling next(err) to pass error along
• Sending response too early