Middleware factory pattern in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this middleware factory produce?

Consider this Express middleware factory function. What will be the output when a request hits the route using this middleware?

Express

function greetMiddleware(greeting) {
  return function(req, res, next) {
    res.locals.message = `${greeting}, user!`;
    next();
  };
}

app.use(greetMiddleware('Hello'));
app.get('/', (req, res) => {
  res.send(res.locals.message);
});

A The response will be 'Hello, user!'

B The response will be 'greeting, user!'

C The server will crash with an error

D The response will be undefined

💡 Hint

Think about how the factory function uses the greeting parameter inside the returned middleware.

The factory function greetMiddleware takes a greeting string and returns a middleware function. This middleware sets res.locals.message to the greeting plus ', user!'. When the route handler sends res.locals.message, it outputs 'Hello, user!'.

📝 Syntax

intermediate

Identify the syntax error in this middleware factory

Which option correctly fixes the syntax error in this middleware factory code?

Express

function authMiddleware(role) {
  return (req, res, next) => {
    if(req.user.role !== role) {
      res.status(403).send('Forbidden');
    } else {
      next()
    }
  }
}

A No syntax error, code is correct

B Add curly braces around the else block

C Add a missing closing parenthesis after next()

D Add a semicolon after next() call

💡 Hint

Check if arrow functions require braces or semicolons in this context.

The arrow function syntax is valid without semicolons after next() and the else block is correctly formed. No syntax error exists.

🔧 Debug

advanced

Why does this middleware factory not work as expected?

This middleware factory is supposed to log a custom message. Why does it always log 'undefined'?

Express

function logMessage(msg) {
  return function(req, res, next) {
    console.log(message);
    next();
  };
}

app.use(logMessage('Request received'));

A The middleware does not call next(), so it hangs

B The variable 'message' is not defined; should use 'msg' instead

C The factory function does not return a function

D The console.log syntax is incorrect

💡 Hint

Check variable names inside the returned middleware function.

The middleware tries to log 'message' which is undefined. The parameter is named 'msg', so it should log 'msg'.

❓ state_output

advanced

What is the value of res.locals after this middleware runs?

Given this middleware factory and usage, what will be the value of res.locals.user after the middleware runs?

Express

function userMiddleware(name) {
  return (req, res, next) => {
    res.locals.user = { name };
    next();
  };
}

app.use(userMiddleware('Alice'));

app.get('/', (req, res) => {
  res.json(res.locals.user);
});

A {"user":"Alice"}

B {}

C {"name":"Alice"}

D undefined

💡 Hint

Look at how res.locals.user is assigned inside the middleware.

The middleware sets res.locals.user to an object with a name property equal to the passed name. So res.locals.user is { name: 'Alice' }.

🧠 Conceptual

expert

Why use a middleware factory instead of a simple middleware?

Which reason best explains why middleware factories are useful in Express?

A They replace the need for route handlers entirely

B They improve server performance by caching middleware

C They automatically handle errors without extra code

D They allow creating middleware with custom parameters for reuse

💡 Hint

Think about how you can customize middleware behavior.

Middleware factories let you create middleware functions that can be customized with parameters, making them reusable with different settings.

Practice

1. What is the main purpose of the middleware factory pattern in Express?

easy

A. To automatically handle errors in middleware

B. To create middleware functions that can be customized with different settings

C. To replace the need for routing in Express

D. To speed up server response time by caching

Solution

1. Step 1: Understand middleware factory pattern concept

   The middleware factory pattern is used to create middleware functions that accept parameters to customize their behavior.

2. Step 2: Compare options with the concept

   Only To create middleware functions that can be customized with different settings correctly describes creating customizable middleware functions. Other options describe unrelated features.

3. Final Answer:

   To create middleware functions that can be customized with different settings -> Option B

4. Quick Check:

   Middleware factory pattern = customizable middleware [OK]

Hint: Middleware factory = function returning middleware with parameters [OK]

Common Mistakes:

• Thinking it automatically handles errors
• Confusing with routing or caching
• Believing it speeds response time directly

2. Which of the following is the correct syntax for a middleware factory function in Express?

easy

A. function logger() { /* middleware code */ }

B. function logger(req, res, next) { return function(level) { /* middleware code */ } }

C. function logger(level) { return function(req, res, next) { /* middleware code */ } }

D. function logger(level, req, res, next) { /* middleware code */ }

Solution

1. Step 1: Identify middleware factory structure

   A middleware factory is a function that takes parameters and returns a middleware function with signature (req, res, next).

