Merge pull request #61 from boostcampwm-2022/feat/#51-S

Feat/#51-S : 특정 워크스페이스의 멤버, 회의록 목록 조회하기 API 구축

Author: juyeong-s

server/apis/user/model.ts

@@ -1,7 +1,7 @@
 import { Schema } from 'mongoose';
 import mongoose from '@db';
 
-interface User {
+export interface User {
   id: number;
   name: string;
   avatarUrl: string;

server/apis/workspace/controller.ts

@@ -3,21 +3,23 @@ import asyncWrapper from '@utils/async-wrapper';
 import jwtAuthenticator from '@middlewares/jwt-authenticator';
 import * as workspaceService from './service';
 import { CREATED } from '@constants/http-status';
-import { PostParams, PostJoinParams } from '@params/workspace';
+import { PostParams, PostJoinParams, GetInfoParams } from '@params/workspace';
 
 const router = express.Router();
 
+/* POST: 워크스페이스 생성 */
 router.post(
   '/',
   asyncWrapper(async (req: Request<PostParams>, res: Response) => {
     const { name } = req.body;
 
     const workspace = await workspaceService.create(name);
 
-    res.status(CREATED).send({ ...workspace });
+    res.status(CREATED).send(workspace);
   }),
 );
 
+/* POST: 워크스페이스 참여 */
 router.post(
   '/join',
   jwtAuthenticator,
@@ -30,4 +32,17 @@ router.post(
   }),
 );
 
+/* GET: 특정 워크스페이스의 멤버, 회의록 목록 */
+router.get(
+  '/:id',
+  jwtAuthenticator,
+  asyncWrapper(async (req: Request<GetInfoParams>, res: Response) => {
+    const { id: workspaceId } = req.params;
+
+    const workspaceInfo = await workspaceService.info(Number(workspaceId));
+
+    res.send(workspaceInfo);
+  }),
+);
+
 export default router;

server/apis/workspace/service.test.ts

@@ -1,6 +1,9 @@
 const workspaceModel = require('./model');
 const workspaceService = require('./service');
 const { default: InvalidJoinError } = require('@errors/invalid-join-error');
+const {
+  default: InvalidWorkspaceError,
+} = require('@errors/invalid-workspace-error');
 
 jest.mock('./model', () => {
   return {
@@ -12,10 +15,15 @@ jest.mock('./model', () => {
 
 jest.mock('@apis/user/model', () => {
   return {
+    find: jest.fn(),
     updateOne: jest.fn(),
   };
 });
 
+jest.mock('@apis/mom/model', () => {
+  return { find: jest.fn() };
+});
+
 const VALID_CODE = 'wab-0000-0000-0000';
 
 jest.mock('uuid', () => {
@@ -91,4 +99,49 @@ describe('join', () => {
   });
 });
 
+describe('info', () => {
+  const WORKSPACE_ID = 1;
+  const INVALID_WORKSPACE_ID = -1;
+
+  it('워크스페이스 ID가 DB에 존재할 경우 조회에 성공한다.', async () => {
+    const WORKSPACE_NAME = 'Wab';
+
+    workspaceModel.findOne.mockResolvedValueOnce({
+      id: WORKSPACE_ID,
+      name: WORKSPACE_NAME,
+      code: VALID_CODE,
+      users: [],
+      moms: [],
+    });
+
+    expect(workspaceService.info(WORKSPACE_ID)).resolves.toEqual({
+      name: WORKSPACE_NAME,
+      users: [],
+      moms: [],
+    });
+  });
+
+  it('워크스페이스 Id가 없는 경우 실패한다.', async () => {
+    expect(() => workspaceService.info()).rejects.toThrow(
+      InvalidWorkspaceError,
+    );
+  });
+
+  it('워크스페이스 Id가 DB에 존재하지 않는 경우 실패한다.', async () => {
+    workspaceModel.findOne.mockResolvedValueOnce(null);
+
+    expect(() => workspaceService.info(INVALID_WORKSPACE_ID)).rejects.toThrow(
+      InvalidWorkspaceError,
+    );
+  });
+
+  it('워크스페이스 정보 획득 실패 시 에러를 던진다.', async () => {
+    workspaceModel.findOne.mockRejectedValueOnce(
+      new Error('Some error in database operation'),
+    );
+
+    expect(() => workspaceService.info(WORKSPACE_ID)).rejects.toThrow();
+  });
+});
+
 export {};

server/apis/workspace/service.ts

@@ -1,8 +1,10 @@
 import { v4 as uuidv4 } from 'uuid';
 import workspaceModel from './model';
-import userModel from '@apis/user/model';
+import userModel, { User } from '@apis/user/model';
+import momModel from '@apis/mom/model';
 import AuthorizationError from '@errors/authorization-error';
 import InvalidJoinError from '@errors/invalid-join-error';
+import InvalidWorkspaceError from '@errors/invalid-workspace-error';
 
 export const create = async (name: string) => {
   if (!name) throw new Error('워크스페이스 이름을 입력하세요 ^^');
@@ -30,3 +32,27 @@ export const join = async (userId: number, code: string) => {
 
   return { id, name, code };
 };
+
+export const info = async (workspaceId: number) => {
+  if (!workspaceId) throw new InvalidWorkspaceError('잘못된 접근이에요 ^^');
+
+  const workspace = await workspaceModel.findOne({ id: workspaceId });
+
+  if (!workspace)
+    throw new InvalidWorkspaceError('존재하지 않는 워크스페이스에요 ^^');
+
+  const { name, users: userIds, moms: momsIds } = workspace;
+
+  const users: Pick<User, 'name' | 'avatarUrl'>[] =
+    (await userModel.find(
+      {
+        id: { $in: userIds },
+      },
+      { name: 1, avatarUrl: 1, _id: 0 },
+    )) || [];
+
+  const moms: string[] =
+    (await momModel.find({ id: { $in: momsIds } }, { name: 1 })) || [];
+
+  return { name, users, moms };
+};

server/errors/invalid-workspace-error.ts

@@ -0,0 +1,10 @@
+import CustomError from '.';
+import { BAD_REQUEST } from '@constants/http-status';
+
+class InvalidWorkspaceError extends CustomError {
+  constructor(message = 'Unauthorized') {
+    super(message, BAD_REQUEST);
+  }
+}
+
+export default InvalidWorkspaceError;

types/params/workspace.ts

@@ -5,3 +5,7 @@ export interface PostParams {
 export interface PostJoinParams {
   code: string;
 }
+
+export interface GetInfoParams {
+  id: string;
+}