Feat: 채팅 기능 개선

alembic/versions/a930eb13180a_add_last_read_message_id_to_chat_room_.py

@@ -0,0 +1,34 @@
+"""add_last_read_message_id_to_chat_room_member
+
+Revision ID: a930eb13180a
+Revises: 7e51810ce786
+Create Date: 2026-09-04 22:11:01.816890
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'a930eb13180a'
+down_revision: Union[str, Sequence[str], None] = '7e51810ce786'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('chat_room_members', sa.Column('last_read_message_id', sa.Uuid(), nullable=True))
+    op.create_foreign_key('chat_room_members_last_read_message_id_fkey', 'chat_room_members', 'chat_messages', ['last_read_message_id'], ['id'])
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint('chat_room_members_last_read_message_id_fkey', 'chat_room_members', type_='foreignkey')
+    op.drop_column('chat_room_members', 'last_read_message_id')
+    # ### end Alembic commands ###

app/modules/chat/dependencies.py

@@ -1,15 +1,15 @@
+from typing import Annotated
+
 from fastapi import Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.core.database import get_session
+
+from app.core.database import DbSessionDep
 from app.modules.chat.repository import ChatRepository
 from app.modules.chat.service import ChatService
 from app.modules.project.repository import ProjectRepository
 
-async def get_chat_repository(session: AsyncSession = Depends(get_session)) -> ChatRepository:
-    return ChatRepository(session)
 
-async def get_chat_service(
-    session: AsyncSession = Depends(get_session),
-    repository: ChatRepository = Depends(get_chat_repository)
-) -> ChatService:
-    return ChatService(session, repository, ProjectRepository(session))
+def get_chat_service(session: DbSessionDep) -> ChatService:
+    repository = ChatRepository(session)
+    return ChatService(session, repository)
+
+ChatServiceDep = Annotated[ChatService, Depends(get_chat_service)]

app/modules/chat/models.py

@@ -22,6 +22,12 @@ class ChatRoomMember(SQLModel, table=True):
         default_factory=lambda: datetime.now(timezone.utc),
         sa_column=Column(DateTime(timezone=True), nullable=False),
     )
+    last_read_message_id: UUID | None = Field(
+        default=None,
+        foreign_key="chat_messages.id",
+        nullable=True,
+        description="마지막으로 읽은 메시지 고유키",
+    )
 
 class ChatRoom(BaseModel, table=True):
     __tablename__ = "chat_rooms"

app/modules/chat/repository.py

@@ -2,7 +2,7 @@
 from uuid import UUID
 from datetime import datetime, timezone
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import select, and_, func
+from sqlmodel import select, func, update
 from app.modules.chat.models import ChatRoom, ChatRoomMember, ChatMessage
 from app.shared.enums import ChatRoomType
 
@@ -102,6 +102,26 @@ async def get_messages(self, room_id: UUID, limit: int = 50, offset: int = 0) ->
         result = await self.session.execute(stmt)
         return result.scalars().all()
 
+    async def get_message_by_id(self, message_id: UUID) -> ChatMessage | None:
+        stmt = select(ChatMessage).where(ChatMessage.id == message_id)
+        result = await self.session.execute(stmt)
+        return result.scalar()
+
+    async def get_last_messages(self, room_ids: list[UUID]) -> dict[UUID, ChatMessage]:
+        """여러 방의 마지막 메시지를 DISTINCT ON으로 한 번에 조회합니다."""
+        if not room_ids:
+            return {}
+        # DISTINCT ON (chat_room_id) + created_at DESC → 방별 가장 최근 메시지 1건
+        stmt = (
+            select(ChatMessage)
+            .where(ChatMessage.chat_room_id.in_(room_ids), ChatMessage.is_deleted == False)
+            .options(selectinload(ChatMessage.sender))
+            .distinct(ChatMessage.chat_room_id)
+            .order_by(ChatMessage.chat_room_id, ChatMessage.created_at.desc())
+        )
+        result = await self.session.execute(stmt)
+        return {message.chat_room_id: message for message in result.scalars().all()}
+
     async def is_room_member(self, room_id: UUID, member_id: UUID) -> bool:
         stmt = select(ChatRoomMember).where(
             ChatRoomMember.chat_room_id == room_id,
@@ -116,3 +136,34 @@ async def delete_room(self, room: ChatRoom) -> None:
         room.deleted_at = datetime.now(timezone.utc)
         self.session.add(room)
         await self.session.flush()
+
+    async def mark_as_read(self, room_id: UUID, member_id: UUID, message_id: UUID) -> None:
+        await self.session.execute(
+            update(ChatRoomMember)
+            .where(
+                ChatRoomMember.chat_room_id == room_id,
+                ChatRoomMember.member_id == member_id,
+            )
+            .values(last_read_message_id = message_id)
+        )
+
+    async def get_unread_count(self, room_id: UUID, member_id: UUID) -> int:
+        result = await self.session.execute(
+            select(ChatRoomMember.last_read_message_id)
+            .where(
+                ChatRoomMember.chat_room_id == room_id,
+                ChatRoomMember.member_id == member_id,
+            )
+        )
+        last_read_message_id = result.scalar_one_or_none()
+
+        count_query = select(func.count()).where(
+            ChatMessage.chat_room_id == room_id,
+            ChatMessage.is_deleted == False,
+        )
+        if last_read_message_id is not None:
+            sub_query = select(ChatMessage.created_at).where(ChatMessage.id == last_read_message_id).scalar_subquery()
+            count_query = count_query.where(ChatMessage.created_at > sub_query)
+
+        result = await self.session.execute(count_query)
+        return result.scalar_one()