[Chat] 채팅방에 userId로 초대하기 API 구현

chat/src/main/kotlin/kpring/chat/chat/api/v1/ChatController.kt

@@ -17,8 +17,8 @@ import org.springframework.web.bind.annotation.*
 @RequestMapping("/api/v1")
 class ChatController(
   private val chatService: ChatService,
-  val authClient: AuthClient,
-  val serverClient: ServerClient,
+  private val authClient: AuthClient,
+  private val serverClient: ServerClient,
 ) {
   @PostMapping("/chat")
   fun createChat(

chat/src/main/kotlin/kpring/chat/chatroom/api/v1/ChatRoomController.kt

@@ -3,6 +3,7 @@ package kpring.chat.chatroom.api.v1
 import kpring.chat.chatroom.service.ChatRoomService
 import kpring.core.auth.client.AuthClient
 import kpring.core.chat.chatroom.dto.request.CreateChatRoomRequest
+import kpring.core.global.dto.response.ApiResponse
 import org.springframework.http.ResponseEntity
 import org.springframework.validation.annotation.Validated
 import org.springframework.web.bind.annotation.*
@@ -34,4 +35,15 @@ class ChatRoomController(
     val result = chatRoomService.exitChatRoom(chatRoomId, userId)
     return ResponseEntity.ok().body(result)
   }
+
+  @PatchMapping("/chatroom/{chatRoomId}/invite/{userId}")
+  fun inviteToChatRoomByUserId(
+    @PathVariable("userId") userId: String,
+    @PathVariable("chatRoomId") chatRoomId: String,
+    @RequestHeader("Authorization") token: String,
+  ): ResponseEntity<*> {
+    val inviterId = authClient.getTokenInfo(token).data!!.userId
+    chatRoomService.inviteToChatRoomByUserIdWithLock(userId, inviterId, chatRoomId)
+    return ResponseEntity.ok().body(ApiResponse<Nothing>(status = 201))
+  }
 }

chat/src/main/kotlin/kpring/chat/chatroom/dto/Lock.kt

@@ -0,0 +1,7 @@
+package kpring.chat.chatroom.dto
+
+data class Lock(
+  val lockId: String,
+  val owner: String,
+  val acquired: Boolean,
+)

chat/src/main/kotlin/kpring/chat/chatroom/model/ChatRoom.kt

@@ -9,16 +9,20 @@ class ChatRoom : BaseTime() {
   @Id
   var id: String? = null
 
-  var members: MutableList<String> = mutableListOf()
+  var members: MutableSet<String> = mutableSetOf()
 
   fun getUsers(): List<String> {
-    return members
+    return members.stream().toList()
   }
 
   fun addUsers(list: List<String>) {
     members.addAll(list)
   }
 
+  fun addUser(userId: String) {
+    members.add(userId)
+  }
+
   fun removeUser(userId: String) {
     members.remove(userId)
   }

chat/src/main/kotlin/kpring/chat/chatroom/model/DistributedLock.kt

@@ -0,0 +1,12 @@
+package kpring.chat.chatroom.model
+
+import org.springframework.data.annotation.Id
+import org.springframework.data.mongodb.core.mapping.Document
+
+@Document(collection = "distributedLocks")
+data class DistributedLock(
+  @Id
+  val id: String,
+  val owner: String,
+  val expiresAt: Long,
+)

chat/src/main/kotlin/kpring/chat/chatroom/repository/DistributedLockRepository.kt

@@ -0,0 +1,8 @@
+package kpring.chat.chatroom.repository
+
+import kpring.chat.chatroom.model.DistributedLock
+import org.springframework.data.mongodb.repository.MongoRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface DistributedLockRepository : MongoRepository<DistributedLock, String>

chat/src/main/kotlin/kpring/chat/chatroom/service/ChatRoomService.kt

@@ -6,10 +6,12 @@ import kpring.chat.global.exception.ErrorCode
 import kpring.chat.global.exception.GlobalException
 import kpring.core.chat.chatroom.dto.request.CreateChatRoomRequest
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
 
 @Service
 class ChatRoomService(
   private val chatRoomRepository: ChatRoomRepository,
+  private val lockService: DistributedLockService,
 ) {
   fun createChatRoom(
     request: CreateChatRoomRequest,
@@ -30,6 +32,31 @@ class ChatRoomService(
     chatRoomRepository.save(chatRoom)
   }
 
+  @Transactional
+  fun inviteToChatRoomByUserIdWithLock(
+    userId: String,
+    inviterId: String,
+    chatRoomId: String,
+  ): Boolean {
+    val lock = lockService.getLock(chatRoomId)
+
+    inviteToChatRoomByUserId(userId, inviterId, chatRoomId)
+
+    lockService.releaseLock(lock.lockId, lock.owner)
+    return true
+  }
+
+  fun inviteToChatRoomByUserId(
+    userId: String,
+    inviterId: String,
+    chatRoomId: String,
+  ) {
+    verifyChatRoomAccess(chatRoomId, inviterId)
+    val chatRoom: ChatRoom = getChatRoom(chatRoomId)
+    chatRoom.addUser(userId)
+    chatRoomRepository.save(chatRoom)
+  }
+
   fun verifyChatRoomAccess(
     chatRoomId: String,
     userId: String,

chat/src/main/kotlin/kpring/chat/chatroom/service/DistributedLockService.kt

@@ -0,0 +1,58 @@
+package kpring.chat.chatroom.service
+
+import kpring.chat.chatroom.dto.Lock
+import kpring.chat.chatroom.model.DistributedLock
+import kpring.chat.chatroom.repository.DistributedLockRepository
+import kpring.chat.global.exception.ErrorCode
+import kpring.chat.global.exception.GlobalException
+import org.springframework.stereotype.Service
+import java.util.*
+
+@Service
+class DistributedLockService(
+  private val lockRepository: DistributedLockRepository,
+) {
+  fun acquireLock(
+    lockId: String,
+    owner: String,
+    expireInMillis: Long,
+  ): Boolean {
+    val now = System.currentTimeMillis()
+    val expiresAt = now + expireInMillis
+
+    val optionalLock = lockRepository.findById(lockId)
+    return if (optionalLock.isPresent) {
+      val lock = optionalLock.get()
+      if (lock.expiresAt < now) {
+        lockRepository.save(DistributedLock(lockId, owner, expiresAt))
+        true
+      } else {
+        false
+      }
+    } else {
+      lockRepository.save(DistributedLock(lockId, owner, expiresAt))
+      true
+    }
+  }
+
+  fun releaseLock(
+    lockId: String,
+    owner: String,
+  ) {
+    val optionalLock = lockRepository.findById(lockId)
+    if (optionalLock.isPresent && optionalLock.get().owner == owner) {
+      lockRepository.deleteById(lockId)
+    }
+  }
+
+  fun getLock(chatRoomId: String): Lock {
+    val lockId = "chatRoom:$chatRoomId:lock"
+    val owner = UUID.randomUUID().toString()
+
+    val lockAcquired = acquireLock(lockId, owner, 10000) // 10초 동안 잠금 유지
+    if (!lockAcquired) {
+      throw GlobalException(ErrorCode.CONCURRENCY_CONFLICTION)
+    }
+    return Lock(lockId = lockId, owner = owner, acquired = lockAcquired)
+  }
+}

chat/src/main/kotlin/kpring/chat/global/exception/ErrorCode.kt

@@ -12,4 +12,7 @@ enum class ErrorCode(val httpStatus: Int, val message: String) {
 
   // 404
   CHATROOM_NOT_FOUND(HttpStatus.NOT_FOUND.value(), "해당 id로 chatroom을 찾을 수 없습니다"),
+
+  // 500
+  CONCURRENCY_CONFLICTION(HttpStatus.CONFLICT.value(), "동시성 충돌이 발생했습니다."),
 }

chat/src/test/kotlin/kpring/chat/chatroom/ChatRoomServiceTest.kt

@@ -1,22 +1,30 @@
 package kpring.chat.chatroom
 
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContain
 import io.kotest.matchers.collections.shouldNotContain
+import io.kotest.matchers.shouldBe
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
+import kpring.chat.chatroom.dto.Lock
 import kpring.chat.chatroom.model.ChatRoom
 import kpring.chat.chatroom.repository.ChatRoomRepository
 import kpring.chat.chatroom.service.ChatRoomService
+import kpring.chat.chatroom.service.DistributedLockService
 import kpring.chat.global.ChatRoomTest
 import kpring.chat.global.CommonTest
+import kpring.chat.global.exception.ErrorCode
+import kpring.chat.global.exception.GlobalException
 import kpring.core.chat.chatroom.dto.request.CreateChatRoomRequest
 import java.util.*
 
 class ChatRoomServiceTest : FunSpec({
 
   val chatRoomRepository = mockk<ChatRoomRepository>()
-  val chatRoomService = ChatRoomService(chatRoomRepository)
+  val lockService = mockk<DistributedLockService>()
+  val chatRoomService = ChatRoomService(chatRoomRepository, lockService)
 
   test("createChatRoom 는 새 ChatRoom을 저장해야 한다") {
     // Given
@@ -49,4 +57,66 @@ class ChatRoomServiceTest : FunSpec({
     verify { chatRoomRepository.save(chatRoom) }
     chatRoom.members.shouldNotContain(CommonTest.TEST_USER_ID)
   }
+
+  test("inviteToChatRoomByUserIdWithLock 는 동시성 잠금을 획득한 후 사용자를 초대해야 한다") {
+    // Given
+    val chatRoom =
+      ChatRoom().apply {
+        id = ChatRoomTest.TEST_ROOM_ID
+        addUsers(ChatRoomTest.TEST_MEMBERS)
+      }
+    val lock = Lock("chatRoom:${chatRoom.id}:lock", UUID.randomUUID().toString(), true)
+
+    every { lockService.getLock(any()) } returns lock
+    every { lockService.releaseLock(any(), any()) } returns Unit
+    every { chatRoomRepository.findById(chatRoom.id!!) } returns Optional.of(chatRoom)
+    every { chatRoomRepository.save(any()) } returns chatRoom
+    every { chatRoomRepository.existsByIdAndMembersContaining(any(), CommonTest.TEST_USER_ID) } returns true
+
+    // When
+    chatRoomService.inviteToChatRoomByUserIdWithLock(CommonTest.TEST_USER_ID, CommonTest.TEST_USER_ID, chatRoom.id!!)
+
+    // Then
+    verify { lockService.getLock(any()) }
+    verify { chatRoomRepository.save(chatRoom) }
+    verify { lockService.releaseLock(any(), any()) }
+    chatRoom.members.shouldContain(CommonTest.TEST_USER_ID)
+  }
+
+  test("inviteToChatRoomByUserId 는 사용자를 초대해야 한다") {
+    // Given
+    val chatRoom =
+      ChatRoom().apply {
+        id = ChatRoomTest.TEST_ROOM_ID
+        addUsers(ChatRoomTest.TEST_MEMBERS)
+      }
+
+    every { chatRoomRepository.findById(chatRoom.id!!) } returns Optional.of(chatRoom)
+    every { chatRoomRepository.save(any()) } returns chatRoom
+    every { chatRoomRepository.existsByIdAndMembersContaining(any(), CommonTest.TEST_USER_ID) } returns true
+
+    // When
+    chatRoomService.inviteToChatRoomByUserId(CommonTest.TEST_USER_ID, CommonTest.TEST_USER_ID, chatRoom.id!!)
+
+    // Then
+    verify { chatRoomRepository.save(chatRoom) }
+    chatRoom.members.shouldContain(CommonTest.TEST_USER_ID)
+  }
+
+  test("inviteToChatRoomByUserIdWithLock 는 잠금 획득 실패 시 예외를 발생해야 한다") {
+    // Given
+    val chatRoomId = ChatRoomTest.TEST_ROOM_ID
+    val userId = CommonTest.TEST_USER_ID
+
+    every { lockService.getLock(any()) } throws GlobalException(ErrorCode.CONCURRENCY_CONFLICTION)
+
+    // When
+    val exception =
+      shouldThrow<GlobalException> {
+        chatRoomService.inviteToChatRoomByUserIdWithLock(userId, userId, chatRoomId)
+      }
+
+    // Then
+    exception.getErrorCode() shouldBe ErrorCode.CONCURRENCY_CONFLICTION
+  }
 })