Global middleware in NestJS - Mini Project: Build & Apply

Using Global Middleware in NestJS

📖 Scenario: You are building a simple NestJS application that logs every request made to the server. To do this efficiently, you want to use global middleware so that the logging happens for all routes automatically.

🎯 Goal: Create a global middleware in NestJS that logs the HTTP method and URL of every incoming request.

📋 What You'll Learn

Create a middleware class called LoggerMiddleware that logs the HTTP method and URL.

Apply the LoggerMiddleware globally in the main application module.

Use the use method of MiddlewareConsumer to apply the middleware.

Ensure the middleware logs the method and URL before passing control to the next handler.

💡 Why This Matters

🌍 Real World

Global middleware is used in real NestJS apps to handle tasks like logging, authentication, and request validation for all routes without repeating code.

💼 Career

Understanding global middleware is essential for backend developers working with NestJS to build scalable and maintainable server applications.

1

Create LoggerMiddleware class

Create a class called LoggerMiddleware that implements NestMiddleware. Inside the use method, log the HTTP method and URL from the Request object using console.log. Do not call next() yet.

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    // Your code here
  }
}

Hint

Remember to import NestMiddleware and implement the use method with req, res, and next parameters.

2

Call next() in LoggerMiddleware

In the LoggerMiddleware class, inside the use method, add a call to next() after logging to pass control to the next middleware or route handler.

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`Method: ${req.method} URL: ${req.url}`);
    // Your code here
  }
}

Hint

Call next() after logging to continue the request lifecycle.

3

Apply LoggerMiddleware globally in AppModule

In the AppModule class, implement the configure method with a MiddlewareConsumer parameter. Use consumer.apply(LoggerMiddleware).forRoutes('*') to apply the middleware globally to all routes.

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

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

import { Module, MiddlewareConsumer } from '@nestjs/common';

@Module({})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    // Your code here
  }
}

Hint

Use the configure method in AppModule to apply middleware globally.

4

Import LoggerMiddleware in AppModule

Add an import statement for LoggerMiddleware at the top of the AppModule file to ensure it is recognized when applying middleware.

NestJS

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

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

import { Module, MiddlewareConsumer } from '@nestjs/common';
// Your code here

@Module({})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes('*');
  }
}

Hint

Import the LoggerMiddleware class from its file path at the top of the module file.

Practice

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

easy

A. To define database models for the application

B. To run code on every incoming request before reaching route handlers

C. To create new routes dynamically

D. To handle errors after the response is sent

Solution

1. Step 1: Understand middleware role

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

2. Step 2: Identify global middleware scope

   Global middleware runs on every request, so it applies common logic everywhere.

3. Final Answer:

   To run code on every incoming request before reaching route handlers -> Option B

4. Quick Check:

   Global middleware = runs on every request [OK]

Hint: Global middleware runs before routes on all requests [OK]

Common Mistakes:

• Confusing middleware with route handlers
• Thinking middleware only runs on some routes
• Mixing middleware with error handling

2. Which of the following is the correct way to apply a middleware globally in NestJS?

easy

A. app.useGlobalMiddleware(MyMiddleware)

B. consumer.apply(MyMiddleware).forRoutes('users')

C. consumer.apply(MyMiddleware).forRoutes('*')

D. app.applyMiddlewareGlobally(MyMiddleware)

Solution

1. Step 1: Recall global middleware syntax

   In NestJS, the recommended way to apply middleware globally is using app.useGlobalMiddleware(MyMiddleware).

2. Step 2: Compare options

   consumer.apply(MyMiddleware).forRoutes('*') applies middleware to all routes but is not truly global middleware; app.useGlobalMiddleware applies middleware globally.

3. Final Answer:

   app.useGlobalMiddleware(MyMiddleware) -> Option A

4. Quick Check:

   Global middleware uses app.useGlobalMiddleware [OK]

Hint: Use app.useGlobalMiddleware to apply middleware globally [OK]

Common Mistakes:

• Using consumer.apply(...).forRoutes('*') for global middleware
• Trying to call non-existent app methods
• Confusing middleware registration with guards

3. Given this middleware code, what will be logged for every request?

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

// Applied globally with consumer.apply(LoggerMiddleware).forRoutes('*')

medium

A. Logs the HTTP method only

B. Logs the response status code

C. Logs nothing because next() is missing

D. Logs the URL of every incoming request

Solution

1. Step 1: Analyze middleware code

   The middleware logs the string 'Request to:' plus the request URL from req.url.

2. Step 2: Understand global application

   Since applied globally, this log happens on every request URL received by the app.

3. Final Answer:

   Logs the URL of every incoming request -> Option D

4. Quick Check:

   LoggerMiddleware logs req.url every request [OK]

Hint: Look for console.log inside middleware use() method [OK]

Common Mistakes:

• Assuming HTTP method is logged instead of URL
• Forgetting next() causes no further processing
• Thinking response status is logged

4. Identify the error in this global middleware setup:

export class AuthMiddleware implements NestMiddleware {
  use(req: Request, res: Response) {
    if (!req.headers.authorization) {
      res.status(401).send('Unauthorized');
    }
  }
}

// Applied with consumer.apply(AuthMiddleware).forRoutes('*')

medium

A. Missing call to next() to continue request processing

B. Middleware should not check headers

C. forRoutes('*') cannot be used for global middleware

D. res.status(401) is invalid syntax

Solution

1. Step 1: Check middleware method signature

   The use method lacks the next parameter and does not call next(), so request stops here.

2. Step 2: Understand middleware flow

   Without calling next(), the request will hang or not proceed to route handlers after middleware.

3. Final Answer:

   Missing call to next() to continue request processing -> Option A

4. Quick Check:

   Middleware must call next() to proceed [OK]

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

Common Mistakes:

• Omitting next() call in middleware
• Misunderstanding middleware flow control
• Thinking forRoutes('*') is invalid

5. You want to apply a logging middleware globally but only for HTTP POST requests. Which approach correctly achieves this in NestJS?

hard

A. Use consumer.apply(LoggerMiddleware).forRoutes('*') and check req.method inside middleware

B. Apply middleware only on POST routes manually, no global option

C. Use consumer.apply(LoggerMiddleware).forRoutes({ path: '*', method: RequestMethod.POST })

D. Use app.useGlobalMiddleware(LoggerMiddleware) with method filter

Solution

1. Step 1: Understand route filtering in middleware

   NestJS allows filtering middleware by path and HTTP method using forRoutes with an object.

2. Step 2: Apply middleware globally but only for POST

   Using forRoutes({ path: '*', method: RequestMethod.POST }) applies middleware to all paths but only POST requests.

3. Step 3: Evaluate other options

   Use consumer.apply(LoggerMiddleware).forRoutes('*') and check req.method inside middleware applies middleware on all methods, not just POST. Apply middleware only on POST routes manually, no global option is manual, not global. Use app.useGlobalMiddleware(LoggerMiddleware) with method filter is invalid syntax.

4. Final Answer:

   Use consumer.apply(LoggerMiddleware).forRoutes({ path: '*', method: RequestMethod.POST }) -> Option C

5. Quick Check:

   forRoutes with method filter = selective global middleware [OK]

Hint: Use forRoutes({ path: '*', method: RequestMethod.POST }) for selective global [OK]

Common Mistakes:

• Applying middleware globally without method filter
• Trying non-existent app.useGlobalMiddleware method
• Manually applying middleware on each POST route