class-validator

function validateUser(body: any) {
  if (!body.email || !body.email.includes('@')) {
    throw new Error('이메일이 유효하지 않습니다');
  }
  if (!body.name || body.name.length < 2) {
    throw new Error('이름은 2자 이상이어야 합니다');
  }
  if (body.age !== undefined && (typeof body.age !== 'number' || body.age < 0)) {
    throw new Error('나이는 0 이상의 숫자여야 합니다');
  }
}

import { IsEmail, MinLength, IsInt, Min, IsOptional } from 'class-validator';

export class CreateUserDto {
  @IsEmail()
  email: string;

  @MinLength(2)
  name: string;

  @IsOptional()
  @IsInt()
  @Min(0)
  age?: number;
}

import { validate, validateOrReject } from 'class-validator';

const user = new CreateUserDto();
user.email = 'not-an-email';
user.name = 'J';

// 방법 1: 에러 배열 반환
const errors = await validate(user);
if (errors.length > 0) {
  console.log('검증 실패:', errors);
} else {
  console.log('검증 성공');
}

// 방법 2: 에러 시 Promise reject
try {
  await validateOrReject(user);
} catch (errors) {
  console.log('검증 실패:', errors);
}

{
  target: Object;        // 검증된 객체
  property: string;      // 실패한 프로퍼티 이름
  value: any;            // 실패한 값
  constraints?: {        // 실패한 검증 규칙과 에러 메시지
    [type: string]: string;
  };
  children?: ValidationError[];  // 중첩 객체의 검증 에러
}

{
  "property": "email",
  "value": "not-an-email",
  "constraints": {
    "isEmail": "email must be an email"
  }
}

@MinLength(10, {
  message: '제목은 최소 10자 이상이어야 합니다',
})
title: string;
date: "2026-02-15"

@MinLength(10, {
  message: '$property의 길이가 너무 짧습니다. 최소 $constraint1자, 현재 $value자',
})
title: string;
date: "2026-02-15"

@MinLength(10, {
  message: (args: ValidationArguments) => {
    if (args.value.length === 0) {
      return `${args.property}은(는) 필수 항목입니다`;
    }
    return `${args.property}은(는) 최소 ${args.constraints[0]}자여야 합니다 (현재: ${args.value.length}자)`;
  },
})
title: string;
date: "2026-02-15"

export class CreatePostDto {
  @MaxLength(20, { each: true })
  @IsString({ each: true })
  tags: string[];
}

@MaxLength(20, { each: true })
tags: Set<string>;

@MaxLength(20, { each: true })
tags: Map<string, string>;  // value를 검증

import { ValidateNested, IsString, IsInt } from 'class-validator';
import { Type } from 'class-transformer';

class AddressDto {
  @IsString()
  street: string;

  @IsString()
  city: string;

  @IsInt()
  zipCode: number;
}

class CreateUserDto {
  @IsString()
  name: string;

  @ValidateNested()
  @Type(() => AddressDto)
  address: AddressDto;
}

@ValidateNested({ each: true })
@Type(() => AddressDto)
addresses: AddressDto[];

import { ValidateIf, IsNotEmpty, IsUrl } from 'class-validator';

class SocialProfileDto {
  @IsString()
  platform: string;

  @ValidateIf(o => o.platform === 'website')
  @IsUrl()
  @IsNotEmpty()
  url: string;
}

class PaymentDto {
  @IsEnum(PaymentMethod)
  method: PaymentMethod;

  @ValidateIf(o => o.method === PaymentMethod.CARD)
  @IsCreditCard()
  cardNumber: string;

  @ValidateIf(o => o.method === PaymentMethod.BANK)
  @IsString()
  @IsNotEmpty()
  accountNumber: string;
}

class UserDto {
  @IsString({ always: true })
  name: string;

  @IsString({ groups: ['create'] })
  @MinLength(8, { groups: ['create'] })
  password: string;

  @IsEmail({}, { groups: ['create', 'update'] })
  email: string;
}

// 생성 시: name, password, email 모두 검증
validate(user, { groups: ['create'] });

// 수정 시: name, email만 검증 (password는 건너뜀)
validate(user, { groups: ['update'] });

// 알려지지 않은 프로퍼티를 조용히 제거
validate(user, { whitelist: true });

// 알려지지 않은 프로퍼티가 있으면 에러 발생
validate(user, { whitelist: true, forbidNonWhitelisted: true });

class UpdateProfileDto {
  @IsString()
  name: string;

