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
  }
}

Need a 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
  }
}

Need a 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
  }
}

Need a 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('*');
  }
}

Need a hint?

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