1
yarn add @nestjs/typeorm typeorm pg
2
yarn start:dev

1
import { Module } from '@nestjs/common'
2
import { TypeOrmModule } from '@nestjs/typeorm'
3

4
import { AppController } from './app.controller'
5
import { AppService } from './app.service'
6
import { PostsModule } from './posts/posts.module'
7

8
@Module({
9
  imports: [
10
    PostsModule,
11
    TypeOrmModule.forRoot({
12
      // 데이터베이스 타입
13
      type: 'postgres',
14
      host: '127.0.0.1',
15
      port: 5808,
16
      username: 'postgres',
17
      password: 'postgres',
18
      database: 'postgres',
19
      // entities폴더에 작성한 PostsModel 가져오기
20
      entities: [],
21
      synchronize: true,
22
    }),
23
  ],
24
  controllers: [AppController],
25
  providers: [AppService],
26
})
27
export class AppModule {}

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

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

8
  @Column()
9
  author: string
10

11
  @Column()
12
  title: string
13

14
  @Column()
15
  content: string
16

17
  @Column()
18
  likeCount: number
19

20
  @Column()
21
  commentCount: number
22
}

1
// 생략
2
import { PostsModel } from './posts/entities/posts.entity'
3

4
@Module({
5
  imports: [
6
    PostsModule,
7
    TypeOrmModule.forRoot({
8
      // 데이터베이스 타입
9
      type: 'postgres',
10
      host: '127.0.0.1',
11
      port: 5808,
12
      username: 'postgres',
13
      password: 'postgres',
14
      database: 'postgres',
15
      // entities폴더에 작성한 PostsModel 가져오기
16
      entities: [PostsModel],
17
      synchronize: true,
18
    }),
19
  ],
20
  controllers: [AppController],
21
  providers: [AppService],
22
})
23
export class AppModule {}

1
import { Module } from '@nestjs/common'
2
import { PostsService } from './posts.service'
3
import { PostsController } from './posts.controller'
4
import { TypeOrmModule } from '@nestjs/typeorm'
5
import { PostsModel } from './entities/posts.entity'
6

7
@Module({
8
  imports: [
9
    /*** 모델에 해당하는 repostory를 주입 ==> forFeature
10
     * repository : 해당 모델을 다룰 수 있게 해주는 클래스
11
     */
12
    TypeOrmModule.forFeature([PostsModel]),
13
  ],
14
  /** 컨트롤러로 사용할 파일을 정의
15
   * 컨트롤러로 사용할 파일을 정의,
16
   * 특정 path로 요청이 오면 라우팅해주는 역할
17
   *
18
   * PostsController() ===> 인스턴스화
19
   * PostsController ===> 클래스 그 자체
20
   * 잘 보면, 인스턴스가 아닌 클래스 그 자체를 넣었다
21
   * 왜냐하면 IoC 컨테이너가 인스턴스를 생성, 수정, 삭제하길 바라니까
22
   */
23
  controllers: [PostsController],
24
  /** 컨트롤러에서 주입할 값들을 providers 안에 정의
25
   * PostsService는 어떤 역할을 하는지에 대한 정의다.
26
   * 데이터를 다루는 로직을 작성하는 클래스 === Service
27
   *
28
   * 서비스가 아니더라도 주입해야할 클래스들은
29
   * 전부 providers 안에 넣어주면 된다.
30
   *
31
   * porviders 안에 등록된 모든 클래스들은 인스턴스화 없이
32
   * IoC 컨테이너가 의존하면서 사용할 수 있게 된다.
33
   */
34
  providers: [PostsService],
35
})
36
export class PostsModule {}

1
// posts.service.ts
2
import { Injectable, NotFoundException } from '@nestjs/common'
3
import { InjectRepository } from '@nestjs/typeorm'
4
import { Repository } from 'typeorm'
5
import { PostsModel } from './entities/posts.entity'
6

7
// 생략
8

9
@Injectable()
10
export class PostsService {
11
  constructor(
12
    @InjectRepository(PostsModel)
13
    private readonly postsRepository: Repository<PostsModel>,
14
  ) {}
15

16
  // 생략
17
}

1
// posts.service.ts 생략
2
async getAllPosts() {
3
  return this.postsRepository.find()
4
}

1
// posts.service.ts 생략
2
async getPostById(id: number) {
3
  const post = await this.postsRepository.findOne({
4
    // PostsModel의 id가 입력받은 id와 같은지 필터링
5
    where: {
6
      id,
7
    },
8
  })
9
  if (!post) {
10
    throw new NotFoundException()
11
  }
12
  return post
13
}

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

14
  const newPost = await this.postsRepository.save(post)
15

16
  return newPost
17
}

1
/** save의 2가지 기능
2
 * 1) 만약에 데이터가 존재하지 않는다면(id 기준) 새로 생성한다.
3
 * 2) 만약에 데이터가 존재한다면(같은 id의 값이 존재한다면) 존재하던 값을 업데이트한다.
4
 */
5
async updatePost(postId: number, author: string, title: string, content: string) {
6
  const post = await this.postsRepository.findOne({
7
    where: { id: postId },
8
  })
9

10
  if (!post) throw new NotFoundException()
11
  if (author) post.author = author
12
  if (title) post.title = title
13
  if (content) post.content = content
14

15
  const newPost = await this.postsRepository.save(post)
16
  return newPost
17
}

1
async deletePost(postId: number) {
2
  const post = await this.postsRepository.findOne({
3
    where: { id: postId },
4
  })
5

6
  if (!post) throw new NotFoundException()
7

8
  await this.postsRepository.delete(postId)
9

10
  return postId
11
}