1
-- 초기상태
2
-- Table: account
3
-- | id | balance |
4
-- |----|---------|
5
-- | 1  | 1000    |
6

7
-- 트랜잭션 1
8
BEGIN TRANSACTION;
9
SELECT balance FROM account WHERE id = 1; -- 1000 반환
10
UPDATE account SET balance = 1000 - 100 WHERE id = 1; -- 900으로 업데이트
11

12
-- 트랜잭션 2 (동시에 발생)
13
BEGIN TRANSACTION;
14
SELECT balance FROM account WHERE id = 1; -- 1000 반환
15
UPDATE account SET balance = 1000 - 200 WHERE id = 1; -- 800으로 업데이트
16

17
-- 트랜잭션 1 진행
18
COMMIT; -- Balance: 900
19

20
-- 트랜잭션 2 진행
21
COMMIT; -- Balance: 800
22

23
-- 최종 결과
24
-- | id | balance |
25
-- |----|---------|
26
-- | 1  | 800     |

1
-- 초기상태
2
-- Table: account
3
-- | id | balance |
4
-- |----|---------|
5
-- | 1  | 1000    |
6

7
-- 트랜잭션 1
8
BEGIN TRANSACTION;
9
UPDATE account SET balance = balance - 100 WHERE id = 1; -- 900으로 업데이트
10

11
-- 트랜잭션 2
12
BEGIN TRANSACTION;
13
SELECT balance FROM account WHERE id = 1; -- 900 반환
14

15
-- 트랜잭션 1 롤백
16
ROLLBACK; -- Balance: 1000으로 되돌림
17

18
-- 트랜잭션 2 진행
19
-- 트랜잭션 2에서 읽은 balance 값은 잘못된 값이다.

1
-- 초기상태
2
-- Table: account
3
-- | id | balance |
4
-- |----|---------|
5
-- | 1  | 1000    |
6

7
-- 트랜잭션 1
8
BEGIN TRANSACTION;
9
SELECT balance FROM account WHERE id = 1; -- 1000 반환
10

11
-- 트랜잭션 2
12
BEGIN TRANSACTION;
13
UPDATE account SET balance = balance - 100 WHERE id = 1; -- 900으로 업데이트
14

15
-- 트랜잭션 1 진행
16
SELECT balance FROM account WHERE id = 1; -- 900 반환 (non-repeatable read)
17
COMMIT;

1
--- 초기상태
2
--- Table: account
3
--- | id | balance |
4
--- |----|---------|
5
--- | 1  | 1000    |
6
--- | 2  | 1500    |
7

8
--- 트랜잭션 1
9
BEGIN TRANSACTION;
10
SELECT * FROM account WHERE balance > 1000; -- 1500 반환
11

12
--- 트랜잭션 2
13
BEGIN TRANSACTION;
14
INSERT INTO account (id, balance) VALUES (3, 1200);
15
COMMIT;
16

17
-- 트랜잭션 1
18
SELECT * FROM account WHERE balance > 1000; -- 1500, 1200 반환 (phantom read)
19
COMMIT;

1
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
2
BEGIN TRANSACTION;
3
--- SQL 작업
4
COMMIT;

1
/*** 3) POST /posts
2
 * post를 생성한다
3
 *
4
 * A Model, B Model
5
 * Post API -> A모델을 저장하고, B모델을 저장한다.
6
 * await repository.save(a)
7
 * await repository.save(b)
8
 *
9
 * 만약에 a를 저장하다가 실패하면 b를 저장하면 안될 경우
10
 * 이 경우를 막기 위해 등장한 것이 Transaction
11
 * all or nothing
12
 *
13
 * Transaction
14
 * start -> 시작
15
 * commit -> 저장
16
 * rollback -> 원상복구
17
 */
18
@Post()
19
@UseGuards(AccessTokenGuard)
20
async postPosts(
21
  // 생략
22
) {
23
  await this.postsService.createPostImage(body)
24
  return this.postsService.createPost(userId, body)
25
}

