@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) {
  return this.usersService.findOne(id);
}

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

@Injectable()
export class ValidateAgePipe implements PipeTransform<number, number> {
  transform(value: number): number {
    if (value < 18) {
      throw new BadRequestException('Age must be at least 18');
    }
    if (value > 120) {
      throw new BadRequestException('Age must be less than 120');
    }
    return value; // Значення не змінюється, лише перевіряється
  }
}

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

interface PipeTransform<T = any, R = any> {
  transform(value: T, metadata: ArgumentMetadata): R | Promise<R>;
}

interface ArgumentMetadata {
  type: 'body' | 'query' | 'param' | 'custom';
  metatype?: Type<unknown>;
  data?: string;
}

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

@Injectable()
export class ParsePositiveIntPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    console.log('Metadata:', metadata);
    // { type: 'param', metatype: Number, data: 'id' }
    
    const val = parseInt(value, 10);
    
    if (isNaN(val)) {
      throw new BadRequestException(`Validation failed: "${value}" is not a valid integer`);
    }
    
    if (val <= 0) {
      throw new BadRequestException(`Validation failed: value must be positive, received ${val}`);
    }
    
    return val;
  }
}

@Get(':id')
findOne(@Param('id', ParsePositiveIntPipe) id: number) {
  // id гарантовано є додатнім числом
  return this.usersService.findOne(id);
}

@Get(':id')
findOne(
  @Param('id', ParseIntPipe) id: number,
  @Query('limit', new DefaultValuePipe(10), ParseIntPipe) limit: number
) {
  // ParseIntPipe застосовано до id
  // DefaultValuePipe та ParseIntPipe застосовано до limit у ланцюгу
  return this.usersService.findMany(id, limit);
}

@Post()
@UsePipes(new ValidationPipe({ whitelist: true }))
create(@Body() dto: CreateUserDto, @Query('notify') notify: string) {
  // ValidationPipe застосовано до обох параметрів: dto та notify
  return this.usersService.create(dto, notify === 'true');
}

@Controller('users')
@UsePipes(ValidationPipe)
export class UsersController {
  @Get()
  findAll(@Query() query: FindAllDto) {
    // ValidationPipe застосовано
  }

  @Post()
  create(@Body() dto: CreateUserDto) {
    // ValidationPipe застосовано
  }
  
  @Patch(':id')
  update(@Param('id') id: string, @Body() dto: UpdateUserDto) {
    // ValidationPipe застосовано до обох параметрів
  }
}

@Controller('users')
@UsePipes(TrimStringsPipe) // Виконається 2-м
export class UsersController {
  @Post()
  @UsePipes(SanitizeHtmlPipe) // Виконається 3-м
  create(
    @Body(new ValidateEmailPipe()) dto: CreateUserDto // Виконається 4-м
  ) {
    // dto пройшов через 3 pipes: Trim → Sanitize → ValidateEmail
  }
}

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

@Injectable()
export class ParseIntPipe implements PipeTransform<string, number> {
  transform(value: string): number {
    const val = parseInt(value, 10);
    
    if (isNaN(val)) {
      // 400 Bad Request
      throw new BadRequestException(
        `Validation failed: "${value}" is not a valid integer`
      );
    }
    
    return val;
  }
}

@Injectable()
export class UserExistsPipe implements PipeTransform {
  constructor(private usersService: UsersService) {}

  async transform(userId: string) {
    const user = await this.usersService.findById(userId);
    
    if (!user) {
      // 404 Not Found
      throw new NotFoundException(`User with ID "${userId}" does not exist`);
    }
    
    return user; // Повертаємо об'єкт замість ID
  }
}

{
  "statusCode": 400,
  "message": "Validation failed: \"abc\" is not a valid integer",
  "error": "Bad Request"
}

@Get()
findAll(
  @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
  @Query('limit', new DefaultValuePipe(10), ParseIntPipe, new MaxValuePipe(100)) limit: number
) {
  // Якщо page відсутній → DefaultValuePipe встановить 1
  // Потім ParseIntPipe перетворить на number
  // Аналогічно для limit + MaxValuePipe обмежить до 100
  return this.usersService.findAll({ page, limit });
}

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

@Injectable()
export class MaxValuePipe implements PipeTransform<number, number> {
  constructor(private readonly max: number) {}

  transform(value: number): number {
    if (value > this.max) {
      throw new BadRequestException(`Value must not exceed ${this.max}, received: ${value}`);
    }
    return value;
  }
}

// create-user.dto.ts
export class CreateUserDto {
  email: string;
  password: string;
  age: number;
  roles: string[];
}

// validate-age.pipe.ts
import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';

@Injectable()
export class ValidateAgePipe implements PipeTransform<number, number> {
  transform(age: number): number {
    if (age < 18) {
      throw new BadRequestException('User must be at least 18 years old');
    }
    if (age > 120) {
      throw new BadRequestException('Invalid age value');
    }
    return age;
  }
}

// validate-roles.pipe.ts
@Injectable()
export class ValidateRolesPipe implements PipeTransform<string[], string[]> {
  private readonly allowedRoles = ['user', 'admin', 'moderator'];

  transform(roles: string[]): string[] {
    if (!Array.isArray(roles)) {
      throw new BadRequestException('Roles must be an array');
    }

    const invalidRoles = roles.filter(role => !this.allowedRoles.includes(role));
    
    if (invalidRoles.length > 0) {
      throw new BadRequestException(
        `Invalid roles: ${invalidRoles.join(', ')}. Allowed: ${this.allowedRoles.join(', ')}`
      );
    }

    return roles;
  }
}

import { Controller, Post, Body } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { ValidateAgePipe } from './pipes/validate-age.pipe';
import { ValidateRolesPipe } from './pipes/validate-roles.pipe';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() dto: CreateUserDto) {
    // Валідація age відбувається в окремому Pipe
    const validatedAge = await new ValidateAgePipe().transform(dto.age);
    // Валідація roles відбувається в іншому Pipe
    const validatedRoles = await new ValidateRolesPipe().transform(dto.roles);

    return this.usersService.create({
      ...dto,
      age: validatedAge,
      roles: validatedRoles,
    });
  }
}