Merge pull request #64 from boostcampwm-2024/develop

1.1.1 버전 배포

Author: github-actions[bot]

.github/workflows/auto-assign-merge.yml

@@ -68,9 +68,9 @@ jobs:
                           ? context.payload.pull_request.requested_reviewers.map(r => r.login)
                           : [];
 
-                      const BE_reviewers = ['summersummerwhy', 'ezcolin2', 'Tolerblanc'];
-                      const FE_reviewers = ['yewonJin', 'djk01281'];
-                      const doc_reviewers = ['summersummerwhy', 'ezcolin2', 'Tolerblanc', 'yewonJin', 'djk01281'];
+                      const BE_reviewers = ['summersummerwhy', 'ezcolin2'];
+                      const FE_reviewers = ['baegyeong', 'pkh0106'];
+                      const doc_reviewers = ['summersummerwhy', 'ezcolin2', 'baegyeong', 'pkh0106'];
 
                       // Function to filter out assignees, PR author, and current reviewers
                       const filterReviewers = (reviewers) => {

.github/workflows/cd-pipeline.yml

@@ -1,9 +1,9 @@
-name: auto  Workflow
+name: OctoDocs CD Pipeline
 
 on:
   push:
     branches:
-      - main
+      - refactor-be-#47
   workflow_dispatch:
 jobs:
   image-build-and-push:
@@ -27,28 +27,52 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
+      # 패키지 이미지부터 빌드 후 푸시
+      # 이 이미지를 base로 backend와 websocket 이미지를 만들기 때문
+      # 만약 octodocs-modules 이미지가 존재하면 그 이미지를 base로 하고
+      # 그렇지 않으면 node:20-alpine 버전 사용
+      # 그리고 layer 수가 너무 많으면 node:20-alpine 버전 사용 (50개 이상)
+      - name: package docker image build and push
+        run: |
+          STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://hub.docker.com/v2/repositories/summersummerwhy/octodocs-modules)
+          if [ "$STATUS" -eq 404 ]; then
+            echo "octodocs-modules not found"
+            docker build -f ./services/module/Dockerfile.init -t summersummerwhy/octodocs-modules .
+
+          else
+            echo "octodocs-modules found"
+            docker build -f ./services/module/Dockerfile -t summersummerwhy/octodocs-modules .
+            LAYERS=$(docker inspect --format '{{len .RootFS.Layers}}' summersummerwhy/octodocs-modules)
+              if [ $LAYERS -gt 50 ]; then
+                echo "too many layers"
+                docker build -f ./services/module/Dockerfile.init -t summersummerwhy/octodocs-modules .
+              fi
+          fi
       # Docker 이미지 빌드
       - name: docker image build
         run: |
-          docker build -f ./services/module/Dockerfile -t summersummerwhy/octodocs-modules .
-          docker build -f ./services/backend/Dockerfile.prod -t summersummerwhy/octodocs-backend .
-          docker build -f ./services/nginx/Dockerfile.prod -t summersummerwhy/octodocs-nginx .
-          docker build -f ./services/websocket/Dockerfile.prod -t summersummerwhy/octodocs-websocket .
+          docker build -f ./services/backend/Dockerfile.prod -t summersummerwhy/octodocs-backend . &
+          docker build -f ./services/nginx/Dockerfile.prod -t summersummerwhy/octodocs-nginx . &
+          docker build -f ./services/websocket/Dockerfile.prod -t summersummerwhy/octodocs-websocket . &
+          wait
 
       # Docker 이미지 푸시
       - name: docker image push
         run: |
-          docker push summersummerwhy/octodocs-modules
-          docker push summersummerwhy/octodocs-backend
-          docker push summersummerwhy/octodocs-nginx
-          docker push summersummerwhy/octodocs-websocket
+          docker push summersummerwhy/octodocs-modules &
+          docker push summersummerwhy/octodocs-backend &
+          docker push summersummerwhy/octodocs-nginx &
+          docker push summersummerwhy/octodocs-websocket &
+          wait
 
   deploy:
     needs: image-build-and-push
     runs-on: ubuntu-latest
 
     steps:
-      - name: deploy
+      # octodocs-modules먼저 pull 한 뒤 나머지 이미지 pull
+      # octodocs-modules를 base로 하는 이미지가 있기 때문
+      - name: image-pulling
         env:
           REMOTE_HOST: ${{ secrets.REMOTE_SERVER_IP }}
           REMOTE_USER: ${{ secrets.REMOTE_SERVER_USER }}
@@ -61,6 +85,22 @@ jobs:
 
           ssh -o StrictHostKeyChecking=no $REMOTE_USER@$REMOTE_HOST << 'EOF'
             cd /root/octodocs
-            docker-compose -f compose.prod.yml down
+            docker pull summersummerwhy/octodocs-modules
             docker-compose -f compose.prod.yml pull
+      - name: deploy
+        env:
+          REMOTE_HOST: ${{ secrets.REMOTE_SERVER_IP }}
+          REMOTE_USER: ${{ secrets.REMOTE_SERVER_USER }}
+        run: |
+          ssh -o StrictHostKeyChecking=no $REMOTE_USER@$REMOTE_HOST << 'EOF'
+            cd /root/octodocs
+            docker-compose -f compose.prod.yml down
             docker-compose -f compose.prod.yml up -d
+      # 사용하지 않는 도커 리소스를 정리한다.
+      - name: cleanup
+        env:
+          REMOTE_HOST: ${{ secrets.REMOTE_SERVER_IP }}
+          REMOTE_USER: ${{ secrets.REMOTE_SERVER_USER }}
+        run: |
+          ssh -o StrictHostKeyChecking=no $REMOTE_USER@$REMOTE_HOST << 'EOF'
+            docker system prune -f --all

.github/workflows/ci-pipeline.yml

@@ -75,6 +75,7 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: "23"
+
       # 루트 의존성 캐시 설정
       - name: Cache Yarn dependencies for root
         id: cache-deps
@@ -83,6 +84,12 @@ jobs:
           path: node_modules
           key: ${{ runner.os }}-yarn-${{ hashFiles('yarn.lock') }}
 
+      # 환경변수 build에 필요한 .env 생성
+      - name: Set up .env file
+        run: |
+          cd /home/runner/work/refactor-web39-OctoDocs/refactor-web39-OctoDocs/apps/frontend
+          echo "VITE_API_URL=${{ secrets.VITE_API_URL }}" >> .env
+
       # 빌드 실행
       - name: Run build
         run: yarn build
@@ -100,11 +107,19 @@ jobs:
 
       # 의존성 캐시 복원
       - name: Restore Yarn dependencies
+        id: cache-deps
         uses: actions/cache@v3
         with:
           path: node_modules
           key: ${{ runner.os }}-yarn-${{ hashFiles('yarn.lock') }}
 
+      # test에 필요한 의존성 설치
+      - name: Install Jest dependencies from test package
+        run: |
+          cd /home/runner/work/refactor-web39-OctoDocs/refactor-web39-OctoDocs/apps/backend/test
+          yarn install
+          mv node_modules ../
+
       # 테스트 실행
       - name: Run tests
         run: yarn test

apps/backend/src/app.module.ts

@@ -40,8 +40,7 @@ import { ScheduleModule } from '@nestjs/schedule';
         database: configService.get('DB_NAME'),
         entities: [Node, Page, Edge, User, Workspace, Role],
         logging: process.env.NODE_ENV === 'development',
-        // synchronize: process.env.NODE_ENV === 'development',
-        synchronize: true,
+        synchronize: process.env.NODE_ENV === 'development',
       }),
     }),
     NodeModule,

