@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) {
  return id + 2;
}

  @Get(':id')
  findOne(
    @Param('id', new ParseIntPipe({ errorHttpStatusCode: HttpStatus.NOT_ACCEPTABLE })) id: number) {
    return id + 2;
  }

@Get('user/all')
findAll(
  @Query('offset', new DefaultValuePipe(0), ParseIntPipe) offset: number,
  @Query('limit', new DefaultValuePipe(10), ParseIntPipe) limit: number,
) {
  console.log(offset, limit);
  return offset;
}

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

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata): any {
    return undefined;
  }
}

export interface PipeTransform<T = any, R = any> {
    /**
     * Method to implement a custom pipe.  Called with two parameters
     *
     * @param value argument before it is received by route handler method
     * @param metadata contains metadata about the value
     */
    transform(value: T, metadata: ArgumentMetadata): R;
}

export interface ArgumentMetadata {
    /**
     * Indicates whether argument is a body, query, param, or custom parameter
     */
    readonly type: Paramtype;
    /**
     * Underlying base type (e.g., `String`) of the parameter, based on the type
     * definition in the route handler.
     */
    readonly metatype?: Type<any> | undefined;
    /**
     * String passed as an argument to the decorator.
     * Example: `@Body('userId')` would yield `userId`
     */
    readonly data?: string | undefined;
}

@Get(':id')
findOne(@Param('id', ValidationPipe) id: number) {
  return id;
}

import { IsEmail, IsString, MaxLength, MinLength } from 'class-validator';

export class CreateUserDto {
  @IsString()
  @MinLength(1)
  @MaxLength(20)
  readonly name: string;

  @IsEmail()
  email: string;
}

import {
  ArgumentMetadata,
  BadRequestException,
  Injectable,
  PipeTransform,
} from '@nestjs/common';
import { plainToClass } from 'class-transformer';
import { validate } from 'class-validator';

@Injectable()
export class ValidationPipe implements PipeTransform {
  // transform(value: any, metadata: ArgumentMetadata): any {
  //   console.log('value: ', value);
  //   console.log('metadata: ', metadata);
  //   return undefined;
  // }
  async transform(value: any, { metatype }: ArgumentMetadata) {
    // metatype 이 Pipe 가 지원하는 타입인지 검사
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }
    // 순수 자바스크립트 객체를 클래스 객체로 변경
    // (네트워크를 통해 들어온 데이터는 역직렬화 과정에서 body 의 객체가 아무런 타입 정보도 없기 때문에 타입을 지정하는 변환 과정)
    const object = plainToClass(metatype, value);
    const errors = await validate(object);
    if (errors.length > 0) {
      throw new BadRequestException('Validation failed~');
    }
    return value; // 유효성 검사 통과했다면 원래의 값 그대로 전달
  }

  // eslint-disable-next-line @typescript-eslint/ban-types
  private toValidate(metatype: Function): boolean {
    // eslint-disable-next-line @typescript-eslint/ban-types
    const types: Function[] = [String, Boolean, Number, Array, Object];
    return !types.includes(metatype);
  }
}

import { ValidationPipe } from '../validation.pipe';

...

@Controller('users')
export class UsersController {
  @Post()
  create(@Body(ValidationPipe) createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
}

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from './validation.pipe';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe());
  await app.listen(3000);
}
bootstrap();

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      transform: true,
    }),
  );
  await app.listen(3000);
}
bootstrap();

export class CreateUserDto {
  readonly name: string;
  readonly email: string;
  readonly password: string;
}

import {
  IsEmail,
  IsString,
  Matches,
  MaxLength,
  MinLength,
} from 'class-validator';

export class CreateUserDto {
  @IsString()
  @MinLength(2)
  @MaxLength(30)
  readonly name: string;

  @IsString()
  @IsEmail()
  @MaxLength(60)
  readonly email: string;

  @IsString()
  @Matches(/^[A-Za-z\d!@#$%^&*()]{8,30}$/)
  readonly password: string;
}

export declare function Transform(transformFn: (params: TransformFnParams) => any, options?: TransformOptions): PropertyDecorator;


export interface TransformFnParams {
  value: any;
  key: string;
  obj: any;
  type: TransformationType;
  options: ClassTransformOptions;
}

  @IsString()
@MinLength(2)
@MaxLength(30)
@Transform((params) => {
  console.log('param: ', params);
  return params.value;  // 속성 변형을 하지 않고 그대로 리턴
})
readonly name: string;

  @IsString()
  @MinLength(2)
  @MaxLength(30)
  @Transform((params) => params.value.trim())
  readonly name: string;

  @IsString()
  @Matches(/^[A-Za-z\d!@#$%^&*()]{8,30}$/)
  @Transform(({ value, obj }) => {
    if (obj.password.includes(obj.name.trim())) {
      throw new BadRequestException('password 에 name 과 같은 문자열 포함');
    }
    return value.trim();
  })
  readonly password: string;

  @IsString()
  @Matches(/^[A-Za-z\d!@#$%^&*()]{8,30}$/)
  @Transform(({ value, obj }) => {
    if (obj.password.includes(obj.name.trim())) {
      throw new BadRequestException('password 에 name 과 같은 문자열 포함');
    }
    return value.trim();
  })
  readonly password: string;

import {
  registerDecorator,
  ValidationArguments,
  ValidationOptions,
} from 'class-validator';

export function NotIn(property: string, validationOptions?: ValidationOptions) {  // 데커레이터의 인수는 객체에서 참조하려고 하는 다른 속성의 이름과 ValidationOptions 을 받음
  // eslint-disable-next-line @typescript-eslint/ban-types
  return (object: Object, propertyName: string) => {  // registerDecorator 를 호출하는 함수 리턴, 이 함수의 인수로 데커레이터가 선언될 객체와 속성 이름 받음
    registerDecorator({ // registerDecorator 는 ValidationDecoratorOptions 객체를 인수로 받음
      name: 'NotIn',  // 데커레이터 이름
      target: object.constructor, // 이 데커레이터는 객체가 생성될 때 적용됨.
      propertyName,
      options: validationOptions, // 유효성 옵션은 데커레이터의 인수로 전달받은 것을 사용
      constraints: [property],  //  이 데커레이터는 속성에 적용되도록 제약을 줌
      validator: {  // validator 속성 안에 유효성 검사 규칙 기술, 이는 ValidatorConstraint Interface 를 구현한 함수
        validate(
          value: any,
          validationArguments?: ValidationArguments,
        ): Promise<boolean> | boolean {
          const [relatedPropertyName] = validationArguments.constraints;
          const relatedValue = (validationArguments.object as any)[
            relatedPropertyName
          ];
          return (
            typeof value === 'string' &&
            typeof relatedValue === 'string' &&
            !relatedValue.includes(value)
          );
        },
      },
    });
  };
}

  @IsString()
  @MinLength(2)
  @MaxLength(30)
  @Transform((params) => params.value.trim())
  @NotIn('password', { message: 'password 는 name 과 같은 문자 포함 불가' })
  readonly name: string;