Merge branch 'refactor/#7' into 'develop'

[#%{issuses}] {taskTitle}

.gitignore

 node_modules/
-.env/
+.env
 config.json/

controllers/friendController.js

 const FriendService = require('../services/friendService');
 
 class friendController {
-    /**
-     * 친구 요청 보내기
-     * POST /api/friend/request/:friendId
-     */
-    async sendRequest(req, res) {
-        try {
-            const userId = req.user.id;
-            const { friendId } = req.params;
 
-            const request = await FriendService.sendFriendRequest(userId, friendId);
-            return res.status(201).json({
-                success: true,
-                data: request
-            });
-        } catch (error) {
-            return res.status(400).json({
-                success: false,
-                error: {
-                    message: error.message,
-                    code: 'FRIEND_REQUEST_ERROR'
+
+
+    class FriendController {
+        /**
+         * 친구 요청 보내기
+         * 클라이언트는 userId와 요청을 보낼 사용자의 email을 전송
+         * @param {Object} req - Express 요청 객체
+         * @param {Object} res - Express 응답 객체
+         * @param {Function} next - Express next 미들웨어 함수
+         */
+        async sendFriendRequest(req, res, next) {
+            const { userId, email } = req.body;
+    
+            try {
+
+                if (!userId || !email) {
+                    return res.status(400).json({ message: 'userId와 email은 필수 입력 항목입니다.' });
                 }
-            });
+                // 친구 요청을 받을 사용자의 정보 조회 (서비스로 분리할지 생각)
+                const receiver = await User.findOne({ where: { email: email } });
+                if (!receiver) {
+                    return res.status(404).json({ message: '요청을 받을 사용자를 찾을 수 없습니다.' });
+                }
+                const friendId = receiver.id;
+                // 친구 요청 보내기 서비스 호출
+                const friendRequest = await friendService.sendFriendRequest(userId, friendId);
+                return res.status(201).json({
+                    success:true,
+                    data:friendRequest
+                });
+            } catch (error) {
+                // 유니크 제약조건 오류 처리
+                if (error.message === 'Friend request already exists') {
+                    return res.status(409).json({ message: error.message });
+                }
+                // 일반 오류 처리
+                return res.status(500).json({ message: '서버 오류가 발생했습니다.', error: error.message });
+            }
         }
     }
 

models/Friend.js

@@ -13,12 +13,22 @@ const Friend = sequelize.define('Friend', {
 }, {
     tableName: 'Friends',
     timestamps: true,
+    indexes: [
+        {
+            unique: true,
+            fields: ['requester_id', 'receiver_id']
+        },
+        {
+            fields: ['status']
+        }
+    ]
 });
 
-Friend.belongsTo(User, { foreignKey: 'user_id', as: 'user' });
-Friend.belongsTo(User, { foreignKey: 'friend_id', as: 'friend' });
+// 관계 설정
+Friend.belongsTo(User, { foreignKey: 'requester_id', as: 'requester' }); // 친구 요청을 보낸 사용자
+Friend.belongsTo(User, { foreignKey: 'receiver_id', as: 'receiver' });   // 친구 요청을 받은 사용자
 
-User.hasMany(Friend, { foreignKey: 'user_id', as: 'friends' });
-User.hasMany(Friend, { foreignKey: 'friend_id', as: 'friendRequests' });
+User.hasMany(Friend, { foreignKey: 'requester_id', as: 'sentRequests' });     // 친구 요청을 보낸 목록
+User.hasMany(Friend, { foreignKey: 'receiver_id', as: 'receivedRequests' }); // 친구 요청을 받은 목록
 
-module.exports = Friend;
\ No newline at end of file
+module.exports = Friend;

package.json

@@ -29,6 +29,7 @@
     "sequelize-cli": "^6.6.2"
   },
   "devDependencies": {
+    "artillery": "^2.0.21",
     "nodemon": "^3.1.7"
   }
 }

services/friendService.js

+// services/friendService.js
+
 const { Op } = require('sequelize');
 const Friend = require('../models/Friend');
 const User = require('../models/User');
+const sequelize = require('../config/sequelize'); // 트랜잭션을 위해 추가
 
-class friendService {
-
+class FriendService {
     /**
      * User 존재 여부 유효성 검사
+     * @param {number} userId - 검사할 사용자 ID
+     * @returns {Promise<User>} - 유효한 사용자 객체
+     * @throws {Error} - 사용자가 존재하지 않을 경우
      */
     async validUser(userId) {
         const user = await User.findByPk(userId);
@@ -14,10 +19,13 @@ class friendService {
         }
         return user;
     }
+
     /**
      * 친구 요청 보내기
-     * 나 자신에게 보내기 or 이미 존재하는 친구 -> X
-     * 이후, PENDING 상태로 변환 -> 수락/거절에 따라 변화
+     * @param {number} userId - 친구 요청을 보내는 사용자 ID
+     * @param {number} friendId - 친구 요청을 받는 사용자 ID
+     * @returns {Promise<Friend>} - 생성된 친구 요청 객체
+     * @throws {Error} - 유효하지 않은 요청일 경우
      */
     async sendFriendRequest(userId, friendId) {
         await this.validUser(userId);
@@ -27,38 +35,34 @@ class friendService {
             throw new Error('Cannot send friend request to yourself');
         }
 
-        const existingFriend = await Friend.findOne({
-            where: {
-                [Op.or]: [
-                    { user_id: userId, friend_id: friendId },
-                    { user_id: friendId, friend_id: userId }
-                ]
+        try {
+            return await Friend.create({
+                requester_id: userId,
+                receiver_id: friendId,
+                status: 'PENDING'
+            });
+        } catch (error) {
+            if (error.name === 'SequelizeUniqueConstraintError') {
+                throw new Error('Friend request already exists');
             }
-        });
-
-        if (existingFriend) {
-            throw new Error('Friend request already exists');
+            throw error;
         }
-
-        return Friend.create({
-            user_id: userId,
-            friend_id: friendId,
-            status: 'PENDING'
-        });
     }
 
     /**
      * 받은 친구 요청 목록 조회
+     * @param {number} userId - 요청을 받은 사용자 ID
+     * @returns {Promise<Array>} - 받은 친구 요청 목록
      */
     async getReceivedRequests(userId) {
         return Friend.findAll({
             where: {
-                friend_id: userId,
+                receiver_id: userId,
                 status: 'PENDING'
             },
             include: [{
                 model: User,
-                as: 'user',
+                as: 'requester',
                 attributes: ['id', 'name', 'email']
             }]
         });
@@ -66,16 +70,18 @@ class friendService {
 
     /**
      * 보낸 친구 요청 목록 조회
+     * @param {number} userId - 요청을 보낸 사용자 ID
+     * @returns {Promise<Array>} - 보낸 친구 요청 목록
      */
     async getSentRequests(userId) {
         return Friend.findAll({
             where: {
-                user_id: userId,
+                requester_id: userId,
                 status: 'PENDING'
             },
             include: [{
                 model: User,
-                as: 'user',
+                as: 'receiver',
                 attributes: ['id', 'name', 'email']
             }]
         });
@@ -83,96 +89,116 @@ class friendService {
 
     /**
      * 친구 요청 수락
+     * @param {number} userId - 요청을 수락하는 사용자 ID
+     * @param {number} friendId - 친구 요청을 보낸 사용자 ID
+     * @returns {Promise<Friend>} - 업데이트된 친구 요청 객체
+     * @throws {Error} - 친구 요청이 존재하지 않을 경우
      */
     async acceptFriendRequest(userId, friendId) {
-        const request = await Friend.findOne({
-            where: {
-                user_id: friendId,
-                friend_id: userId,
-                status: 'PENDING'
+        const transaction = await sequelize.transaction();
+        try {
+            const request = await Friend.findOne({
+                where: {
+                    requester_id: friendId,
+                    receiver_id: userId,
+                    status: 'PENDING'
+                },
+                transaction
+            });
+
+            if (!request) {
+                throw new Error('Friend request not found');
             }
-        });
-    
-        if (!request) {
-            throw new Error('Friend request not found');
+
+            await request.update({ status: 'ACCEPTED' }, { transaction });
+
+            await transaction.commit();
+            return request;
+        } catch (error) {
+            await transaction.rollback();
+            throw error;
         }
-    
-        return request.update({ status: 'ACCEPTED' });
     }
 
     /**
      * 친구 요청 거절
+     * @param {number} userId - 요청을 거절하는 사용자 ID
+     * @param {number} friendId - 친구 요청을 보낸 사용자 ID
+     * @returns {Promise<number>} - 삭제된 친구 요청 수
+     * @throws {Error} - 친구 요청이 존재하지 않을 경우
      */
-    async rejectFriendRequest(userId, friendId) { 
+    async rejectFriendRequest(userId, friendId) {
         const result = await Friend.destroy({
             where: {
-                user_id: friendId,  
-                friend_id: userId,  
+                requester_id: friendId,
+                receiver_id: userId,
                 status: 'PENDING'
             }
         });
-    
+
         if (!result) {
             throw new Error('Friend request not found');
         }
-    
+
         return result;
     }
 
     /**
      * 친구 목록 조회
+     * @param {number} userId - 친구 목록을 조회할 사용자 ID
+     * @returns {Promise<Array>} - 친구 목록
      */
     async getFriendList(userId) {
         const friends = await Friend.findAll({
             where: {
                 [Op.or]: [
-                    { user_id: userId },
-                    { friend_id: userId }
+                    { requester_id: userId },
+                    { receiver_id: userId }
                 ],
                 status: 'ACCEPTED'
-            }
-        });
-    
-        const friendIds = friends.map(friend => 
-            friend.user_id === userId ? friend.friend_id : friend.user_id
-        );
-    
-        const friendUsers = await User.findAll({
-            where: {
-                id: friendIds
             },
-            attributes: ['id', 'name', 'email']
+            include: [
+                {
+                    model: User,
+                    as: 'requester',
+                    attributes: ['id', 'name', 'email']
+                },
+                {
+                    model: User,
+                    as: 'receiver',
+                    attributes: ['id', 'name', 'email']
+                }
+            ]
         });
-    
-        const friendsMap = friendUsers.reduce((map, user) => {
-            map[user.id] = user;
-            return map;
-        }, {});
-    
+
         return friends.map(friend => {
-            const isSender = friend.user_id === userId;
-            const friendId = isSender ? friend.friend_id : friend.user_id;
-            
+            const isRequester = friend.requester_id === userId;
+            const friendInfo = isRequester ? friend.receiver : friend.requester;
+
             return {
                 id: friend.id,
                 status: friend.status,
                 createdAt: friend.createdAt,
                 updatedAt: friend.updatedAt,
-                friendInfo: friendsMap[friendId],
-                relationshipType: isSender ? 'sent' : 'received'
+                friendInfo: friendInfo,
+                relationshipType: isRequester ? 'sent' : 'received'
             };
         });
     }
 
     /**
      * 친구 삭제
+     * @param {number} userId - 친구를 삭제하는 사용자 ID
+     * @param {number} friendId - 삭제할 친구의 사용자 ID
+     * @returns {Promise<number>} - 삭제된 친구 관계 수
+     * @throws {Error} - 친구 관계가 존재하지 않을 경우
      */
     async deleteFriend(userId, friendId) {
         const result = await Friend.destroy({
             where: {
                 [Op.or]: [
-                    {user_id: userId, friend_id: friendId},
-                    {user_id: friendId, friend_id: userId}
+                    { requester_id: userId, receiver_id: friendId },
+                    { requester_id: friendId, receiver_id: userId }
                 ],
                 status: 'ACCEPTED'
             }
@@ -183,7 +209,6 @@ class friendService {
         }
         return result;
     }
-
 }
 
-module.exports = new friendService();
\ No newline at end of file
+module.exports = new FriendService();