Creating middleware in NestJS - Visual Walkthrough

Concept Flow - Creating middleware

Request comes in

↓

Middleware runs

↓

Middleware can modify request/response

↓

Call next() to continue

↓

Controller handles request

↓

Response sent back

Middleware runs when a request arrives, can change request or response, then passes control to the next step.

Execution Sample

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req, res, next) {
    console.log(`Request to: ${req.url}`);
    next();
  }
}

This middleware logs the URL of each incoming request and then passes control to the next handler.

Execution Table

Step	Action	Request URL	Console Output	Next Called	Effect
1	Request arrives	/home		No	Middleware starts
2	Middleware logs URL	/home	Request to: /home	No	Logging happens
3	Middleware calls next()	/home	Request to: /home	Yes	Pass control to controller
4	Controller handles request	/home	Request to: /home	Yes	Response prepared
5	Response sent	/home	Request to: /home	Yes	Client receives response

💡 Middleware calls next(), so request proceeds to controller and response is sent.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
req.url	/home	/home	/home	/home
console output		Request to: /home	Request to: /home	Request to: /home
next called	No	No	Yes	Yes

Key Moments - 2 Insights

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

Calling next() tells NestJS to continue processing the request. Without it, the request stops at middleware and the controller never runs, as shown in execution_table step 3.

Can middleware change the request or response?

Yes, middleware can modify req or res objects before passing control. This is why middleware runs before the controller, as seen in the flow diagram.

Visual Quiz - 3 Questions

Look at the execution table, what is the console output at step 2?

A Request to: /home

B No output yet

C next() called

D Response sent

💡 Hint

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

At which step does the middleware pass control to the controller?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Next Called' column to see when it changes to Yes.

If next() was not called in middleware, what would happen?

A Response would be sent twice

B Request would skip middleware

C Request would stop at middleware and controller won't run

D Middleware would run twice

💡 Hint

Refer to the key moment about why next() is needed and execution_table step 3.

Concept Snapshot

Creating middleware in NestJS:
- Middleware runs on each request before controllers
- Implement NestMiddleware interface with use(req, res, next)
- Call next() to continue processing
- Can modify req or res objects
- Useful for logging, auth, or modifying requests

Full Transcript

Middleware in NestJS runs when a request arrives. It can look at or change the request or response. The middleware must call next() to let the request continue to the controller. If next() is not called, the request stops and the controller never runs. For example, a LoggerMiddleware logs the request URL and then calls next(). The flow is: request arrives, middleware runs and logs, calls next(), controller handles request, response is sent back. This helps add features like logging or authentication before the main handling.