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.

Practice

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

easy

A. To handle server errors automatically

B. To define database models

C. To run code before the request reaches the route handler

D. To create UI components

Solution

1. Step 1: Understand middleware role

   Middleware is code that runs before the main route handler processes a request.

2. Step 2: Compare options

   Only To run code before the request reaches the route handler describes this behavior correctly; others describe unrelated tasks.

3. Final Answer:

   To run code before the request reaches the route handler -> Option C

4. Quick Check:

   Middleware runs before routes [OK]

Hint: Middleware always runs before route handlers [OK]

Common Mistakes:

• Confusing middleware with controllers
• Thinking middleware handles UI rendering
• Assuming middleware manages database models

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

easy

A. const MyMiddleware = (req, res, next) => { next(); }

B. class MyMiddleware { handle(req, res, next) { next(); } }

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

D. class MyMiddleware { use(req, res, next) { next(); } }

Solution

1. Step 1: Recall NestJS middleware pattern

   Middleware must be a class with a method named use that takes req, res, next.

2. Step 2: Check options

   Only class MyMiddleware { use(req, res, next) { next(); } } defines a class with a use method correctly. class MyMiddleware { handle(req, res, next) { next(); } } uses handle, which is invalid. Options C and D define functions, not classes.

3. Final Answer:

   class MyMiddleware { use(req, res, next) { next(); } } -> Option D

4. Quick Check:

   Middleware class must have use() method [OK]

Hint: Middleware class must have a use() method [OK]

Common Mistakes:

• Using method name other than use
• Defining middleware as a function instead of class
• Forgetting to call next() inside use

3. Given this middleware class, what will be logged when a request to '/some-path' hits the route?

class LoggerMiddleware {
  use(req, res, next) {
    console.log('Request URL:', req.url);
    next();
  }
}

medium

A. Request URL: /some-path

B. Request URL: undefined

C. No output because next() is missing

D. Error: use method not found

Solution

1. Step 1: Analyze middleware behavior

   The middleware logs the request URL from req.url and then calls next() to continue.

2. Step 2: Predict output

   When a request to '/some-path' arrives, it logs 'Request URL: /some-path'. No errors occur because use is defined and next() is called.

3. Final Answer:

   Request URL: /some-path -> Option A

4. Quick Check:

   Middleware logs req.url correctly [OK]

Hint: Middleware logs req.url before calling next() [OK]

Common Mistakes:

• Forgetting to call next() causing no further processing
• Assuming req.url is undefined
• Confusing method name use with handle

4. What is wrong with this middleware code?

class LoggerMiddleware {
  use(req, res, next) {
    console.log('Request received');
  }
}

export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes('users');
  }
}

medium

A. Missing call to next() inside LoggerMiddleware

B. MiddlewareConsumer must be imported from '@nestjs/common' not '@nestjs/core'

C. The configure method should return a value

D. No semicolon after forRoutes call

Solution

1. Step 1: Check middleware code

   The registration uses MiddlewareConsumer correctly, but examine the LoggerMiddleware class.

2. Step 2: Identify the error

   The use method does not call next(), causing the request to hang without reaching the route handler.

3. Final Answer:

   Missing call to next() inside LoggerMiddleware -> Option A

4. Quick Check:

   Middleware must call next() to continue [OK]

Hint: Always call next() inside middleware use() method [OK]

Common Mistakes:

• Forgetting next() call causing request hang
• Thinking configure must return a value
• Confusing import sources for MiddlewareConsumer

5. You want to apply a middleware only to POST requests on the '/login' route. How can you achieve this in NestJS?

hard

A. Use consumer.apply(MyMiddleware).forRoutes('/login') and check method inside middleware

B. Use consumer.apply(MyMiddleware).forRoutes({ path: '/login', method: RequestMethod.POST })

C. Apply middleware globally and filter POST requests inside middleware

D. NestJS does not support method-specific middleware

Solution

1. Step 1: Understand method-specific middleware application

   In NestJS, you can specify route and HTTP method using an object with path and method in forRoutes.

2. Step 2: Evaluate options

   Use consumer.apply(MyMiddleware).forRoutes({ path: '/login', method: RequestMethod.POST }) correctly uses { path: '/login', method: RequestMethod.POST }. Use consumer.apply(MyMiddleware).forRoutes('/login') and check method inside middleware applies middleware to all methods on '/login', requiring manual filtering. Apply middleware globally and filter POST requests inside middleware applies globally, which is less efficient. NestJS does not support method-specific middleware is false.

3. Final Answer:

   Use consumer.apply(MyMiddleware).forRoutes({ path: '/login', method: RequestMethod.POST }) -> Option B

4. Quick Check:

   Use forRoutes with path and method object [OK]

Hint: Use forRoutes with path and method object for specific HTTP verbs [OK]

Common Mistakes:

• Applying middleware to all methods unintentionally
• Not importing RequestMethod enum
• Assuming method-specific middleware is unsupported