Async middleware wrapper in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this async middleware wrapper?

Consider this Express async middleware wrapper function. What will be the response if the wrapped async function throws an error?

Express

const asyncWrapper = fn => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

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

A The server crashes with an unhandled promise rejection error.

B The request hangs indefinitely with no response.

C The client receives a 200 OK response with an empty body.

D The error is passed to Express error handling middleware via next(), resulting in a 500 response.

💡 Hint

Think about how Promise.catch(next) works in Express middleware.

The asyncWrapper catches any error thrown in the async function and passes it to next(), which triggers Express's error handling middleware. This prevents the server from crashing and sends a 500 error response.

📝 Syntax

intermediate

Which option correctly defines an async middleware wrapper in Express?

Select the option that correctly implements an async middleware wrapper function for Express.

A const asyncWrapper = fn => async (req, res, next) => { await fn(req, res, next).catch(next); };

B const asyncWrapper = fn => (req, res, next) => { Promise.resolve(fn(req, res, next)).catch(next); };

C const asyncWrapper = fn => (req, res, next) => { try { fn(req, res, next); } catch (e) { next(e); } };

D const asyncWrapper = fn => (req, res, next) => { fn(req, res, next).catch(next); };

💡 Hint

Remember that async functions return promises and errors must be caught asynchronously.

Option B correctly wraps the async function call in Promise.resolve and catches errors to pass to next(). Option B misses Promise.resolve and may not catch non-promise errors. Option B misuses await with catch. Option B uses try/catch but does not handle async errors properly.

🔧 Debug

advanced

Why does this async middleware wrapper fail to catch errors?

Identify the problem in this async middleware wrapper code that causes errors thrown in the async function not to be caught.

Express

const asyncWrapper = fn => (req, res, next) => {
  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

A The try/catch block does not catch errors from the async function because it returns a promise and errors happen asynchronously.

B The next function is not called correctly inside the catch block.

C The wrapper should use setTimeout to catch errors asynchronously.

D The async function is not awaited, causing the wrapper to miss synchronous errors.

💡 Hint

Think about how errors in promises behave with try/catch.

Errors thrown inside async functions are wrapped in promises and happen asynchronously. The try/catch block only catches synchronous errors, so it misses async errors. The wrapper must catch promise rejections instead.

❓ state_output

advanced

What is the value of 'errorHandled' after this middleware runs?

Given this async middleware wrapper and route, what will be the value of the variable 'errorHandled' after a request triggers an error?

Express

let errorHandled = false;

const asyncWrapper = fn => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(err => {
    errorHandled = true;
    next(err);
  });
};

app.get('/fail', asyncWrapper(async (req, res) => {
  throw new Error('Fail');
}));

// Simulate a request to '/fail' and error handling middleware sets errorHandled to true

A true

B false

C undefined

D null

💡 Hint

The catch block sets errorHandled to true when an error occurs.

When the async function throws, the catch block runs, setting errorHandled to true before calling next with the error.

🧠 Conceptual

expert

Which statement best explains why async middleware wrappers are important in Express?

Choose the best explanation for why wrapping async middleware functions with an error-catching wrapper is necessary in Express applications.

A Async middleware wrappers improve performance by running middleware functions in parallel.

B Wrapping async middleware automatically converts them into synchronous functions, simplifying error handling.

C Express does not natively handle rejected promises in async middleware, so errors must be caught and passed to next() to avoid unhandled promise rejections and server crashes.

D Async middleware wrappers are only needed when using Express with TypeScript.

💡 Hint

Consider how Express handles errors from promises by default.

Express does not catch rejected promises from async middleware automatically. Without a wrapper, unhandled promise rejections can crash the server or cause silent failures. Wrapping async middleware ensures errors are forwarded to Express error handlers.

Practice

1. What is the main purpose of using an async middleware wrapper in Express?

easy

A. To automatically catch errors from async route handlers without try-catch blocks

B. To convert synchronous middleware into asynchronous functions

C. To speed up the execution of middleware functions

D. To log all requests automatically

Solution

1. Step 1: Understand async middleware challenges

   Async route handlers can throw errors that need to be caught to avoid crashing the app.

2. Step 2: Role of async middleware wrapper

   The wrapper automatically catches errors from async functions and passes them to Express error handlers, avoiding manual try-catch blocks.

3. Final Answer:

   To automatically catch errors from async route handlers without try-catch blocks -> Option A

4. Quick Check:

   Async error catching = To automatically catch errors from async route handlers without try-catch blocks [OK]

Hint: Async wrapper catches errors, no manual try-catch needed [OK]

Common Mistakes:

• Thinking it converts sync to async
• Assuming it improves speed
• Confusing it with logging middleware

2. Which of the following is the correct syntax to create an async middleware wrapper function in Express?

easy

A. const wrap = fn => (req, res, next) => { try { fn(req, res, next); } catch (err) { next(err); } };

B. const wrap = fn => (req, res, next) => fn(req, res, next).catch(next);

C. const wrap = fn => async (req, res, next) => { await fn(req, res, next); };

