Middleware in NestJS plays an important role in intercepting and processing HTTP requests before they reach route handlers. It allows developers to execute code logic before or after handling a request, making it a powerful tool for managing cross-cutting concerns such as logging, authentication, error handling, and more.

In this article, we will explore how to implement custom middleware in NestJS to enhance the functionality of your applications.

Prerequisites

• Node.js and npm installed.
• Basic knowledge of TypeScript.
• NestJS CLI installed (npm install -g @nestjs/cli).

Understanding Middleware in NestJS

Middleware functions in NestJS are functions or classes that are invoked during the request-response cycle. They have access to the request and response objects as well as the next function, which is used to pass control to the next middleware function or route handler.

Middleware can be used for various purposes:

• Logging: Capture information about incoming requests or outgoing responses.
• Authentication: Verify the identity of users before allowing access to protected routes.
• Error Handling: Catch and process errors that occur during request processing.
• Request Processing: Modify request or response objects before they reach route handlers.

Types of Middleware in NestJS

NestJS supports three types of middleware:

• Function Middleware: Simple functions that accept the request, response, and next function as arguments.
• Middleware Classes: ES6 classes that implement the NestMiddleware interface. These classes can inject dependencies through the constructor and are more structured and reusable.
• Route-scoped Middleware: Applied to specific routes or controllers using the @Use decorator.

Steps to Implement Middleware in NestJS

Step 1: Setup a Nest.js Project

First, ensure you have Node.js and npm installed. Then, install the Nest CLI if you haven’t already:

npm install -g @nestjs/cli

Step 2: Create a new NestJS project:

nest new nest-gfg

Step 3: Navigate to the project directory:

cd nest-gfg

Step 4: Creating a Simple Middleware

Generate a new controller using the Nest CLI:

nest generate middleware logger

Folder Structure

Folder Structure

Dependencies

"dependencies": {
    "@nestjs/common": "^10.0.0",
    "@nestjs/core": "^10.0.0",
    "@nestjs/mongoose": "^10.0.10",
    "@nestjs/platform-express": "^10.0.0",
    "dotenv": "^16.4.5",
    "mongoose": "^8.5.1",
    "reflect-metadata": "^0.2.0",
    "rxjs": "^7.8.1"
  }

Example: Implementing the basic middleware.

// src/app.module.ts

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggerMiddleware } from './logger/logger.middleware';

@Module({
    imports: [],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule implements NestModule {
    configure(consumer: MiddlewareConsumer) {
        consumer.apply(LoggerMiddleware).forRoutes('*');
    }
}

// src/logger.middleware.

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(`Request...`);
        console.log(`Method: ${req.method}`);
        console.log(`URL: ${req.url}`);
        next();
    }
}

Output

Middleware in NestJS: Implementing Custom Middleware for Request Processing.