ci: 운영 서버 배포

.github/workflows/deploy-dev.yml

@@ -39,5 +39,8 @@ jobs:
             SERVICE_KEY=${{ secrets.OPENAPI_HOLIDAY_SERVICE_KEY }}
             SLACK_BOT_USER_OAUTH_ACCESS_TOKEN=${{ secrets.SLACK_BOT_USER_OAUTH_ACCESS_TOKEN_DEV }}
             SLACK_CHANNEL_JIPHYEONJEON=${{ secrets.SLACK_CHANNEL_JIPHYEONJEON_DEV }}
+            AWS_CLOUDWATCH_LOG_GROUP=${{ secrets.AWS_CLOUDWATCH_LOG_GROUP_DEV }}
+            AWS_CLOUDWATCH_REGION=${{ secrets.AWS_CLOUDWATCH_REGION }}
+            AWS_CLOUDWATCH_LOG_STREAM_BACKEND=${{ secrets.AWS_CLOUDWATCH_LOG_STREAM_BACKEND }}
             FRONT_URL=${{ secrets.FRONT_URL_DEV }}" > .env.dev
             docker-compose --env-file .env.dev up -d --build backend_dev

.github/workflows/deploy-main.yml

@@ -39,5 +39,8 @@ jobs:
             SERVICE_KEY=${{ secrets.OPENAPI_HOLIDAY_SERVICE_KEY }}
             SLACK_BOT_USER_OAUTH_ACCESS_TOKEN=${{ secrets.SLACK_BOT_USER_OAUTH_ACCESS_TOKEN }}
             SLACK_CHANNEL_JIPHYEONJEON=${{ secrets.SLACK_CHANNEL_JIPHYEONJEON }}
+            AWS_CLOUDWATCH_LOG_GROUP=${{ secrets.AWS_CLOUDWATCH_LOG_GROUP }}
+            AWS_CLOUDWATCH_REGION=${{ secrets.AWS_CLOUDWATCH_REGION }}
+            AWS_CLOUDWATCH_LOG_STREAM_BACKEND=${{ secrets.AWS_CLOUDWATCH_LOG_STREAM_BACKEND }}
             FRONT_URL=${{ secrets.FRONT_URL }}" > .env.prod
             docker-compose --env-file .env.prod up -d --build backend

README.md

@@ -8,7 +8,8 @@
 
 ## Description
 친해지길 바라 백엔드를 리팩토링합니다.