D. const wrap = fn => (req, res, next) => { fn(req, res, next).then(next); };

Solution

1. Step 1: Understand async wrapper pattern

   The wrapper returns a function that calls the async function and catches errors with .catch(next).

2. Step 2: Check each option

   const wrap = fn => (req, res, next) => { try { fn(req, res, next); } catch (err) { next(err); } }; uses try-catch but misses async/await and won't catch async errors properly. const wrap = fn => (req, res, next) => fn(req, res, next).catch(next); correctly returns a function that calls fn and catches errors with .catch(next). const wrap = fn => async (req, res, next) => { await fn(req, res, next); }; awaits but does not catch errors. const wrap = fn => (req, res, next) => { fn(req, res, next).then(next); }; calls then(next) which is incorrect for error handling.

3. Final Answer:

   const wrap = fn => (req, res, next) => fn(req, res, next).catch(next); -> Option B

4. Quick Check:

   Async wrapper uses .catch(next) = const wrap = fn => (req, res, next) => fn(req, res, next).catch(next); [OK]

Hint: Async wrapper uses .catch(next) to handle errors [OK]

Common Mistakes:

• Using try-catch without async/await
• Not returning the wrapped function
• Misusing .then instead of .catch

3. Given the code below, what will be the output when a GET request is made to /data?

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

const wrap = fn => (req, res, next) => fn(req, res, next).catch(next);

app.get('/data', wrap(async (req, res) => {
  const data = await Promise.resolve('Hello World');
  res.send(data);
}));

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

app.listen(3000);

medium

A. Nothing, request hangs

B. Error caught

C. Hello World

D. SyntaxError

Solution

1. Step 1: Analyze the async route handler

   The async function resolves 'Hello World' and sends it as response.

2. Step 2: Check error handling

   No error occurs, so the error middleware is not triggered. The wrapper ensures errors would be caught if any.

3. Final Answer:

   Hello World -> Option C

4. Quick Check:

   Successful async response = Hello World [OK]

Hint: No error means normal response sent [OK]

Common Mistakes:

• Assuming error middleware always runs
• Thinking async wrapper changes output
• Confusing promise resolution with error

4. Identify the error in the following async middleware wrapper code:

const wrap = fn => (req, res, next) => {
  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

medium

A. fn should not receive next as argument

B. Using try-catch inside middleware is not allowed

C. next(err) should be replaced with throw err

D. Missing async keyword and await, so async errors are not caught

Solution

1. Step 1: Understand async error handling

   Async functions return promises; errors inside them are caught via .catch or await with try-catch.

2. Step 2: Analyze the wrapper code

   The wrapper calls fn without await or .catch, so errors inside async fn are not caught by try-catch.

3. Final Answer:

   Missing async keyword and await, so async errors are not caught -> Option D

4. Quick Check:

   Async errors need await or .catch = Missing async keyword and await, so async errors are not caught [OK]

Hint: Try-catch alone misses async errors without await [OK]

Common Mistakes:

• Thinking try-catch works without await
• Confusing next(err) with throw
• Believing next should not be passed

5. You want to create an async middleware wrapper that also logs the error message before passing it to Express error handler. Which of the following implementations correctly achieves this?

hard

A. const wrap = fn => (req, res, next) => fn(req, res, next).catch(err => { console.error(err.message); next(err); });

B. const wrap = fn => async (req, res, next) => { try { await fn(req, res, next); } catch (err) { next(err.message); } };

C. const wrap = fn => (req, res, next) => { fn(req, res, next).then(() => {}, err => { console.log(err); }); };

D. const wrap = fn => (req, res, next) => { try { fn(req, res, next); } catch (err) { console.error(err); next(err); } };

Solution

1. Step 1: Understand error logging and forwarding

   We want to log the error message and then pass the full error to next() for Express to handle.

2. Step 2: Evaluate each option

   const wrap = fn => (req, res, next) => fn(req, res, next).catch(err => { console.error(err.message); next(err); }); uses .catch to log err.message and calls next(err) correctly. const wrap = fn => async (req, res, next) => { try { await fn(req, res, next); } catch (err) { next(err.message); } }; passes err.message to next, which breaks error handling. const wrap = fn => (req, res, next) => { fn(req, res, next).then(() => {}, err => { console.log(err); }); }; logs error but does not call next, so error is not forwarded. const wrap = fn => (req, res, next) => { try { fn(req, res, next); } catch (err) { console.error(err); next(err); } }; uses try-catch without async/await, so async errors may be missed.

3. Final Answer:

   const wrap = fn => (req, res, next) => fn(req, res, next).catch(err => { console.error(err.message); next(err); }); -> Option A

4. Quick Check:

   Log then next(err) in .catch = const wrap = fn => (req, res, next) => fn(req, res, next).catch(err => { console.error(err.message); next(err); }); [OK]

Hint: Log error inside .catch, then call next(err) [OK]

Common Mistakes:

• Passing err.message to next instead of err
• Not forwarding error to next
• Using try-catch without async/await