apps/backend/src/auth/auth.controller.spec.ts

@@ -29,6 +29,10 @@ describe('AuthController', () => {
             refreshAccessToken: jest.fn(() => 'mockedAccessToken'),
           },
         },
+        {
+          provide: JwtAuthGuard,
+          useValue: {},
+        },
       ],
     })
       .overrideGuard(JwtAuthGuard)

apps/backend/src/edge/edge.controller.spec.ts

@@ -51,24 +51,24 @@ describe('EdgeController', () => {
   });
 
   describe('deleteEdge', () => {
-    it('id에 해당하는 엣지를 찾아 삭제한다.', async () => {
-      const id = 2;
+    it('fromNode, toNode에 해당하는 엣지를 찾아 삭제한다.', async () => {
       const expectedResponse = {
         message: EdgeResponseMessage.EDGE_DELETED,
       };
 
-      const result = await controller.deleteEdge(id);
+      jest.spyOn(edgeService, 'deleteEdge').mockResolvedValue(undefined);
+      const result = await controller.deleteEdge(1, 3);
 
-      expect(edgeService.deleteEdge).toHaveBeenCalledWith(id);
+      expect(edgeService.deleteEdge).toHaveBeenCalledWith(1, 3);
       expect(result).toEqual(expectedResponse);
     });
 
-    it('id에 해당하는 엣지가 존재하지 않으면 NodeNotFoundException을 throw한다.', async () => {
+    it('fromNode, toNode에 해당하는 엣지가 존재하지 않으면 NodeNotFoundException을 throw한다.', async () => {
       jest
         .spyOn(edgeService, 'deleteEdge')
         .mockRejectedValue(new EdgeNotFoundException());
 
-      await expect(controller.deleteEdge(1)).rejects.toThrow(
+      await expect(controller.deleteEdge(1, 3)).rejects.toThrow(
         EdgeNotFoundException,
       );
     });

apps/backend/src/edge/edge.controller.ts

@@ -39,12 +39,13 @@ export class EdgeController {
 
   @ApiResponse({ type: MessageResponseDto })
   @ApiOperation({ summary: '엣지를 삭제합니다.' })
-  @Delete('/:id')
+  @Delete('/:fromNode/:toNode') // URL 경로에서 fromNode와 toNode를 추출
   @HttpCode(HttpStatus.OK)
   async deleteEdge(
-    @Param('id', ParseIntPipe) id: number,
-  ): Promise<{ message: string }> {
-    await this.edgeService.deleteEdge(id);
+    @Param('fromNode', ParseIntPipe) fromNode: number,
+    @Param('toNode', ParseIntPipe) toNode: number,
+  ) {
+    await this.edgeService.deleteEdge(fromNode, toNode);
 
     return {
       message: EdgeResponseMessage.EDGE_DELETED,

apps/backend/src/edge/edge.service.spec.ts

@@ -25,8 +25,9 @@ describe('EdgeService', () => {
           useValue: {
             create: jest.fn(),
             save: jest.fn(),
-            delete: jest.fn(),
+            remove: jest.fn(),
             findOneBy: jest.fn(),
+            findOne: jest.fn(),
             findEdgesByWorkspace: jest.fn(),
           },
         },
@@ -35,6 +36,7 @@ describe('EdgeService', () => {
           useValue: {
             save: jest.fn(),
             findOneBy: jest.fn(),
+            findOne: jest.fn(),
           },
         },
         {
@@ -86,41 +88,41 @@ describe('EdgeService', () => {
         id: 1,
         fromNode: fromNode,
         toNode: toNode,
+        workspace: null,
       } as Edge;
 
-      jest
-        .spyOn(nodeRepository, 'findOneBy')
-        .mockResolvedValueOnce(fromNode) // 첫 번째 호출: fromNode
-        .mockResolvedValueOnce(toNode); // 두 번째 호출: toNode
+      jest.spyOn(nodeRepository, 'findOne').mockResolvedValueOnce(fromNode); // 첫 번째 호출: fromNode
+      jest.spyOn(nodeRepository, 'findOneBy').mockResolvedValueOnce(toNode); // 두 번째 호출: toNode
       jest.spyOn(edgeRepository, 'save').mockResolvedValue(edge);
 
       const result = await service.createEdge(dto);
 
       expect(result).toEqual(edge);
       expect(edgeRepository.save).toHaveBeenCalledTimes(1);
-      expect(nodeRepository.findOneBy).toHaveBeenCalledTimes(2);
+      expect(nodeRepository.findOne).toHaveBeenCalledTimes(1);
+      expect(nodeRepository.findOneBy).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('deleteEdge', () => {
     it('엣지를 성공적으로 삭제한다.', async () => {
       jest
-        .spyOn(edgeRepository, 'delete')
+        .spyOn(edgeRepository, 'remove')
         .mockResolvedValue({ affected: true } as any);
-      jest.spyOn(edgeRepository, 'findOneBy').mockResolvedValue(new Edge());
+      jest.spyOn(edgeRepository, 'findOne').mockResolvedValue(new Edge());
 
-      await service.deleteEdge(1);
+      await service.deleteEdge(1, 3);
 
-      expect(edgeRepository.delete).toHaveBeenCalledWith(1);
+      expect(edgeRepository.remove).toHaveBeenCalledTimes(1);
     });
 
     it('삭제할 엣지가 존재하지 않으면 EdgeNotFoundException을 throw한다.', async () => {
-      jest
-        .spyOn(edgeRepository, 'delete')
-        .mockResolvedValue({ affected: false } as any);
-      await expect(service.deleteEdge(1)).rejects.toThrow(
+      jest.spyOn(edgeRepository, 'findOne').mockResolvedValue(undefined);
+
+      await expect(service.deleteEdge(1, 3)).rejects.toThrow(
         EdgeNotFoundException,
       );
+      expect(edgeRepository.remove).toHaveBeenCalledTimes(0);
     });
   });
 

apps/backend/src/edge/edge.service.ts

@@ -19,37 +19,43 @@ export class EdgeService {
     const { fromNode, toNode } = dto;
 
     // 출발 노드를 조회한다.
-    const existingFromNode = await this.nodeRepository.findOneBy({
-      id: fromNode,
+    const existingFromNode = await this.nodeRepository.findOne({
+      where: { id: fromNode },
+      relations: ['workspace'], // workspace 관계를 포함
     });
+
     // 도착 노드를 조회한다.
     const existingToNode = await this.nodeRepository.findOneBy({ id: toNode });
 
     // 엣지를 생성한다.
     return await this.edgeRepository.save({
       fromNode: existingFromNode,
       toNode: existingToNode,
+      workspace: existingFromNode.workspace,
     });
   }
 
-  async deleteEdge(id: number): Promise<void> {
-    // 엣지를 삭제한다
-    const deleteResult = await this.edgeRepository.delete(id);
+  async deleteEdge(fromNode: number, toNode: number): Promise<void> {
+    // fromNode와 toNode로 매치되는 엣지를 검색
+
+    // 출발 노드를 조회한다.
+    const existingFromNode = await this.nodeRepository.findOneBy({
+      id: fromNode,
+    });
+    // 도착 노드를 조회한다.
+    const existingToNode = await this.nodeRepository.findOneBy({ id: toNode });
+
+    const edge = await this.edgeRepository.findOne({
+      where: { fromNode: existingFromNode, toNode: existingToNode },
+    });
 
-    // 삭제된 엣지가 없으면 노드를 찾지 못한 것
-    if (!deleteResult.affected) {
+    // 엣지가 없으면 예외를 발생시킴
+    if (!edge) {
       throw new EdgeNotFoundException();
     }
-  }
 
-  async findEdgeByFromNodeAndToNode(fromNodeId: number, toNodeId: number) {
-    return this.edgeRepository.findOne({
-      where: {
-        fromNode: { id: fromNodeId },
-        toNode: { id: toNodeId },
-      },
-      relations: ['fromNode', 'toNode'],
-    });
+    // 엣지를 삭제
+    await this.edgeRepository.remove(edge);
   }
 
   async findEdgesByWorkspace(workspaceId: string): Promise<Edge[]> {