All 15 Architecture & Design Patterns questions
More in Architecture & Design Patterns
What is the Module pattern in Node.js, and how does it enable encapsulation? How is the Factory pattern commonly applied in Node.js applications, and what problem does it solve? What is the Singleton pattern, and what are the specific risks of using it in a Node.js application? What is Dependency Injection, and how is it typically implemented in Node.js given the language has no built-in DI container? What is the Strategy pattern, and how would you apply it to support multiple payment providers in a Node.js checkout service? What is a layered (n-tier) architecture in a Node.js/Express application, and what are its typical layers? What is the Repository pattern, and how does it help decouple business logic from a specific database technology? What is the Observer pattern, and how does Node.js's EventEmitter class implement it natively? What is Domain-Driven Design (DDD), and how do its concepts of entities, value objects, and aggregates apply to a Node.js codebase? What is a Hexagonal Architecture (Ports and Adapters), and what specific benefit does it provide for a Node.js API?
Advertisement
Back to results for “Architecture”
Node.js › Architecture & Design Patterns

What is the Middleware (Chain of Responsibility) pattern as implemented by Express, and how does the 'next()' function drive it?

Intermediate

Answer

Express middleware implements the Chain of Responsibility pattern: each middleware function receives the request, response, and a 'next' callback, and can either handle the request completely, modify it and pass control to the next function in the chain by calling next(), or short-circuit the chain by sending a response directly -- this lets cross-cutting concerns (authentication, logging, error handling) be composed as small, independent, reorderable functions rather than one large monolithic handler.
app.use((req, res, next) => {
  console.log(`${req.method} ${req.path}`);
  next(); // pass control to the next middleware in the chain
});

app.use((req, res, next) => {
  if (!req.headers.authorization) return res.status(401).end(); // short-circuits the chain
  next();
});
Real-world example An API composes a request-logging middleware, an authentication middleware, and a rate-limiting middleware as three separate, independently testable functions applied in sequence, rather than combining all three concerns into a single large function at the top of every route handler.

Common follow-ups: What happens if a middleware function neither calls next() nor sends a response?;How does error-handling middleware (with four parameters) fit into this same chain-of-responsibility model?

Express & Middleware;Error Handling
All 15 Architecture & Design Patterns questions