  @Allow()
  metadata: any;  // 검증 규칙은 없지만 화이트리스트에 포함
}

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

@ValidatorConstraint({ name: 'isAfterNow', async: false })
class IsAfterNowConstraint implements ValidatorConstraintInterface {
  validate(value: any, args: ValidationArguments): boolean {
    if (!(value instanceof Date)) return false;
    return value.getTime() > Date.now();
  }

  defaultMessage(args: ValidationArguments): string {
    return `${args.property}은(는) 현재 시간 이후여야 합니다`;
  }
}

// 데코레이터 팩토리
function IsAfterNow(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsAfterNowConstraint,
    });
  };
}

class CreateEventDto {
  @IsAfterNow({ message: '이벤트 시작일은 미래여야 합니다' })
  startDate: Date;
}

function IsLongerThan(property: string, validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      name: 'isLongerThan',
      target: object.constructor,
      propertyName,
      constraints: [property],
      options: validationOptions,
      validator: {
        validate(value: any, args: ValidationArguments) {
          const [relatedPropertyName] = args.constraints;
          const relatedValue = (args.object as any)[relatedPropertyName];
          return typeof value === 'string' &&
                 typeof relatedValue === 'string' &&
                 value.length > relatedValue.length;
        },
        defaultMessage(args: ValidationArguments) {
          return `${args.property}은(는) ${args.constraints[0]}보다 길어야 합니다`;
        },
      },
    });
  };
}

@ValidatorConstraint({ name: 'isUniqueEmail', async: true })
class IsUniqueEmailConstraint implements ValidatorConstraintInterface {
  constructor(private userRepository: UserRepository) {}

  async validate(email: string): Promise<boolean> {
    const user = await this.userRepository.findByEmail(email);
    return !user;  // 이미 존재하면 false
  }

  defaultMessage(): string {
    return '이미 사용 중인 이메일입니다';
  }
}

// main.ts
import { ValidationPipe } from '@nestjs/common';

app.useGlobalPipes(
  new ValidationPipe({
    whitelist: true,              // DTO에 없는 프로퍼티 제거
    forbidNonWhitelisted: true,   // 알 수 없는 프로퍼티가 있으면 400 에러
    transform: true,              // plain object → DTO 클래스 인스턴스로 변환
    transformOptions: {
      enableImplicitConversion: true,  // 쿼리 파라미터 등 문자열 → 숫자 자동 변환
    },
  }),
);

@Controller('users')
class UserController {
  @Post()
  create(@Body() dto: CreateUserDto) {
    // dto는 이미 검증 완료된 CreateUserDto 인스턴스
    // 검증 실패 시 자동으로 400 Bad Request 응답
    return this.userService.create(dto);
  }

  @Get()
  findAll(@Query() query: PaginationDto) {
    // 쿼리 파라미터도 검증 가능
    return this.userService.findAll(query);
  }
}

new ValidationPipe({
  exceptionFactory: (errors: ValidationError[]) => {
    const messages = errors.map(error => {
      const constraints = Object.values(error.constraints || {});
      return {
        field: error.property,
        errors: constraints,
      };
    });
    return new BadRequestException({
      statusCode: 400,
      message: '입력값 검증에 실패했습니다',
      errors: messages,
    });
  },
});

class BaseDto {
  @IsEmail()
  email: string;

  @IsString()
  password: string;
}

class CreateUserDto extends BaseDto {
  @MinLength(2)
  @MaxLength(20)
  name: string;

  @MinLength(8)  // 부모의 @IsString()도 함께 적용됨
  password: string;
}

// ❌ 동작하지 않음
const body = { email: 'test@test.com', name: 'J' };
validate(body);  // 데코레이터가 없으니 검증이 안 됨

// ✅ 클래스 인스턴스로 변환 후 검증
import { plainToInstance } from 'class-transformer';
const dto = plainToInstance(CreateUserDto, body);
validate(dto);

// ❌ address 내부는 검증되지 않음
class UserDto {
  @Type(() => AddressDto)
  address: AddressDto;
}

// ✅ @ValidateNested 필요
class UserDto {
  @ValidateNested()
  @Type(() => AddressDto)
  address: AddressDto;
}

class UserDto {
  @IsString()  // groups 미지정
  name: string;

  @IsString({ groups: ['create'] })
  password: string;
}

// validate(dto, { groups: ['create'] }) 호출 시
// name의 @IsString()은 실행되지 않음!
// always: true 또는 groups: ['create'] 추가 필요