1
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
2
import { Observable } from 'rxjs'
3
import { tap } from 'rxjs/operators'
4

5
@Injectable()
6
export class LoggingInterceptor implements NestInterceptor {
7
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
8
    console.log('Before...')
9

10
    const now = Date.now()
11
    return next
12
      .handle() //
13
      .pipe(tap(() => console.log(`After... ${Date.now() - now}ms`)))
14
  }
15
}

1
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common'
2
import { Observable, tap } from 'rxjs'
3

4
@Injectable()
5
export class LogInterceptor implements NestInterceptor {
6
  intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> {
7
    /**
8
     * 요청이 들어올때 REQ 요청이 들어온 타임스탬프를 찍는다.
9
     * [REQ] {요청 path} {요청 시간}
10
     *
11
     * 요청이 끝날때 (응답이 나갈때) 다시 타임스탬프를 찍는다.
12
     * [RES] {요청 path} {응답 시간} {얼마나 걸렸는지 ms}
13
     */
14
    const now = new Date()
15

16
    const req = context.switchToHttp().getRequest()
17

18
    /***
19
     * /posts
20
     * /common/image
21
     */
22
    const path = req.originalUrl
23

24
    // [REQ] {요청 path} {요청 시간}
25
    console.log(`[REQ] ${path} ${now.toLocaleString('kr')}`)
26

27
    /***
28
     * return next.handle()을 실행하는 순간
29
     * 라우트의 로직이 전부 실행되고 응답이 반환된다.
30
     * observable로
31
     */
32
    return next.handle().pipe(
33
      tap(
34
        // [RES] {요청 path} {응답 시간} {얼마나 걸렸는지 ms}
35
        observable =>
36
          console.log(
37
            `[RES] ${path} ${new Date().toLocaleString('kr')} ${
38
              new Date().getMilliseconds() - now.getMilliseconds()
39
            }ms`,
40
          ),
41
      ),
42
    )
43
  }
44
}

1
// posts.controller.ts 생략
2
/*** 1) GET /posts
3
 * 모든 post를 다 가져온다
4
 */
5
@Get()
6
@UseInterceptors(LogInterceptor)
7
getPosts(@Query() query: PaginatePostDto) {
8
  return this.postsService.paginatePosts(query)
9
}

1
import {
2
  CallHandler,
3
  ExecutionContext,
4
  Injectable,
5
  InternalServerErrorException,
6
  NestInterceptor,
7
} from '@nestjs/common'
8
import { Observable, catchError, tap } from 'rxjs'
9
import { DataSource } from 'typeorm'
10

11
@Injectable()
12
export class TransactionInterceptor implements NestInterceptor {
13
  constructor(private readonly dataSource: DataSource) {}
14

15
  async intercept(context: ExecutionContext, next: CallHandler<any>): Promise<Observable<any>> {
16
    const req = context.switchToHttp().getRequest()
17

18
    // 트랜잭션과 관련되 모든 쿼리를 담당할 쿼리 러너를 생성한다.
19
    const qr = this.dataSource.createQueryRunner()
20

21
    // 쿼리 러너에 연결한다.
22
    await qr.connect()
23

24
    /*** 쿼리 러너에서 트랜잭션을 시작한다.
25
     * 이 시점부터 같은 쿼리 러너를 사용하면, 트랜잭션 안에서 데이터베이스 액션을 실행 할 수 있다.
26
     */
27
    await qr.startTransaction()
28

29
    req.queryRunner = qr
30

31
    return next.handle().pipe(
32
      catchError(async e => {
33
        await qr.rollbackTransaction()
34
        await qr.release()
35

36
        throw new InternalServerErrorException(e.message)
37
      }),
38
      tap(async () => {
39
        await qr.commitTransaction()
40
        await qr.release()
41
      }),
42
    )
43
  }
44
}

1
import { ExecutionContext, InternalServerErrorException, createParamDecorator } from '@nestjs/common'
2

3
export const QueryRunner = createParamDecorator((data, context: ExecutionContext) => {
4
  const req = context.switchToHttp().getRequest()
5

6
  if (!req.queryRunner) {
7
    throw new InternalServerErrorException(
8
      `QueryRunner Decorator를 사용하려면 TransactionInterceptor를 적용해야 합니다.`,
9
    )
10
  }
11

12
  return req.queryRunner
13
})

1
// 생략
2
import { DataSource, QueryRunner as QR } from 'typeorm'
3
import { TransactionInterceptor } from 'src/common/interceptor/transaction.interceptor'
4
import { QueryRunner } from 'src/common/decorator/query-runner.decorator'
5

6
// 생략
7
@Post()
8
@UseGuards(AccessTokenGuard)
9
@UseInterceptors(TransactionInterceptor)
10
async postPosts(
11
  @User('id') userId: number, //
12
  @Body() body: CreatePostDto,
13
  @QueryRunner() qr: QR,
14
  // 기본값을 true로 설정하는 파이프
15
  // @Body('isPublic', new DefaultValuePipe(true)) isPublic: boolean,
16
) {
17
  const post = await this.postsService.createPost(userId, body, qr)
18

19
  for (let i = 0; i < body.images.length; i++) {
20
    await this.postsImagesService.createPostImage(
21
      {
22
        post,
23
        order: i,
24
        path: body.images[i],
25
        type: ImageModelType.POST_IMAGE,
26
      },
27
      qr,
28
    )
29
  }
30
  return this.postsService.getPostById(post.id, qr)
31
}

1
// posts.service.ts 생략
2
// **** 6) ID별 포스트 가져오기
3
async getPostById(id: number, qr?: QueryRunner) {
4
  const repository = this.getRepository(qr)
5
  const post = await repository.findOne({
6
    ...DEFAULT_POST_FIND_OPTIONS,
7
    // PostsModel의 id가 입력받은 id와 같은지 필터링
8
    where: {
9
      id,
10
    },
11
  })
12
  if (!post) {
13
    throw new NotFoundException()
14
  }
15
  return post
16
}