Async error handling in routes in Express - Mini Project: Build & Apply

Async Error Handling in Express Routes

📖 Scenario: You are building a simple Express server that fetches user data asynchronously. You want to handle errors properly in your routes so the server does not crash and sends meaningful error messages to clients.

🎯 Goal: Create an Express route that fetches user data asynchronously and handles errors using async/await and try/catch blocks.

📋 What You'll Learn

Create an Express app with a route /user/:id

Use an async function to simulate fetching user data

Add a configuration variable for a delay time

Use try/catch inside the route to handle errors

Send a JSON response with user data or error message

💡 Why This Matters

🌍 Real World

Handling asynchronous operations and errors in web server routes is essential for building reliable APIs that do not crash and provide clear feedback to clients.

💼 Career

Backend developers frequently write async routes in Express and must handle errors properly to maintain server stability and good user experience.

1

Set up Express app and user data

Create a variable called express that requires the 'express' module. Then create an Express app by calling express() and assign it to a variable called app. Finally, create a constant object called users with these exact entries: 1: { name: 'Alice' }, 2: { name: 'Bob' }.

Express

# Your code here

Hint

Use require('express') to import Express. Create app by calling express(). Define users as an object with keys 1 and 2.

2

Add delay configuration variable

Create a constant called delay and set it to 1000 (milliseconds).

Express

const express = require('express');
const app = express();
const users = {
  1: { name: 'Alice' },
  2: { name: 'Bob' }
};

// Your code here

Hint

Just create a constant delay and assign it the number 1000.

3

Create async function to fetch user data

Write an async function called getUserById that takes id as a parameter. Inside, return a new Promise that waits for delay milliseconds using setTimeout. After the delay, if users[id] exists, resolve with users[id], otherwise reject with an Error with message 'User not found'.

Express

const express = require('express');
const app = express();
const users = {
  1: { name: 'Alice' },
  2: { name: 'Bob' }
};

const delay = 1000;

// Your code here

Hint

Use new Promise with setTimeout to simulate delay. Resolve if user exists, reject with error if not.

4

Add async route with error handling

Add a GET route to app at path /user/:id. Use an async function with parameters req and res. Inside, use a try/catch block. In try, await getUserById(req.params.id) and send the user data as JSON with res.json(user). In catch, send a 404 status with JSON containing { error: error.message }.

Express

const express = require('express');
const app = express();
const users = {
  1: { name: 'Alice' },
  2: { name: 'Bob' }
};

const delay = 1000;

async function getUserById(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (users[id]) {
        resolve(users[id]);
      } else {
        reject(new Error('User not found'));
      }
    }, delay);
  });
}

// Your code here

Hint

Use app.get with async function. Use try/catch to await getUserById. Send JSON response or error with status 404.

Practice

1. What is the main reason to use try/catch blocks inside async route handlers in Express?

easy

A. To automatically retry failed requests

B. To catch errors from asynchronous code and pass them to Express error handlers

C. To make the route handler run faster

D. To prevent the server from starting

Solution

1. Step 1: Understand async errors in Express routes

   Async functions can throw errors that are not caught automatically by Express, so we need to catch them manually.

2. Step 2: Use try/catch to handle errors

   Wrapping async code in try/catch allows catching errors and passing them to Express with next(error).

3. Final Answer:

   To catch errors from asynchronous code and pass them to Express error handlers -> Option B

4. Quick Check:

   try/catch in async routes = catch async errors [OK]

Hint: Use try/catch to catch async errors and call next(error) [OK]

Common Mistakes:

• Ignoring errors in async functions
• Not calling next(error) inside catch
• Assuming Express catches async errors automatically

2. Which of the following is the correct syntax to pass an error to the next middleware in an async Express route?

easy

A. res.send(error)

B. throw error

C. return error

D. next(error)

Solution

1. Step 1: Identify how Express handles errors

   Express expects errors to be passed to the next middleware using next(error).

2. Step 2: Confirm correct syntax in async routes

   Inside a catch block, calling next(error) forwards the error to the error handler middleware.

3. Final Answer:

   next(error) -> Option D

4. Quick Check:

   Pass errors with next(error) [OK]

Hint: Use next(error) to forward errors in Express [OK]

Common Mistakes:

• Using throw instead of next(error) inside async catch
• Returning error instead of passing to next
• Sending error directly with res.send inside catch

3. Consider this Express route handler:

app.get('/data', async (req, res, next) => {
  try {
    const result = await fetchData();
    res.json(result);
  } catch (error) {
    next(error);
  }
});

What happens if fetchData() throws an error?

medium

A. The error is caught and passed to the next error handler middleware

B. The server crashes immediately

C. The request hangs without response

D. The error is ignored and response is sent anyway

Solution

1. Step 1: Analyze the try/catch block

   If fetchData() throws, the catch block runs and calls next(error).

2. Step 2: Understand Express error flow

   Calling next(error) sends the error to Express error handler middleware, preventing crashes or hanging.

3. Final Answer:

   The error is caught and passed to the next error handler middleware -> Option A

4. Quick Check:

   Errors in try/catch + next(error) = handled error [OK]

Hint: Errors in async try/catch go to next(error) middleware [OK]

Common Mistakes:

• Assuming server crashes on async error
• Thinking response is sent despite error
• Not using next(error) to handle errors

4. Identify the error in this async Express route handler:

app.get('/user', async (req, res, next) => {
  const user = await getUser();
  res.json(user);
});

What is the problem with this code regarding error handling?

medium

A. It sends response twice

B. It incorrectly uses next() inside the route

C. It lacks a try/catch block to handle errors from the async function

D. It uses synchronous code inside async function

Solution

1. Step 1: Check for error handling in async code

   The async function getUser() might throw errors, but no try/catch is used.

2. Step 2: Understand Express error propagation

   Without try/catch and calling next(error), errors will not be handled properly and may crash the server.

3. Final Answer:

   It lacks a try/catch block to handle errors from the async function -> Option C

4. Quick Check:

   Async routes need try/catch for error handling [OK]

Hint: Always wrap async code in try/catch to handle errors [OK]

Common Mistakes:

• Omitting try/catch in async route handlers
• Expecting Express to catch async errors automatically
• Not calling next(error) inside catch

5. You want to create a centralized error handler middleware in Express that catches all errors passed by next(error). Which of the following is the correct way to define this middleware?

hard

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

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

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

D. app.use((err, req, res) => { res.json({ error: err }); });

Solution

1. Step 1: Recall Express error handler signature

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

2. Step 2: Check each option for correct signature and response

   app.use((err, req, res, next) => { res.status(500).json({ message: err.message }); }); uses all four parameters and sends JSON with error message and status 500, which is correct.

3. Final Answer:

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

4. Quick Check:

   Error handler middleware = 4 params + send error response [OK]

Hint: Error middleware needs 4 params: err, req, res, next [OK]

Common Mistakes:

• Missing the 'next' parameter in error middleware
• Using app.get instead of app.use for error handler
• Not setting status code in error response