Why middleware processes requests before handlers in NestJS - See It in Action

Understanding Middleware Processing Order in NestJS

📖 Scenario: You are building a simple NestJS server that logs request details before handling them. This helps you understand how middleware works before the main request handler.

🎯 Goal: Create a NestJS middleware that logs the request method and URL before the request reaches the handler.

📋 What You'll Learn

Create a middleware function named LoggerMiddleware

Configure the middleware to apply to all routes

Log the HTTP method and URL of each incoming request

Create a simple controller with a GET handler at path /hello that returns a greeting

💡 Why This Matters

🌍 Real World

Middleware is used in real web servers to log requests, check user authentication, and modify requests before they reach the main logic.

💼 Career

Understanding middleware is essential for backend developers working with NestJS or similar frameworks to build secure and maintainable server applications.

1

Create a simple controller with a GET handler

Create a controller class named HelloController with a method getHello that handles GET requests at path /hello and returns the string 'Hello, NestJS!'.

NestJS

import { Controller, Get } from '@nestjs/common';

// Your code here

Hint

Use @Controller() and @Get('hello') decorators to define the route and handler.

2

Create a middleware class named LoggerMiddleware

Create a class named LoggerMiddleware that implements NestMiddleware and has a use method accepting req, res, and next parameters.

NestJS

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

@Controller()
export class HelloController {
  @Get('hello')
  getHello(): string {
    return 'Hello, NestJS!';
  }
}

// Create LoggerMiddleware class here
// Your code here

Hint

Import NestMiddleware and Injectable from @nestjs/common. Define the use method with parameters req, res, and next.

3

Add logging inside the middleware use method

Inside the use method of LoggerMiddleware, add a console log that outputs the HTTP method and URL of the incoming request using req.method and req.url. Then call next() to continue processing.

NestJS

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

@Controller()
export class HelloController {
  @Get('hello')
  getHello(): string {
    return 'Hello, NestJS!';
  }
}

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    // Log method and URL here
    // Your code here
    next();
  }
}

Hint

Use a template string inside console.log to show req.method and req.url.

4

Apply the LoggerMiddleware globally in the main module

In the main application module, import MiddlewareConsumer and Module from @nestjs/common. Then, in the AppModule class, implement the configure method that accepts a consumer parameter of type MiddlewareConsumer. Use consumer.apply(LoggerMiddleware).forRoutes('*') to apply the middleware to all routes.

NestJS

import { Controller, Get, NestMiddleware, Injectable, Module, MiddlewareConsumer } from '@nestjs/common';

@Controller()
export class HelloController {
  @Get('hello')
  getHello(): string {
    return 'Hello, NestJS!';
  }
}

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    console.log(`Request... Method: ${req.method}, URL: ${req.url}`);
    next();
  }
}

@Module({
  controllers: [HelloController],
  providers: [],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    // Apply LoggerMiddleware globally
    // Your code here
  }
}

Hint

Use the configure method in AppModule to apply middleware globally with consumer.apply(...).forRoutes('*').

Practice

1. Why does middleware in NestJS process requests before the route handlers?

easy

A. To delay the request processing intentionally

B. To send the response after the handler finishes

C. To replace the route handler completely

D. To prepare or check the request before the handler uses it

Solution

1. Step 1: Understand middleware role

   Middleware runs before handlers to prepare or validate requests, like checking authentication or adding data.

2. Step 2: Compare with other options

   Middleware does not send responses after handlers or replace handlers; it only processes requests early.

3. Final Answer:

   To prepare or check the request before the handler uses it -> Option D

4. Quick Check:

   Middleware prepares requests = D [OK]

Hint: Middleware runs first to prep requests before handlers [OK]

Common Mistakes:

• Thinking middleware runs after handlers
• Believing middleware replaces handlers
• Assuming middleware delays requests

2. Which of the following is the correct way to continue request processing inside a NestJS middleware?

easy

A. Return the response directly

B. Call next() function

C. Throw an error to stop processing

D. Call the route handler manually

Solution

1. Step 1: Identify middleware flow control

   In NestJS, calling next() passes control to the next middleware or handler.

2. Step 2: Eliminate incorrect options

   Returning response or throwing error stops flow; calling handler manually is not standard.

3. Final Answer:

   Call next() function -> Option B

4. Quick Check:

   Use next() to continue middleware chain [OK]

Hint: Always call next() to move forward in middleware [OK]

Common Mistakes:

• Forgetting to call next(), causing request hang
• Trying to call handler directly inside middleware
• Returning response without next() when not ending request

3. Given this NestJS middleware code snippet, what will be logged first when a request arrives?

export function logger(req, res, next) {
  console.log('Middleware start');
  next();
  console.log('Middleware end');
}

medium

A. "Middleware start" then "Middleware end"

B. "Middleware end" then "Middleware start"

C. Only "Middleware start" is logged

D. No logs appear because next() stops execution

Solution

1. Step 1: Analyze middleware execution order

   Console logs before and after next() run synchronously; first logs "Middleware start".

2. Step 2: Understand next() behavior

   Calling next() passes control but does not pause middleware; "Middleware end" logs after next() call.

3. Final Answer:

   "Middleware start" then "Middleware end" -> Option A

4. Quick Check:

   Logs before and after next() run in order [OK]

Hint: Logs before and after next() run in sequence [OK]

Common Mistakes:

• Thinking next() pauses middleware execution
• Assuming logs after next() run later
• Believing next() stops middleware code

4. You wrote this NestJS middleware but requests never reach the handler. What is the problem?

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

medium

A. Middleware must not send responses directly

B. Authorization header check is incorrect syntax

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

D. next() should be called before checking headers

Solution

1. Step 1: Review middleware flow control

   If authorization header is missing, response is sent but next() is still called, causing request to continue incorrectly.

2. Step 2: Fix flow by returning early

   To stop processing after sending response, return immediately without calling next().

3. Final Answer:

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

4. Quick Check:

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

Hint: Return after sending response to avoid calling next() [OK]

Common Mistakes:

• Calling next() after response ends
• Not returning early to stop middleware
• Misunderstanding middleware flow control

5. You want to add a middleware that adds a timestamp to every request before handlers run. Which approach correctly ensures the timestamp is available in the handler?

hard

A. Add req.timestamp = Date.now() in middleware, then call next()

B. Call next() first, then add req.timestamp after

C. Add timestamp in the handler, not middleware

D. Send timestamp in response headers from middleware

Solution

1. Step 1: Understand middleware purpose

   Middleware runs before handlers, so adding data to req here makes it available later.

2. Step 2: Correct order of operations

   Assign req.timestamp before calling next() so handlers see the value.

3. Final Answer:

   Add req.timestamp = Date.now() in middleware, then call next() -> Option A

4. Quick Check:

   Add data before next() to share with handlers [OK]

Hint: Set request data before next() to share with handlers [OK]

Common Mistakes:

• Adding data after next(), so handlers miss it
• Trying to add data in handlers instead of middleware
• Sending data only in response headers