1
import { IsEnum, IsInt, IsOptional, IsString } from 'class-validator'
2
import { Transform } from 'class-transformer'
3

4
import { Column, Entity, ManyToOne } from 'typeorm'
5
import { join } from 'path'
6
import { BaseModel } from './base.entity'
7
import { PostsModel } from '../../posts/entities/posts.entity'
8
import { POST_PUBLIC_IMAGE_PATH } from '../const/path.const'
9

10
export enum ImageModelType {
11
  POST_IMAGE,
12
}
13

14
@Entity()
15
export class ImageModel extends BaseModel {
16
  @Column({
17
    default: 0,
18
  })
19
  @IsInt()
20
  @IsOptional()
21
  order: number
22

23
  /***
24
   * UserModel -> 사용자 프로필 이미지
25
   * PostsModel -> 포스트 이미지
26
   */
27
  @Column({
28
    enum: ImageModelType,
29
  })
30
  @IsEnum(ImageModelType)
31
  @IsString()
32
  type: ImageModelType
33

34
  @Column()
35
  @IsString()
36
  @Transform(({ value, obj }) => {
37
    // obj는 이미지 모델이 생성됐을 떄의, 현재 객체를 의미
38
    if (obj.type === ImageModelType.POST_IMAGE) {
39
      return `/${join(POST_PUBLIC_IMAGE_PATH, value)}`
40
    } else {
41
      return value
42
    }
43
  })
44
  path: string
45

46
  @ManyToOne(type => PostsModel, post => post.images)
47
  post?: PostsModel
48
}

1
// posts.entity.ts 생략
2

3
@Entity()
4
export class PostsModel extends BaseModel {
5
  // 생략
6

7
  @OneToMany(() => ImageModel, image => image.post)
8
  images: ImageModel[]
9
}

1
// app.module.ts 생략
2
@Module({
3
  imports: [
4
    // 생략
5
    TypeOrmModule.forRoot({
6
      // 생략
7
      // entities폴더에 작성한 PostsModel 가져오기
8
      entities: [PostsModel, UsersModel, ImageModel],
9
      synchronize: true,
10
    }),
11
    UsersModule,
12
    AuthModule,
13
    CommonModule,
14
  ],
15
  // 생략
16
})

1
import { FindManyOptions } from 'typeorm'
2
import { PostsModel } from '../entities/posts.entity'
3

4
export const DEFAULT_POST_FIND_OPTIONS: FindManyOptions<PostsModel> = {
5
  relations: {
6
    author: true,
7
    images: true,
8
  },
9
}

1
import { PickType } from '@nestjs/mapped-types'
2
import { ImageModel } from 'src/common/entities/image.entity'
3

4
export class CreatePostImageDto extends PickType(ImageModel, [
5
  'path', //
6
  'post',
7
  'order',
8
  'type',
9
]) {}

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

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

6
export class CreatePostDto extends PickType(PostsModel, ['title', 'content']) {
7
  @IsString({
8
    each: true, // 리스트 개별 요소마다 string으로 할지
9
  })
10
  @IsOptional()
11
  images: string[] = []
12
}

1
// posts.controller.ts 생략
2
@Post()
3
@UseGuards(AccessTokenGuard)
4
async 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
  const post = await this.postsService.createPost(userId, body)
13
  for (let i = 0; i < body.images.length; i++) {
14
    await this.postsService.createPostImage({
15
      post,
16
      order: i,
17
      path: body.images[i],
18
      type: ImageModelType.POST_IMAGE,
19
    })
20
  }
21
  return this.postsService.getPostById(post.id)
22
}

