1
yarn add class-validator

1
class User {
2
  @IsNotEmpty()
3
  name: string
4

5
  @IsEmail()
6
  email: string
7
}

1
const user = new User()
2

3
user.name = ''
4
user.email = 'invalid-email'
5

6
validate(user).then(errors => {
7
  // 여기서 에러 반환
8
})

1
import { IsString } from 'class-validator'
2

3
export class CreatePostDto {
4
  @IsString()
5
  title: string
6

7
  @IsString()
8
  content: string
9
}

1
// posts.controller.ts 생략
2
@Post()
3
@UseGuards(AccessTokenGuard)
4
postPosts(
5
  @User('id') userId: number,
6
  @Body() body: CreatePostDto,
7
  // @Body('title') title: string,
8
  // @Body('content') content: string,
9
  // 기본값을 true로 설정하는 파이프
10
  // @Body('isPublic', new DefaultValuePipe(true)) isPublic: boolean,
11
) {
12
  return this.postsService.createPost(userId, body)
13
}

1
// posts.service.ts 생략
2
/**
3
 * 1) create : 저장할 객체를 생성
4
 * 2) save   : 객체를 저장 (create 메서드에서 생성한 객체로)
5
 */
6
async createPost(authorId: number, postDto: CreatePostDto) {
7
  const post = this.postsRepository.create({
8
    author: {
9
      id: authorId,
10
    },
11
    ...postDto,
12
    likeCount: 0,
13
    commentCount: 0,
14
  })
15
  const newPost = await this.postsRepository.save(post)
16
  return newPost
17
}

1
import { NestFactory } from '@nestjs/core'
2
import { AppModule } from './app.module'
3
import { ValidationPipe } from '@nestjs/common'
4

5
async function bootstrap() {
6
  const app = await NestFactory.create(AppModule)
7
  app.useGlobalPipes(new ValidationPipe()) // 추가
8
  await app.listen(3000)
9
}
10
bootstrap()

1
{
2
  target: Object;
3
  property: string;
4
  value: any;
5
  constraints?: {
6
  	[type: string]: string;
7
	};
8
	children?: ValidationError[];
9
}

1
import { IsString } from 'class-validator'
2

3
export class CreatePostDto {
4
  @IsString({
5
    message: 'title은 string 타입을 입력해줘야 합니다.',
6
  })
7
  title: string
8

9
  @IsString({
10
    message: 'content은 string 타입을 입력해줘야 합니다.',
11
  })
12
  content: string
13
}

1
// 생략
2

3
@Entity()
4
export class PostsModel extends BaseModel {
5
  // 생략
6
  @Column()
7
  @IsString({
8
    message: 'title은 string 타입을 입력해줘야 합니다.',
9
  })
10
  title: string
11

12
  @Column()
13
  @IsString({
14
    message: 'content은 string 타입을 입력해줘야 합니다.',
15
  })
16
  content: string
17
  // 생략
18
}

1
import { PickType } from '@nestjs/mapped-types'
2
import { PostsModel } from '../entities/posts.entity'
3

4
/***
5
 * Pick, Omit, Partial -> Type을 반환
6
 * PickType, OmitType, PartialType -> 값을 반환
7
 */
8
export class CreatePostDto extends PickType(PostsModel, ['title', 'content']) {}

1
import { IsOptional, IsString } from 'class-validator'
2
import { CreatePostDto } from './create-post.dto'
3
import { PartialType } from '@nestjs/mapped-types'
4

5
/***
6
 * Pick, Omit, Partial -> Type을 반환
7
 * PickType, OmitType, PartialType -> 값을 반환
8
 */
9
export class UpdatePostDto extends PartialType(CreatePostDto) {
10
  @IsString()
11
  @IsOptional()
12
  title?: string
13

14
  @IsString()
15
  @IsOptional()
16
  content?: string
17
}

1
@Patch(':id')
2
putPost(
3
  @Param('id', ParseIntPipe) id: number, //
4
  @Body() body: UpdatePostDto,
5
  // @Body('title') title?: string,
6
  // @Body('content') content?: string,
7
) {
8
  return this.postsService.updatePost(id, body)
9
}

1
// posts.service.ts 생략
2
async updatePost(postId: number, postDto: UpdatePostDto) {
3
  const { title, content } = postDto // 추가
4
  const post = await this.postsRepository.findOne({
5
    where: { id: postId },
6
  })
7

8
  if (!post) throw new NotFoundException()
9
  if (title) post.title = title
10
  if (content) post.content = content
11

12
  const newPost = await this.postsRepository.save(post)
13
  return newPost
14
}

1
// posts.controller.ts
2
/*** 4) PATCH /posts/:id
3
 * id에 해당하는 post를 부분 변경한다
4
 */
5
@Patch(':id')
6
patchPost(
7
  @Param('id', ParseIntPipe) id: number, //
8
  @Body() body: UpdatePostDto,
9
) {
10
  return this.postsService.updatePost(id, body)
11
}

1
import { PickType } from '@nestjs/mapped-types'
2
import { UsersModel } from 'src/users/entities/users.entity'
3

