fix: 권한 체크 수정

Author: summersummerwhy

apps/backend/src/exception/access.exception.ts

@@ -0,0 +1,7 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export class ForbiddenAccessException extends HttpException {
+  constructor() {
+    super('워크스페이스에 접근할 권한이 없습니다.', HttpStatus.FORBIDDEN);
+  }
+}

apps/backend/src/exception/workspace-auth.exception.ts

@@ -2,6 +2,6 @@ import { HttpException, HttpStatus } from '@nestjs/common';
 
 export class NotWorkspaceOwnerException extends HttpException {
   constructor() {
-    super('You are not the owner of this workspace.', HttpStatus.FORBIDDEN);
+    super('해당 워크스페이스의 소유자가 아닙니다.', HttpStatus.FORBIDDEN);
   }
 }

apps/backend/src/workspace/dtos/getWorkspaceAccessResponse.dto.ts

@@ -136,4 +136,49 @@ describe('WorkspaceController', () => {
       expect(result).toEqual(expectedResult);
     });
   });
+
+  it('컨트롤러가 정상적으로 인스턴스화된다.', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('generateInviteLink', () => {
+    it('초대 링크를 생성하고 반환한다.', async () => {
+      const req = { user: { sub: 1 } };
+      const workspaceId = 'workspace-snowflake-id';
+      const mockInviteUrl =
+        'https://example.com/api/workspace/join?token=abc123';
+
+      jest.spyOn(service, 'generateInviteUrl').mockResolvedValue(mockInviteUrl);
+
+      const result = await controller.generateInviteLink(req, workspaceId);
+
+      expect(service.generateInviteUrl).toHaveBeenCalledWith(
+        req.user.sub,
+        workspaceId,
+      );
+      expect(result).toEqual({
+        message: WorkspaceResponseMessage.WORKSPACE_INVITED,
+        inviteUrl: mockInviteUrl,
+      });
+    });
+  });
+
+  describe('joinWorkspace', () => {
+    it('초대 토큰을 처리하고 성공 메시지를 반환한다.', async () => {
+      const req = { user: { sub: 1 } };
+      const token = 'valid-token';
+
+      jest.spyOn(service, 'processInviteToken').mockResolvedValue();
+
+      const result = await controller.joinWorkspace(req, token);
+
+      expect(service.processInviteToken).toHaveBeenCalledWith(
+        req.user.sub,
+        token,
+      );
+      expect(result).toEqual({
+        message: WorkspaceResponseMessage.WORKSPACE_INVITED,
+      });
+    });
+  });
 });

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

@@ -19,15 +19,14 @@ import { CreateWorkspaceDto } from './dtos/createWorkspace.dto';
 import { CreateWorkspaceResponseDto } from './dtos/createWorkspaceResponse.dto';
 import { GetUserWorkspacesResponseDto } from './dtos/getUserWorkspacesResponse.dto';
 import { CreateWorkspaceInviteUrlDto } from './dtos/createWorkspaceInviteUrl.dto';
-import { GetWorkspaceAccessResponseDto } from './dtos/getWorkspaceAccessResponse.dto';
 
 export enum WorkspaceResponseMessage {
   WORKSPACE_CREATED = '워크스페이스를 생성했습니다.',
   WORKSPACE_DELETED = '워크스페이스를 삭제했습니다.',
   WORKSPACES_RETURNED = '사용자가 참여하고 있는 모든 워크스페이스들을 가져왔습니다.',
   WORKSPACE_INVITED = '워크스페이스 게스트 초대 링크가 생성되었습니다.',
   WORKSPACE_JOINED = '워크스페이스에 게스트로 등록되었습니다.',
-  WORKSPACE_ACCESS_CHECKED = '워크스페이스에 대한 사용자의 권한을 확인하였습니다.',
+  WORKSPACE_ACCESS_CHECKED = '워크스페이스에 대한 사용자의 접근 권한이 확인되었습니다.',
 }
 
 @Controller('workspace')
@@ -132,7 +131,7 @@ export class WorkspaceController {
   }
 
   @ApiResponse({
-    type: GetWorkspaceAccessResponseDto,
+    type: MessageResponseDto,
   })
   @ApiOperation({
     summary: '워크스페이스에 대한 사용자의 권한을 확인합니다.',
@@ -141,14 +140,16 @@ export class WorkspaceController {
   @HttpCode(HttpStatus.OK)
   async checkWorkspaceAccess(
     @Param('workspaceId') workspaceId: string,
-    @Param('userId') userId: string | 'null', // 로그인되지 않은 경우 'null'
+    @Param('userId') userId: string, // 로그인되지 않은 경우 'null'
   ) {
     // workspaceId, userId 둘 다 snowflakeId
-    const access = await this.workspaceService.checkAccess(userId, workspaceId);
+    // userId 'null'인 경우 => null로 처리
+    const checkedUserId = userId === 'null' ? null : userId;
+
+    await this.workspaceService.checkAccess(checkedUserId, workspaceId);
 
     return {
       message: WorkspaceResponseMessage.WORKSPACE_ACCESS_CHECKED,
-      access,
     };
   }
 }

apps/backend/src/workspace/workspace.controller.ts

@@ -9,6 +9,7 @@ import { Workspace } from './workspace.entity';
 import { WorkspaceNotFoundException } from '../exception/workspace.exception';
 import { NotWorkspaceOwnerException } from '../exception/workspace-auth.exception';
 import { TokenService } from '../auth/token/token.service';
+import { ForbiddenAccessException } from '../exception/access.exception';
 
 @Injectable()
 export class WorkspaceService {
@@ -147,10 +148,7 @@ export class WorkspaceService {
     });
   }
 
-  async checkAccess(
-    userId: string | null,
-    workspaceId: string,
-  ): Promise<'public' | 'owner' | 'guest' | 'forbidden'> {
+  async checkAccess(userId: string | null, workspaceId: string): Promise<void> {
     // workspace가 존재하는지 확인
     const workspace = await this.workspaceRepository.findOne({
       where: { snowflakeId: workspaceId },
@@ -160,28 +158,32 @@ export class WorkspaceService {
       throw new WorkspaceNotFoundException();
     }
 
+    // 퍼블릭 워크스페이스인 경우
     if (workspace.visibility === 'public') {
-      return 'public';
+      return;
     }
 
+    // 사용자 인증 필요
     if (userId !== null) {
-      // user이 존재하는지 확인
       const user = await this.userRepository.findOneBy({
         snowflakeId: userId,
       });
       if (!user) {
         throw new UserNotFoundException();
       }
-      // workspace + user => role 있는지 확인
+
+      // workspace와 user에 대한 role 확인
       const role = await this.roleRepository.findOne({
         where: { userId: user.id, workspaceId: workspace.id },
       });
 
+      // role이 존재하면 접근 허용
       if (role) {
-        return role.role as 'owner' | 'guest';
+        return;
       }
     }
 
-    return 'forbidden';
+    // 권한이 없으면 예외 발생
+    throw new ForbiddenAccessException();
   }
 }