1
// 생략
2
@Injectable()
3
export class PostsService {
4
  constructor(
5
    @InjectRepository(PostsModel)
6
    private readonly postsRepository: Repository<PostsModel>,
7
    @InjectRepository(ImageModel)
8
    private readonly imageRepository: Repository<ImageModel>,
9
    private readonly commonService: CommonService,
10
    private readonly configService: ConfigService,
11
  ) {}
12

13
  async getAllPosts() {
14
    return this.postsRepository.find({ ...DEFAULT_POST_FIND_OPTIONS })
15
  }
16

17
  async generatePosts(userId: number) {
18
    for (let i = 0; i < 100; i++) {
19
      await this.createPost(userId, {
20
        title: `임의로 생성된 포스트 제목 ${i}`,
21
        content: `임의로 생성된 포스트 내용 ${i}`,
22
        images: [],
23
      })
24
    }
25
  }
26

27
  async paginatePosts(dto: PaginatePostDto) {
28
    return this.commonService.paginate(
29
      dto, //
30
      this.postsRepository,
31
      { ...DEFAULT_POST_FIND_OPTIONS },
32
      'posts',
33
    )
34
  }
35

36
  async getPostById(id: number) {
37
    const post = await this.postsRepository.findOne({
38
      ...DEFAULT_POST_FIND_OPTIONS,
39
      // PostsModel의 id가 입력받은 id와 같은지 필터링
40
      where: {
41
        id,
42
      },
43
    })
44
    // 생략
45
  }
46

47
  async createPost(authorId: number, postDto: CreatePostDto) {
48
    const post = this.postsRepository.create({
49
      author: {
50
        id: authorId,
51
      },
52
      ...postDto,
53
      images: [],
54
      likeCount: 0,
55
      commentCount: 0,
56
    })
57
    const newPost = await this.postsRepository.save(post)
58
    return newPost
59
  }
60

61
  async createPostImage(dto: CreatePostImageDto) {
62
    // 생략
63

64
    // save
65
    const result = await this.imageRepository.save({
66
      ...dto,
67
    })
68

69
    // 파일 옮기기
70
    await promises.rename(tempFilePath, publicFilePath)
71

72
    return result
73
  }
74
  // 생략
75
}

1
// posts.module.ts 생략
2
@Module({
3
  imports: [
4
    /*** 모델에 해당하는 repostory를 주입 ==> forFeature
5
     * repository : 해당 모델을 다룰 수 있게 해주는 클래스
6
     */
7
    TypeOrmModule.forFeature([
8
      PostsModel, //
9
      ImageModel,
10
    ]),
11
    AuthModule,
12
    UsersModule,
13
    CommonModule,
14
  ],
15
  // 생략
16
})
17
export class PostsModule {}

1
// posts.controller.ts 생략
2
@Post()
3
@UseGuards(AccessTokenGuard)
4
async 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
  // (1) 트랜잭션과 관련된 모든 쿼리를 담당할 쿼리 러너(qr)를 생성한다.
13
  const qr = this.dataSource.createQueryRunner()
14

15
  // (2) 쿼리 러너에 연결한다.
16
  await qr.connect()
17
  /*** 쿼리 러너에서 트랜잭션을 시작한다.
18
   * 이 시점부터 같은 쿼리 러너를 사용하면
19
   * 트랜잭션 안에서 데이터베이스 액션을 실행한다.
20
   */
21
  await qr.startTransaction()
22

23
  // 로직실행
24
  try {
25
    const post = await this.postsService.createPost(userId, body)
26
    for (let i = 0; i < body.images.length; i++) {
27
      await this.postsService.createPostImage({
28
        post,
29
        order: i,
30
        path: body.images[i],
31
        type: ImageModelType.POST_IMAGE,
32
      })
33
    }
34
    await qr.commitTransaction()
35
    await qr.release()
36
    return this.postsService.getPostById(post.id)
37
  } catch (e) {
38
    // 어떤 에러든 에러가 던져지면, 트랜잭션을 종료하고 원래 상태로 되돌린다.
39
    await qr.rollbackTransaction()
40
    await qr.release()
41
  }
42
}

1
// posts.service.ts 생략
2
getRepository(qr?: QueryRunner) {
3
  return qr
4
    ? qr.manager.getRepository<PostsModel>(PostsModel) //
5
    : this.postsRepository
6
}
7

