Functional middleware in NestJS - Step-by-Step Execution

Concept Flow - Functional middleware

Request Received

↓

Middleware Function Called

↓

Middleware Logic Executes

↓

Call next() to pass control

↓

Next Middleware or Handler Executes

↓

Response Sent

The request passes through the functional middleware which runs its logic and calls next() to continue the flow.

Execution Sample

NestJS

function logger(req, res, next) {
  console.log(`Request to ${req.url}`);
  next();
}

Logs the request URL and passes control to the next middleware or handler.

Execution Table

Step	Action	Request URL	Console Output	next() Called	Next Step
1	Middleware function invoked	/api/data		No	Middleware logic runs
2	Log request URL	/api/data	Request to /api/data	No	Middleware logic continues
3	Call next()	/api/data	Request to /api/data	Yes	Next middleware or handler runs
4	Next middleware or handler executes	/api/data		Yes	Response sent
5	Response sent to client	/api/data		Yes	End

💡 Middleware calls next(), passing control to next middleware or handler, ending middleware execution.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
req.url		/api/data	/api/data	/api/data	/api/data
console output			Request to /api/data	Request to /api/data	Request to /api/data
next() called	No	No	No	Yes	Yes

Key Moments - 2 Insights

Why do we need to call next() inside the middleware?

Calling next() passes control to the next middleware or route handler. Without it, the request would hang and never reach the handler, as shown in execution_table step 3.

What happens if we don't call next()?

The request stops at the middleware and the client waits forever. The execution_table shows next() called as 'No' means no further processing.

Visual Quiz - 3 Questions

Look at the execution_table, what is the console output at step 2?

A "Request received"

B "Middleware started"

C "Request to /api/data"

D "No output"

💡 Hint

Check the 'Console Output' column at step 2 in the execution_table.

At which step is next() called to continue processing?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'next() Called' column in the execution_table.

If next() was not called, what would happen to the request?

A It would hang and never reach the handler

B It would immediately send a response

C It would continue to the next middleware

D It would throw an error automatically

💡 Hint

Refer to the key_moments section and execution_table exit_note.

Concept Snapshot

Functional middleware in NestJS is a function with (req, res, next).
It runs code, then calls next() to pass control.
Without next(), request processing stops.
Use middleware to log, modify requests, or check auth.
Always call next() unless sending a response directly.

Full Transcript

Functional middleware in NestJS is a simple function that takes three arguments: request, response, and next. When a request comes in, NestJS calls this middleware function. Inside, you can run any code you want, like logging the request URL. After your code runs, you must call next() to pass control to the next middleware or the route handler. If you forget to call next(), the request will hang and never reach the handler. This flow ensures middleware can process requests step-by-step before the final response is sent.

Practice

1. What is the main purpose of functional middleware in NestJS?

easy

A. To run code before the route handler to modify requests or add features

B. To define database models for the application

C. To create UI components for the frontend

D. To compile TypeScript code into JavaScript

Solution

1. Step 1: Understand middleware role

   Middleware runs before route handlers to process requests or add features like logging or authentication.

2. Step 2: Identify correct purpose

   Options A, B, and D relate to other parts of development, not middleware.

3. Final Answer:

   To run code before the route handler to modify requests or add features -> Option A

4. Quick Check:

   Middleware runs before routes = C [OK]

Hint: Middleware runs before routes to add features [OK]

Common Mistakes:

• Confusing middleware with database models
• Thinking middleware creates UI components
• Believing middleware compiles code

2. Which of the following is the correct way to define a functional middleware in NestJS?

easy

A. function logger(req, res) { console.log(req.url); }

B. class Logger { log(req, res) { console.log(req.url); } }

C. const logger = () => { console.log('log'); }

D. function logger(req, res, next) { console.log(req.url); next(); }

Solution

1. Step 1: Check middleware signature

   Functional middleware must accept (req, res, next) and call next() to continue.