4
export class RegisterUserDto extends PickType(UsersModel, ['nickname', 'email', 'password']) {}

1
// 생략
2

3
@Entity()
4
export class UsersModel extends BaseModel {
5
  /*** 닉네임 특성
6
   * 1) 길이가 20을 넘지 않을 것
7
   * 2) 유일무이한 값이 될 것
8
   */
9
  @Column({
10
    length: 20,
11
    unique: true,
12
  })
13
  @IsString()
14
  @Length(1, 20, {
15
    message: '닉네임은 1~20자 사이로 입력해주세요.',
16
  })
17
  nickname: string
18

19
  /*** 이메일 특성
20
   * 1) 유일무이한 값이 될 것
21
   */
22
  @Column({
23
    unique: true,
24
  })
25
  @IsString()
26
  @IsEmail()
27
  email: string
28

29
  @Column()
30
  @IsString()
31
  @Length(3, 8)
32
  password: string
33

34
  @Column({
35
    // role 특성의 타입을 RolesEnum의 모든 값들로 지정
36
    enum: Object.values(RolesEnum),
37
    default: RolesEnum.USER,
38
  })
39
  role: RolesEnum
40

41
  @OneToMany(() => PostsModel, post => post.author)
42
  posts: PostsModel[]
43
}

1
// auth.controller.ts 생략
2
@Post('register/email')
3
postRegisterEmail(@Body() body: RegisterUserDto) {
4
  return this.authService.registerWithEmail(body)
5
}

1
// auth.service.ts 생략
2
async registerWithEmail(user: RegisterUserDto) {
3
  const hash = await bcrypt.hash(user.password, HASH_ROUNDS)
4
  const newUser = await this.usersService.createUser({
5
    ...user, //
6
    password: hash,
7
  })
8
  return this.loginUser(newUser)
9
}

1
import { ValidationArguments } from 'class-validator'
2

3
/** ValidationArguments의 프로퍼티들
4
 * 1) value -> 검증되고 있는 값(입력된 값)
5
 * 2) constraints -> 파라미터에 입력된 제한사항들
6
 *    args.constraints[0] -> 1
7
 *    args.constraints[1] -> 20
8
 * 3) targetNmae -> 검증하고 있는 클래스의 이름
9
 * 4) object -> 검증하고 있는 객체
10
 * 5) property -> 검증되고 있는 객체의 프로퍼티 이름
11
 * @see https://github.com/typestack/class-validator?tab=readme-ov-file#validation-messages
12
 */
13
export const lengthValidationMessage = (args: ValidationArguments) => {
14
  if (args.constraints.length === 2) {
15
    return `${args.property}은 ${args.constraints[0]}~${args.constraints[1]} 글자를 입력해주세요!`
16
  } else {
17
    return `${args.property}은 최소 ${args.constraints[0]} 글자를 입력해주세요!`
18
  }
19
}

1
import { ValidationArguments } from 'class-validator'
2

3
export const stringValidationMessage = (args: ValidationArguments) => {
4
  return `${args.property}에 string을 입력해주세요!`
5
}

1
import { ValidationArguments } from 'class-validator'
2

3
export const emailValidationMessage = (args: ValidationArguments) => {
4
  return `${args.property}에 정확한 이메일을 입력해주세요!`
5
}

1
// 생략
2

3
@Entity()
4
export class UsersModel extends BaseModel {
5
  /*** 닉네임 특성
6
   * 1) 길이가 20을 넘지 않을 것
7
   * 2) 유일무이한 값이 될 것
8
   */
9
  @Column({
10
    length: 20,
11
    unique: true,
12
  })
13
  @IsString({
14
    message: stringValidationMessage,
15
  })
16
  @Length(1, 20, {
17
    message: lengthValidationMessage,
18
  })
19
  nickname: string
20

21
  /*** 이메일 특성
22
   * 1) 유일무이한 값이 될 것
23
   */
24
  @Column({
25
    unique: true,
26
  })
27
  @IsString({
28
    message: stringValidationMessage,
29
  })
30
  @IsEmail(
31
    {},
32
    {
33
      message: emailValidationMessage,
34
    },
35
  )
36
  email: string
37

38
  @Column()
39
  @IsString({
40
    message: stringValidationMessage,
41
  })
42
  @Length(3, 8, {
43
    message: lengthValidationMessage,
44
  })
45
  password: string
46

47
  // 생략
48
}

1
// posts.entity.ts 생략
2
@Column()
3
@IsString({
4
  message: stringValidationMessage,
5
})
6
title: string
7

8
@Column()
9
@IsString({
10
  message: stringValidationMessage,
11
})
12
content: string

1
// update-post.dto.ts 생략
2
export class UpdatePostDto extends PartialType(CreatePostDto) {
3
  @IsString({
4
    message: stringValidationMessage,
5
  })
6
  @IsOptional()
7
  title?: string
8

9
  @IsString({
10
    message: stringValidationMessage,
11
  })
12
  @IsOptional()
13
  content?: string
14
}