Centralized error handler in Express - Step-by-Step Execution

Concept Flow - Centralized error handler

Request received

↓

Route handler runs

↓

Error occurs?

No→Send response

Yes↓

Pass error to next()

↓

Centralized error handler middleware

↓

Send error response

The request goes to a route handler. If an error happens, it is passed to the centralized error handler middleware, which sends the error response.

Execution Sample

Express

app.get('/user', (req, res, next) => {
  if (!req.query.id) {
    next(new Error('ID missing'));
  } else {
    res.send('User found');
  }
});

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

This code checks if the query has an id. If not, it sends an error to the centralized error handler which returns a 400 status with the error message.

Execution Table

Step	Action	Condition	Result	Next
1	Request to /user without id	id missing?	Yes	Call next(error)
2	next(error) called	Error passed to middleware?	Yes	Centralized error handler runs
3	Error handler runs	Send response with error message	Status 400, message 'ID missing'	Response sent
4	Request to /user with id	id missing?	No	Send 'User found' response
5	Response sent	End of request	Success	Request complete

💡 Execution stops after sending response either from route or error handler.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
req.query.id	undefined or value	undefined (missing) or value	undefined (error passed) or value	unchanged	unchanged
error	none	Error('ID missing') created or none	passed to error handler or none	handled or none	none
res.statusCode	200 default	200	400 if error	400 or 200	final status sent
res.body	empty	'User found' or empty	error message or 'User found'	sent response	sent response

Key Moments - 3 Insights

Why do we call next(error) instead of sending response directly in the route?

Calling next(error) passes the error to the centralized error handler middleware, keeping error handling in one place. See execution_table step 2 where next(error) triggers the error handler.

What happens if the route sends a response without calling next(error)?

The centralized error handler is not called. The response is sent immediately as in execution_table step 4 and 5.

Why does the error handler have four parameters (err, req, res, next)?

Express recognizes middleware with four parameters as error handlers. This lets Express route errors to this middleware, as shown in the concept_flow and execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution table, what is the status code sent when an error occurs?

A 400

B 200

C 500

D 404

💡 Hint

Check execution_table row 3 where the error handler sends the response.

At which step does the centralized error handler middleware run?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

See execution_table where error handler sends the error response.

If the route always sends a response without calling next(error), what changes in the execution table?

A Error handler runs anyway

B next(error) is never called, error handler skipped

C Status code changes to 500

D Request never completes

💡 Hint

Look at execution_table step 4 and 5 where no error is passed.

Concept Snapshot

Centralized error handler in Express:
- Use next(error) in routes to pass errors
- Define error handler middleware with 4 params: (err, req, res, next)
- Error handler sends error response centrally
- Keeps error handling consistent and clean
- Middleware order matters: error handler last

Full Transcript

In Express, when a request comes in, the route handler runs. If an error happens, instead of sending a response immediately, the route calls next(error). This passes the error to a special middleware called the centralized error handler, which has four parameters: err, req, res, next. This middleware sends a response with the error message and status code. If no error occurs, the route sends the normal response. This keeps error handling in one place and makes code cleaner. The error handler middleware must be added after all routes. The execution table shows the steps: request received, error detected, next(error) called, error handler runs, response sent. Variables like req.query.id, error, res.statusCode, and res.body change accordingly during these steps.

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