-- DB 스키마 및 REST API 재설계
+- [REST API 재설계](https://github.com/Together42/nest-backend/wiki/API-%EB%B3%80%EA%B2%BD-%EC%82%AC%ED%95%AD)
+- [DB 스키마 재설계](https://github.com/Together42/nest-backend/wiki/DB-%EB%B3%80%EA%B2%BD-%EC%82%AC%ED%95%AD)
 - JavaScript/Express -> TypeScript/NestJS
 - Raw Query -> TypeORM
 
@@ -37,6 +38,11 @@
 
 <br>
 
+## 서비스 아키텍처
+![아키텍처](https://github.com/Together42/nest-backend/assets/74581396/761238a0-6b7e-4307-b24e-06d675d801c2)
+
+<br>
+
 ## 실행 방법
 ### 1. git clone
 ```sh
@@ -101,6 +107,11 @@ yarn install && yarn start:dev
 
 <br>
 
+## API 명세
+[Swagger Docs](https://dev.together.42jip.net/swagger)
+
+<br>
+
 ## License
 
 Nest is [MIT licensed](LICENSE).

src/app.module.ts

@@ -12,6 +12,10 @@ import { CqrsModule } from '@nestjs/cqrs';
 import { AuthModule } from './auth/auth.module';
 import { UserModule } from './user/user.module';
 import configuration from './config/configuration';
+import { APP_FILTER, APP_INTERCEPTOR } from '@nestjs/core';
+import { ServiceExceptionFilter } from './common/exception-filter/service.exception-filter';
+import { LogInterceptor } from './common/interceptor/log.interceptor';
+import { UnknownExceptionFilter } from './common/exception-filter/unknown.exception-filter';
 
 @Module({
   imports: [
@@ -57,6 +61,11 @@ import configuration from './config/configuration';
     BatchModule,
   ],
   controllers: [AppController],
-  providers: [AppService],
+  providers: [
+    AppService,
+    { provide: APP_FILTER, useClass: UnknownExceptionFilter },
+    { provide: APP_FILTER, useClass: ServiceExceptionFilter },
+    { provide: APP_INTERCEPTOR, useClass: LogInterceptor },
+  ],
 })
 export class AppModule {}

src/auth/auth.service.ts

@@ -53,7 +53,6 @@ export class AuthService {
       const accessToken: string = await this.generateToken(user);
       return { accessToken };
     } catch (error) {
-      this.logger.error(`refreshAccessToken [error: ${error.message}]`);
       throw new UnauthorizedException('Unauthorized', '401');
     }
   }

src/auth/guard/jwt.guard.ts

@@ -1,6 +1,7 @@
 import { Injectable, ExecutionContext, Logger } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 import { JwtService } from '@nestjs/jwt';
+import { UnknownException } from 'src/common/exception/unknown.exception';
 
 @Injectable()
 export class JwtGuard extends AuthGuard('jwt') {
@@ -35,7 +36,7 @@ export class JwtGuard extends AuthGuard('jwt') {
       token could be expired or invaild
       return exception to client and let client to refresh token
       */
-      throw error;
+      throw new UnknownException(error);
     }
     this.logger.debug(`canActivate [result: ${result}]`);
     return result;

src/auth/strategy/jwt.strategy.ts

@@ -19,7 +19,6 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
     try {
       done(null, payload);
     } catch (error) {
-      this.logger.error(`validate [error: ${error.message}]`);
       throw new UnauthorizedException('Unauthorized', '401');
     }
   }

src/batch/batch.service.ts

@@ -35,10 +35,12 @@ export class BatchService {
         try {
           await this.meetupsService.createMatching({ meetupId, teamNum: 1 });
         } catch (e) {
-          this.logger.error('[createWeeklyMeeting]', e);
+          this.logger.error(`[createWeeklyMeeting] meetupId: ${meetupId}`);
+          this.logger.error(e);
         }
       },
     });
+    this.logger.debug(`[createWeeklyMeeting] matchWeeklyMeeting: `, cronJob);
     this.schedulerReistry.addCronJob('matchWeeklyMeeting', cronJob);
     cronJob.start();
   }
@@ -60,10 +62,12 @@ export class BatchService {
         try {
           await this.meetupsService.createMatching({ meetupId, teamNum: 1 });
         } catch (e) {
-          this.logger.error('[createWeeklyDinner]', e);
+          this.logger.error(`[createWeeklyDinner] meetupId: ${meetupId}`);
+          this.logger.error(e);
         }
       },
     });
+    this.logger.debug(`[createWeeklyDinner] matchWeeklyDinner: `, cronJob);
     this.schedulerReistry.addCronJob('matchWeeklyDinner', cronJob);
     cronJob.start();
   }

src/common/enum/error-message.enum.ts

@@ -6,5 +6,9 @@ export enum ErrorMessage {
   MEETUP_REGISTRATION_ALREADY_EXIST = '이미 신청한 이벤트 입니다.',
   TOO_MANY_MEETUP_TEAM_NUMBER = '신청 인원보다 팀 개수가 많습니다.',
 
-  USER_NOT_FOUND = '존재하지 않는 유저입니다.'
+  USER_NOT_FOUND = '존재하지 않는 유저입니다.',
+
+  HASH_TOKEN_ERROR = 'HASH_TOKEN_ERROR'
 }
+
+export type KeyOfErrorMessage = keyof typeof ErrorMessage;

src/common/exception-filter/service.exception-filter.ts

@@ -0,0 +1,19 @@
+import { ArgumentsHost, Catch, ExceptionFilter, Logger } from '@nestjs/common';
+import { ServiceException } from '../exception/service.exception';
+
+@Catch(ServiceException)
+export class ServiceExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(ServiceExceptionFilter.name);
+
+  catch(exception: ServiceException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const status = exception.getStatus();
+
+    response.status(status).json({
+      statusCode: status,
+      errorCode: exception.getErrorCode(),
+      message: exception.getMessage(),
+    });
+  }
+}

src/common/exception-filter/unknown.exception-filter.ts

@@ -0,0 +1,18 @@
+import { ArgumentsHost, Catch, ExceptionFilter, HttpStatus, Logger } from '@nestjs/common';
+import { STATUS_CODES } from 'http';
+import { UnknownException } from '../exception/unknown.exception';
+
+@Catch(UnknownException)
+export class UnknownExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(UnknownExceptionFilter.name);
+  catch(exception: Error, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const status = HttpStatus.INTERNAL_SERVER_ERROR;
+
+    response.status(status).json({
+      statusCode: status,
+      message: exception.message || STATUS_CODES[status],
+    });
+  }
+}

src/common/exception/service.exception.ts

@@ -0,0 +1,25 @@
+import { ErrorMessage, KeyOfErrorMessage } from '../enum/error-message.enum';
+
+export class ServiceException extends Error {
+  private readonly status: number;
+  private readonly errorCode: string;
+
+  constructor(errorCode: KeyOfErrorMessage, status: number, message?: string) {
+    super(message || ErrorMessage[errorCode]);
+    this.name = errorCode;
+    this.status = status;
+    this.errorCode = errorCode;
+  }
+
+  getStatus() {
+    return this.status;
+  }
+
+  getErrorCode() {
+    return this.errorCode;
+  }
+
+  getMessage() {
+    return this.message;
+  }
+}

src/common/exception/unknown.exception.ts

@@ -0,0 +1,12 @@
+export class UnknownException extends Error {
+  private readonly status: number;
+
+  constructor(e?: Error) {
+    super(e?.message || 'Unknown Error');
+    this.name = UnknownException.name;
+  }
+
+  getMessage() {
+    return this.message;
+  }
+}

src/common/interceptor/log.interceptor.ts

@@ -0,0 +1,49 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  HttpException,
+  Injectable,
+  Logger,
+  NestInterceptor,
+} from '@nestjs/common';
+import { Observable, catchError } from 'rxjs';
+import { ServiceException } from '../exception/service.exception';
+import { UnknownException } from '../exception/unknown.exception';
+import { SlackService } from 'nestjs-slack';
+import { Message } from 'slack-block-builder';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class LogInterceptor implements NestInterceptor {
+  private readonly logger = new Logger(LogInterceptor.name);
+
+  constructor(
+    private slackService: SlackService,
+    private configService: ConfigService,
+  ) {}
+
+  intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> {
+    // const start = new Date();
+    const request = context.switchToHttp().getRequest();
+
+    return next.handle().pipe(
+      catchError((err) => {
+        const log = `${request.method} ${request.url} - ${err.stack}`;
+        this.logger.error(log);
+        if (err instanceof ServiceException || err instanceof HttpException) {
+          throw err;
+        }
+        this.slackService.postMessage(
+          Message({
+            text: log,
+            channel: this.configService.get('slack.jiphyeonjeonChannel'),
+          }).buildToObject(),
+        );
+        throw new UnknownException(err);
+      }),
+      //   tap((observable) => {
+      //     const end = new Date();
+      //   }),
+    );
+  }
+}

src/common/interceptor/transaction.interceptor.ts

@@ -0,0 +1,48 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor,
+} from '@nestjs/common';
+import {
+  catchError,
+  finalize,
+  Observable,
+  concatMap,
+} from 'rxjs';
+import { QueryRunner, DataSource } from 'typeorm';
+
+@Injectable()
+export class TransactionInterceptor implements NestInterceptor {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async intercept(
+    context: ExecutionContext,
+    next: CallHandler<any>,
+  ) : Promise<Observable<any>> {
+    const request = context.switchToHttp().getRequest();
+    const queryRunner: QueryRunner = await this.initRunner();
+    request.queryRunnerManager = queryRunner.manager;
+
+    return next.handle().pipe(
+      concatMap(async (data) => {
+        await queryRunner.commitTransaction();
+        return data;
+      }),
+      catchError(async (error) => {
+        await queryRunner.rollbackTransaction();
+        throw error;
+      }),
+      finalize(async () => {
+        await queryRunner.release();
+      }),
+    );
+  }
+
+  private async initRunner(): Promise<QueryRunner> {
+    const queryRunner: QueryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    return queryRunner;
+  }
+}

src/decorator/transaction.decorator.ts

@@ -0,0 +1,8 @@
+import { ExecutionContext, createParamDecorator } from "@nestjs/common";
+
+export const TransactionManager = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.queryRunnerManager;
+  }
+)