These four concepts are all part of middleware in nestjs but each serving a unique purpose.

Pipes

Pipes in NestJS are responsible for transforming and validating data before it is passed into a controller’s router handler.

• Transformation: They can automatically transform the input data (e.g., converting strings into integers)
• Validation: Pipes can validate incoming requests and throw an exception if the validation fails

NestJS provides two built-in types of pipes: Transformation Pipes and Validation Pipes

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class ParseIntPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException('Validation failed');
    }
    return val;
  }
}

To use a pipe in a controller:

@Get(':id')
getUser(@Param('id', ParseIntPipe) id: number) {
  return this.userService.getUserById(id);
}

Guards

Guard are used to implement authorization logic. They determine whether a specific request is allowed to proceed by evaluating custom conditions, such as checking if a user is authenticated or has a particular role.

Guards return a boolean value, and if they return false, the request will be denied

Example (Guard for Authorization):

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    return request.session.user ? true : false; // Check if user is logged in
  }
}

@Controller('users')
@UseGuards(AuthGuard) // Applies the AuthGuard to the whole controller
export class UsersController {
  @Get()
  findAll() {
    return this.usersService.findAll();
  }
}

Interceptors

Interceptors are used to perform logic before or after the execution of a route handler. They are often used to transform the response, log incoming requests, or handle additional tasks such as caching.

Interceptors can:

• Bind extra logic before/after method execution
• Transform the result returned from a function