8
async createPost(authorId: number, postDto: CreatePostDto, qr?: QueryRunner) {
9
  const repository = this.getRepository(qr)
10

11
  const post = repository.create({
12
    author: {
13
      id: authorId,
14
    },
15
    ...postDto,
16
    images: [],
17
    likeCount: 0,
18
    commentCount: 0,
19
  })
20
  const newPost = await repository.save(post)
21
  return newPost
22
}

1
import { BadRequestException, Injectable } from '@nestjs/common'
2
import { InjectRepository } from '@nestjs/typeorm'
3
import { QueryRunner, Repository } from 'typeorm'
4
import { basename, join } from 'path'
5

6
import { promises } from 'fs'
7
import { CreatePostImageDto } from './dto/create-image.dto'
8
import { ImageModel } from 'src/common/entities/image.entity'
9
import { POST_IMAGE_PATH, TEMP_FOLDER_PATH } from 'src/common/const/path.const'
10

11
@Injectable()
12
export class PostsImagesService {
13
  constructor(
14
    @InjectRepository(ImageModel)
15
    private readonly imageRepository: Repository<ImageModel>,
16
  ) {}
17

18
  getRepository(qr?: QueryRunner) {
19
    return qr
20
      ? qr.manager.getRepository<ImageModel>(ImageModel) //
21
      : this.imageRepository
22
  }
23

24
  async createPostImage(dto: CreatePostImageDto, qr?: QueryRunner) {
25
    const repository = qr.manager.getRepository<ImageModel>(ImageModel)
26

27
    // dto의 이미지 이름을 기반으로 파일 경로를 생성한다
28
    const tempFilePath = join(TEMP_FOLDER_PATH, dto.path)
29

30
    try {
31
      /*** promises의 fs 모듈을 import
32
       * 파일이 존재하는지 확인
33
       * 만약에 존재하지 않는다면 에러를 던짐
34
       */
35
      await promises.access(tempFilePath)
36
    } catch (e) {
37
      throw new BadRequestException('존재하지 않는 임시 파일입니다!')
38
    }
39

40
    /*** 파일의 이름만 가져오기
41
     * /USers/aaa/bbb/ccc/asdf.jpg -> asdf.jpg
42
     */
43
    const fileName = basename(tempFilePath)
44

45
    /*** 새로 이동할 포스트 폴더의 경로 + 이미지의 이름
46
     * {프로젝트경로}/public/posts/asdf.jpg
47
     */
48
    const publicFilePath = join(POST_IMAGE_PATH, fileName)
49

50
    // save
51
    const result = await repository.save({
52
      ...dto,
53
    })
54

55
    // 파일 옮기기
56
    await promises.rename(tempFilePath, publicFilePath)
57

58
    return result
59
  }
60
}

1
// 생략
2

3
@Controller('posts')
4
export class PostsController {
5
  constructor(
6
    private readonly postsService: PostsService,
7
    private readonly postsImagesService: PostsImagesService, // 추가
8
    private readonly dataSource: DataSource,
9
  ) {}
10
  // 생략
11
  @Post()
12
  @UseGuards(AccessTokenGuard)
13
  async postPosts(
14
    // 생략
15
    try {
16
      const post = await this.postsService.createPost(userId, body, qr)
17
      // throw new InternalServerErrorException('일부러 에러 발생 테스트')
18
      for (let i = 0; i < body.images.length; i++) {
19
        await this.postsImagesService.createPostImage(
20
          {
21
            post,
22
            order: i,
23
            path: body.images[i],
24
            type: ImageModelType.POST_IMAGE,
25
          },
26
          qr,
27
        )
28
      }
29
      await qr.commitTransaction()
30
      await qr.release()
31
      return this.postsService.getPostById(post.id)
32
    } catch (e) {
33
      // 어떤 에러든 에러가 던져지면, 트랜잭션을 종료하고 원래 상태로 되돌린다.
34
      await qr.rollbackTransaction()
35
      await qr.release()
36
      throw new InternalServerErrorException('에러가 발생했습니다.')
37
    }
38
  }
39
}

1
// 생략
2
@Module({
3
  // 생략
4
  providers: [PostsService, PostsImagesService],
5
})
6
export class PostsModule {}