Async error handling in routes in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when an async route throws an error without next()?

Consider this Express route handler using async/await:

app.get('/data', async (req, res) => {
  const data = await fetchData();
  if (!data) throw new Error('No data found');
  res.json(data);
});

What will Express do if fetchData() returns null causing the error to be thrown?

A The request will hang and eventually time out without a response.

B The server will crash because the error is unhandled.

C Express will catch the error and send a 500 response automatically.

D Express will send a 404 Not Found response.

💡 Hint

Think about how Express handles errors in async functions without calling next().

Express does not automatically catch errors thrown inside async route handlers unless the error is passed to next(). Without error handling middleware or calling next(error), the request hangs.

📝 Syntax

intermediate

Which option correctly passes async errors to Express error handler?

Given an async route, which code snippet correctly forwards errors to Express's error middleware?

A

app.get('/user', async (req, res, next) => {
  try {
    const user = await getUser();
    if (!user) throw new Error('User not found');
    res.json(user);
  } catch (err) {
    next(err);
  }
});

B

app.get('/user', (req, res, next) => {
  getUser().then(user => {
    if (!user) throw new Error('User not found');
    res.json(user);
  }).catch(next);
});

C

app.get('/user', async (req, res, next) => {
  const user = await getUser();
  if (!user) throw new Error('User not found');
  res.json(user);
});

D

app.get('/user', async (req, res) => {
  try {
    const user = await getUser();
    if (!user) throw new Error('User not found');
    res.json(user);
  } catch (err) {
    res.status(500).send(err.message);
  }
});

💡 Hint

Look for the option that uses next(err) inside a try/catch block.

Option A correctly catches errors in async code and passes them to Express's error handler by calling next(err). Option A uses promises but is not async/await. Option A handles error but sends response directly, bypassing error middleware. Option A throws error without catching.

🔧 Debug

advanced

Why does this async error handler not catch errors?

Examine this Express route:

app.get('/items', async (req, res, next) => {
  fetchItems().then(items => {
    if (!items) throw new Error('No items');
    res.json(items);
  });
});

Why won't errors thrown inside then() be caught by Express's error handler?

A Because Express only catches errors thrown synchronously, not inside promises.

B Because the async function does not await the promise, errors inside then() are unhandled.

C Because the route handler is missing the next parameter.

D Because fetchItems() is not returning a promise.

💡 Hint

Consider how async functions and promises interact with error propagation.

The async function returns immediately without awaiting fetchItems(). Errors inside the then() callback are not caught by Express because the promise chain is not awaited or handled with catch(next).

🧠 Conceptual

advanced

What is the benefit of using a wrapper function for async route handlers?

Why do many Express apps use a wrapper like const wrap = fn => (req, res, next) => fn(req, res, next).catch(next); around async route handlers?

A It converts async functions into synchronous ones.

B It improves performance by caching route responses.

C It prevents the route handler from running multiple times.

D It automatically catches errors from async functions and forwards them to Express error middleware.

💡 Hint

Think about how error handling is simplified with this pattern.

The wrapper catches any rejected promise from the async function and calls next(error), so you don't need try/catch in every route handler.

❓ state_output

expert

What is the response status and body when an async route calls next() with an error?

Given this Express setup:

app.get('/fail', async (req, res, next) => {
  try {
    await Promise.reject(new Error('Failed'));
  } catch (err) {
    next(err);
  }
});

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

What will the client receive when requesting /fail?

A Status 500 with empty response body

B Status 200 with JSON body {"error":"Failed"}

C Status 400 with JSON body {"error":"Failed"}

D No response, request times out

💡 Hint

Look at the error middleware and the status code it sets.

The error middleware sets status 400 and sends JSON with the error message. Calling next(err) triggers this middleware.