2. Step 2: Match syntax to this pattern

   function logger(level) { return function(req, res, next) { /* middleware code */ } } matches this: it takes 'level' and returns a function with (req, res, next). Others do not follow this pattern.

3. Final Answer:

   function logger(level) { return function(req, res, next) { /* middleware code */ } } -> Option C

4. Quick Check:

   Factory returns middleware function = function logger(level) { return function(req, res, next) { /* middleware code */ } } [OK]

Hint: Factory takes params, returns (req, res, next) function [OK]

Common Mistakes:

• Placing req, res, next in factory parameters
• Not returning a middleware function
• Confusing middleware and factory signatures

3. Given the middleware factory below, what will be logged when a request is made?

function greet(name) {
  return function(req, res, next) {
    console.log(`Hello, ${name}!`);
    next();
  };
}

app.use(greet('Alice'));

medium

A. Hello, Alice!

B. Hello, undefined!

C. Hello, name!

D. No output, middleware does not log

Solution

1. Step 1: Understand middleware factory usage

   The factory greet('Alice') returns a middleware that logs 'Hello, Alice!'.

2. Step 2: Predict middleware behavior on request

   When a request comes, the middleware logs the greeting with the name 'Alice'.

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   Factory param used in log = Hello, Alice! [OK]

Hint: Factory param appears in log output [OK]

Common Mistakes:

• Expecting 'undefined' if factory param missing
• Thinking middleware does not log
• Confusing variable name with string literal

4. Identify the error in this middleware factory code:

function checkRole(role) {
  return function(req, res, next) {
    if(req.user.role === role) {
      next;
    } else {
      res.status(403).send('Forbidden');
    }
  };
}

medium

A. res.status should be res.send

B. Incorrect comparison operator in if statement

C. Middleware factory should not return a function

D. Missing parentheses when calling next()

Solution

1. Step 1: Review middleware function call

   Inside middleware, next must be called as a function: next().

2. Step 2: Identify the error

   The code uses 'next;' instead of 'next();', so middleware will not proceed correctly.

3. Final Answer:

   Missing parentheses when calling next() -> Option D

4. Quick Check:

   Call next() with parentheses [OK]

Hint: Always call next() as a function, not just next [OK]

Common Mistakes:

• Writing next without parentheses
• Confusing status and send methods
• Thinking factory should not return a function

5. You want to create a middleware factory that limits requests based on a max count per user. Which approach correctly applies the middleware factory pattern to achieve this?

hard

A. function rateLimiter(maxRequests) {
const counts = new Map();
return function(req, res, next) {
const user = req.user.id;
counts.set(user, (counts.get(user) || 0) + 1);
if(counts.get(user) > maxRequests) {
res.status(429).send('Too many requests');
} else {
next();
}
};
}

B. function rateLimiter(req, res, next, maxRequests) {
// logic here
}

C. function rateLimiter(maxRequests) {
return function(req, res) {
// missing next call
};
}

D. function rateLimiter() {
// no parameters, fixed limit
}

Solution

1. Step 1: Understand the requirement for customizable limit

   The middleware must accept maxRequests as a parameter to customize the limit.

2. Step 2: Check which option correctly returns middleware with (req, res, next) and uses maxRequests

   function rateLimiter(maxRequests) { const counts = new Map(); return function(req, res, next) { const user = req.user.id; counts.set(user, (counts.get(user) || 0) + 1); if(counts.get(user) > maxRequests) { res.status(429).send('Too many requests'); } else { next(); } }; } correctly implements a factory that returns middleware tracking counts and enforcing maxRequests, calling next() properly.

3. Final Answer:

   function rateLimiter(maxRequests) { const counts = new Map(); return function(req, res, next) { const user = req.user.id; counts.set(user, (counts.get(user) || 0) + 1); if(counts.get(user) > maxRequests) { res.status(429).send('Too many requests'); } else { next(); } }; } -> Option A

4. Quick Check:

   Factory with param returns middleware calling next() = function rateLimiter(maxRequests) { const counts = new Map(); return function(req, res, next) { const user = req.user.id; counts.set(user, (counts.get(user) || 0) + 1); if(counts.get(user) > maxRequests) { res.status(429).send('Too many requests'); } else { next(); } }; } [OK]

Hint: Factory takes limit param, returns middleware calling next() [OK]

Common Mistakes:

• Putting next as a factory parameter
• Not calling next() in middleware
• Not using maxRequests parameter