1
nest g resource
2
? What name would you like to use for this resource? users
3
? What transport layer do you use? REST API
4
? Would you like to generate CRUD entry points? No

1
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'
2

3
@Entity()
4
export class UsersModel {
5
  @PrimaryGeneratedColumn()
6
  id: number
7

8
  @Column()
9
  nickname: string
10

11
  @Column()
12
  email: string
13

14
  @Column()
15
  password: string
16
}

1
@Module({
2
imports: [
3
  PostsModule,
4
  TypeOrmModule.forRoot({
5
    // 생략
6
    // entities폴더에 작성한 모듈 가져오기
7
    entities: [PostsModel, UsersModel],
8
    synchronize: true,
9
  }),
10
  UsersModule,
11
],
12
controllers: [AppController],
13
providers: [AppService],
14
})

1
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'
2

3
@Entity()
4
export class UsersModel {
5
  @PrimaryGeneratedColumn()
6
  id: number
7

8
  /*** 닉네임 특성
9
   * 1) 길이가 20을 넘지 않을 것
10
   * 2) 유일무이한 값이 될 것
11
   */
12
  @Column({
13
    length: 20,
14
    unique: true,
15
  })
16
  nickname: string
17

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

26
  @Column()
27
  password: string
28
}

1
export enum RolesEnum {
2
  ADMIN = 'ADMIN',
3
  USER = 'USER',
4
}

1
@Entity()
2
export class UsersModel {
3
  // 생략
4

5
  @Column({
6
    // role 특성의 타입을 RolesEnum의 모든 값들로 지정
7
    enum: Object.values(RolesEnum),
8
    default: RolesEnum.USER,
9
  })
10
  role: RolesEnum
11
}

1
// 생략
2

3
@Module({
4
  // 이 모듈 안에서 UsersModel을 어디서든 사용 가능
5
  imports: [TypeOrmModule.forFeature([UsersModel])],
6
  controllers: [UsersController],
7
  providers: [UsersService],
8
})
9
export class UsersModule {}

1
import { Injectable } from '@nestjs/common'
2
import { InjectRepository } from '@nestjs/typeorm'
3
import { UsersModel } from './entities/users.entity'
4
import { Repository } from 'typeorm'
5

6
@Injectable()
7
export class UsersService {
8
  constructor(
9
    @InjectRepository(UsersModel)
10
    private readonly userRepository: Repository<UsersModel>,
11
  ) {}
12

13
  async createUser(nickname: string, email: string, password: string) {
14
    const user = this.userRepository.create({
15
      nickname,
16
      email,
17
      password,
18
    })
19
    const newUser = await this.userRepository.save(user)
20
    return newUser
21
  }
22

23
  async getAllUsers() {
24
    return this.userRepository.find()
25
  }
26
}

1
import { Body, Controller, Get, Post } from '@nestjs/common'
2
import { UsersService } from './users.service'
3

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

8
  @Get()
9
  getUsers() {
10
    return this.usersService.getAllUsers()
11
  }
12

13
  @Post()
14
  postUser(
15
    @Body('nickname') nickname: string, //
16
    @Body('email') email: string,
17
    @Body('password') password: string,
18
  ) {
19
    return this.usersService.createUser(nickname, email, password)
20
  }
21
}

1
@Entity()
2
export class PostsModel {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  /*** 작성자 1명이 여러 개의 포스트를 작성
7
   * 1) UserModel과 연동한다 (Foreign Key를 사용해서)
8
   * 2) null이 될 수 없다
9
   */
10
  // one에 해당하는 클래스 타입을 넣어주면 된다
11
  // 이 클래스 타입을 두 번쨰 함수의 파라미터로 받을 수 있다.
12
  // 어떤 파라미터와 연동시킬지 선택
13
  @ManyToOne(() => UsersModel, user => user.posts, {
14
    nullable: false,
15
  })
16
  author: UsersModel
17

18
  // 생략
19
}

1
@Entity()
2
export class UsersModel {
3
  // 생략
4

5
  @OneToMany(() => PostsModel, post => post.author)
6
  posts: PostsModel[]
7
}

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

17
  const newPost = await this.postsRepository.save(post)
18

19
  return newPost
20
}
21

22
/** save의 2가지 기능
23
 * 1) 만약에 데이터가 존재하지 않는다면(id 기준) 새로 생성한다.
24
 * 2) 만약에 데이터가 존재한다면(같은 id의 값이 존재한다면) 존재하던 값을 업데이트한다.
25
 */
26
async updatePost(postId: number, title: string, content: string) {
27
  const post = await this.postsRepository.findOne({
28
    where: { id: postId },
29
  })
30

31
  if (!post) throw new NotFoundException()
32
  if (title) post.title = title
33
  if (content) post.content = content
34

35
  const newPost = await this.postsRepository.save(post)
36
  return newPost
37
}

1
// posts.controller.ts 생략
2
/*** 3) POST /posts
3
 * post를 생성한다
4
 */
5
@Post()
6
postPosts(
7
  @Body('authorId') authorId: number, //
8
  @Body('title') title: string,
9
  @Body('content') content: string,
10
) {
11
  return this.postsService.createPost(authorId, title, content)
12
}
13

14
/*** 4) PATCH /posts/:id
15
 * id에 해당하는 post를 부분 변경한다
16
 */
17
@Patch(':id')
18
putPost(
19
  @Param('id') id: string, //
20
  @Body('title') title?: string,
21
  @Body('content') content?: string,
22
) {
23
  return this.postsService.updatePost(+id, title, content)
24
}

1
// posts.service.ts 생략
2
async getAllPosts() {
3
  return this.postsRepository.find({ relations: ['author'] })
4
}
5

6
async getPostById(id: number) {
7
  const post = await this.postsRepository.findOne({
8
    // PostsModel의 id가 입력받은 id와 같은지 필터링
9
    where: {
10
      id,
11
    },
12
    relations: ['author'],
13
  })
14
  if (!post) {
15
    throw new NotFoundException()
16
  }
17
  return post
18
}