Router level middleware in Express - Step-by-Step Execution

Concept Flow - Router-level middleware

Request comes in

↓

Router receives request

↓

Router-level middleware runs

↓

Middleware calls next()

↓

Router handles route or passes to next middleware

↓

Response sent or next middleware runs

When a request hits a router, router-level middleware runs first. It can modify the request or response, then calls next() to continue to route handlers or other middleware.

Execution Sample

Express

const express = require('express');
const router = express.Router();

router.use((req, res, next) => {
  console.log('Middleware runs');
  next();
});

router.get('/', (req, res) => res.send('Hello'));

module.exports = router;

This code sets up router-level middleware that logs a message before handling a GET request.

Execution Table

Step	Action	Middleware Called	next() Called	Route Handler Called	Output
1	Request to '/' received by router	No	No	No	No output yet
2	Router-level middleware runs	Yes	Yes	No	Logs 'Middleware runs'
3	Route handler for '/' runs	No	No	Yes	Sends 'Hello' response
4	Response sent to client	No	No	No	Client receives 'Hello'

💡 Response sent after route handler completes, middleware chain ends

Variable Tracker

Variable	Start	After Middleware	After Route Handler	Final
req.url	/	/	/	/
res.headersSent	false	false	true	true
middlewareCalled	false	true	true	true
responseSent	false	false	true	true

Key Moments - 2 Insights

Why does the route handler run only after middleware calls next()?

Because in the execution_table row 2, middleware calls next(), which tells Express to continue to the next function, the route handler.

What happens if middleware does not call next()?

The request stops at middleware and the route handler never runs, so no response is sent (see execution_table step 2 importance of next()).

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the middleware log 'Middleware runs'?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Check the 'Middleware Called' and 'Output' columns in execution_table row 2

According to variable_tracker, when does res.headersSent become true?

A After middleware runs

B After route handler runs

C At the start

D Never

💡 Hint

Look at 'res.headersSent' values in variable_tracker after route handler

If middleware did not call next(), what would happen to the route handler?

A It would run anyway

B It would run before middleware

C It would not run

D It would run twice

💡 Hint

Refer to key_moments explanation about next() importance

Concept Snapshot

Router-level middleware runs when a request hits a router.
It can modify req or res, then must call next() to continue.
If next() is not called, request stops and route handlers don't run.
Use router.use() to add middleware to a router.
Middleware runs before route handlers inside that router.

Full Transcript

Router-level middleware in Express runs when a request is received by a router. The middleware function can do tasks like logging or modifying the request. It must call next() to pass control to the next middleware or route handler. If next() is not called, the request stops and no response is sent. After middleware calls next(), the router's route handler runs and sends the response. Variables like req.url stay the same, while res.headersSent changes to true after the response is sent. This flow ensures middleware can prepare or check requests before routes handle them.

Practice

1. What is the main purpose of router-level middleware in Express?

easy

A. To replace the main app middleware completely

B. To run middleware only for routes defined in a specific router

C. To handle errors globally across all routers

D. To serve static files from a directory

Solution

1. Step 1: Understand router-level middleware scope

   Router-level middleware runs only for routes defined in that router, not the entire app.

2. Step 2: Compare with other middleware types

   Main app middleware runs for all routes, error middleware handles errors, static middleware serves files. Router middleware is specific to router routes.

3. Final Answer:

   To run middleware only for routes defined in a specific router -> Option B

4. Quick Check:

   Router middleware scope = specific router routes [OK]

Hint: Router middleware affects only its router's routes [OK]

Common Mistakes:

• Confusing router middleware with app-level middleware
• Thinking router middleware handles errors globally
• Assuming router middleware serves static files

2. Which of the following is the correct way to add middleware to an Express router?

easy

A. router.middleware(function(req, res, next) { next(); });

B. router.add(function(req, res, next) { next(); });

C. app.useRouter(function(req, res, next) { next(); });

D. router.use(function(req, res, next) { next(); });

Solution

1. Step 1: Recall Express router middleware syntax

   The correct method to add middleware to a router is router.use().