2. Step 2: Validate options

   function logger(req, res, next) { console.log(req.url); next(); } matches this pattern. class Logger { log(req, res) { console.log(req.url); } } is a class, not functional middleware. const logger = () => { console.log('log'); } lacks parameters and next call. function logger(req, res) { console.log(req.url); } misses next parameter and call.

3. Final Answer:

   function logger(req, res, next) { console.log(req.url); next(); } -> Option D

4. Quick Check:

   Middleware needs (req, res, next) and calls next() [OK]

Hint: Middleware needs (req, res, next) and calls next() [OK]

Common Mistakes:

• Omitting the next parameter
• Not calling next() inside middleware
• Using class instead of function for functional middleware

3. Given this middleware code, what will be logged when a request to '/home' is made?

function logger(req, res, next) {
  console.log('Request URL:', req.url);
  next();
}

medium

A. Request URL: undefined

B. Request URL: /home

C. No output because next() stops logging

D. Error: req.url is not defined

Solution

1. Step 1: Understand req.url property

   In middleware, req.url contains the path of the incoming request, here '/home'.

2. Step 2: Analyze console.log output

   The middleware logs 'Request URL:' followed by req.url, so it prints 'Request URL: /home'.

3. Final Answer:

   Request URL: /home -> Option B

4. Quick Check:

   req.url logs request path = A [OK]

Hint: req.url holds the request path string [OK]

Common Mistakes:

• Assuming next() stops console.log
• Thinking req.url is undefined
• Confusing middleware with route handler output

4. Identify the error in this functional middleware code:

function auth(req, res, next) {
  if (!req.headers.authorization) {
    res.status(401).send('Unauthorized');
  }
  next();
}

medium

A. res.status should be res.sendStatus

B. Missing req parameter in function signature

C. next() is called even after sending response, causing errors

D. Authorization header check is incorrect

Solution

1. Step 1: Analyze flow after sending response

   If authorization header is missing, response is sent with 401, but next() is still called, which can cause errors by continuing the request cycle.

2. Step 2: Identify correct fix

   To fix, add return before res.status(401).send(...) to stop execution or call next() only if authorized.

3. Final Answer:

   next() is called even after sending response, causing errors -> Option C

4. Quick Check:

   Call next() only if no response sent [OK]

Hint: Don't call next() after sending response [OK]

Common Mistakes:

• Calling next() after res.send causes errors
• Forgetting to stop middleware after response
• Misusing res.status vs res.sendStatus

5. You want to create a functional middleware that adds a custom header 'X-App-Version' with value '1.0' to every response. Which code correctly implements this?

hard

A. function addVersion(req, res, next) { res.setHeader('X-App-Version', '1.0'); next(); }

B. function addVersion(req, res) { res.setHeader('X-App-Version', '1.0'); }

C. function addVersion(req, res, next) { next(); res.setHeader('X-App-Version', '1.0'); }

D. function addVersion(req, res, next) { req.setHeader('X-App-Version', '1.0'); next(); }

Solution

1. Step 1: Confirm middleware signature and header setting

   Middleware must accept (req, res, next) and call next() after setting headers. res.setHeader is correct method.

2. Step 2: Evaluate options

   function addVersion(req, res, next) { res.setHeader('X-App-Version', '1.0'); next(); } sets header then calls next() correctly. function addVersion(req, res) { res.setHeader('X-App-Version', '1.0'); } misses next parameter and call. function addVersion(req, res, next) { next(); res.setHeader('X-App-Version', '1.0'); } calls next() before setting header, so header may not be sent. function addVersion(req, res, next) { req.setHeader('X-App-Version', '1.0'); next(); } uses req.setHeader which is incorrect because req cannot set response headers.

3. Final Answer:

   function addVersion(req, res, next) { res.setHeader('X-App-Version', '1.0'); next(); } -> Option A

4. Quick Check:

   Set header before next() with correct method [OK]

Hint: Set header before next() using res.setHeader [OK]

Common Mistakes:

• Calling next() before setting headers
• Omitting next parameter or call
• Confusing req and res when setting headers