2. Step 2: Check other options for validity

   router.middleware, app.useRouter, and router.add are not valid Express methods.

3. Final Answer:

   router.use(function(req, res, next) { next(); }); -> Option D

4. Quick Check:

   Use router.use() to add middleware [OK]

Hint: Use router.use() to add middleware to routers [OK]

Common Mistakes:

• Using non-existent methods like router.middleware or router.add
• Confusing app.useRouter with router.use
• Forgetting to call next() inside middleware

3. Consider this Express router code:

const express = require('express');
const router = express.Router();

router.use((req, res, next) => {
  console.log('Middleware A');
  next();
});

router.get('/test', (req, res) => {
  res.send('Hello from test');
});

module.exports = router;

What will be printed in the console when a client requests /test on this router?

medium

A. Middleware A

B. Hello from test

C. Middleware A and then Hello from test

D. Nothing will be printed

Solution

1. Step 1: Identify middleware behavior on route request

   The router middleware logs 'Middleware A' and calls next(), so it runs before the route handler.

2. Step 2: Understand console output vs response

   The console.log prints 'Middleware A' to the server console. The response sends 'Hello from test' to the client but does not print to console.

3. Final Answer:

   Middleware A -> Option A

4. Quick Check:

   Middleware console.log prints 'Middleware A' [OK]

Hint: Middleware logs to console, route sends response [OK]

Common Mistakes:

• Confusing console output with response content
• Expecting both console and response text in console
• Ignoring the next() call in middleware

4. Given this router code:

const router = require('express').Router();

router.use((req, res, next) => {
  console.log('First middleware');
  next();
});

router.get('/hello', (req, res) => {
  res.send('Hello World');
});

router.use((req, res) => {
});

What is the problem with this code?

medium

A. The last middleware does not call next(), causing requests to hang

B. The last middleware is missing next() and will cause 404 for all routes

C. The last middleware will never run because it is after a route handler

D. The last middleware should have 4 parameters to handle errors

Solution

1. Step 1: Analyze middleware execution order

   Middleware and routes execute in the order defined. First middleware runs for all requests and calls next().

2. Step 2: Trace unmatched route behavior

   For unmatched routes like /foo: first middleware calls next(), /hello route doesn't match so next(), last middleware runs but does nothing--no response and no next() call.

3. Step 3: Identify the consequence

   The request pipeline stops without a response, causing the client request to hang indefinitely.

4. Final Answer:

   The last middleware does not call next(), causing requests to hang -> Option A

5. Quick Check:

   No response + no next() = request hangs [OK]

Hint: Every middleware must either respond or call next() [OK]

Common Mistakes:

• Thinking empty catch-all middleware is harmless
• Forgetting unmatched routes reach the last middleware
• Assuming the router automatically handles 404s

5. You want to apply a logging middleware only to routes under /api in your Express app. You create a router and add middleware like this:

const express = require('express');
const app = express();
const apiRouter = express.Router();

apiRouter.use((req, res, next) => {
  console.log('API request:', req.method, req.url);
  next();
});

apiRouter.get('/users', (req, res) => {
  res.send('User list');
});

app.use('/api', apiRouter);

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

What will happen when a client requests /api/users and /?

hard

A. Logging middleware does not run for any route

B. Logging middleware runs for both /api/users and /

C. Logging middleware runs only for /api/users, not for /

D. Logging middleware runs only for / route

Solution

1. Step 1: Understand router mounting path

   The router is mounted at '/api', so its middleware runs only for routes starting with '/api'.

2. Step 2: Analyze requests

   Request to '/api/users' triggers the router middleware and route handler. Request to '/' goes directly to app.get('/') and skips router middleware.

3. Final Answer:

   Logging middleware runs only for /api/users, not for / -> Option C

4. Quick Check:

   Router middleware runs only on mounted path routes [OK]

Hint: Router middleware runs only on its mounted path routes [OK]

Common Mistakes:

• Assuming router middleware runs for all app routes
• Confusing app-level and router-level middleware scopes
• Expecting middleware to run for '/' when mounted on '/api'