first commit

app/messages/models.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, Enum as SAEnum, ForeignKey, Text, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database.base import Base
+
+if TYPE_CHECKING:
+    from app.chats.models import Chat
+    from app.media.models import Attachment
+    from app.users.models import User
+
+
+class MessageType(str, Enum):
+    TEXT = "text"
+    IMAGE = "image"
+    VIDEO = "video"
+    AUDIO = "audio"
+    VOICE = "voice"
+    FILE = "file"
+    CIRCLE_VIDEO = "circle_video"
+
+
+class Message(Base):
+    __tablename__ = "messages"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True)
+    chat_id: Mapped[int] = mapped_column(ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True)
+    sender_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+    type: Mapped[MessageType] = mapped_column(SAEnum(MessageType), nullable=False, default=MessageType.TEXT)
+    text: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    chat: Mapped["Chat"] = relationship(back_populates="messages")
+    sender: Mapped["User"] = relationship(back_populates="sent_messages")
+    attachments: Mapped[list["Attachment"]] = relationship(back_populates="message", cascade="all, delete-orphan")

app/messages/repository.py

@@ -0,0 +1,41 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.messages.models import Message, MessageType
+
+
+async def create_message(
+    db: AsyncSession,
+    *,
+    chat_id: int,
+    sender_id: int,
+    message_type: MessageType,
+    text: str | None,
+) -> Message:
+    message = Message(chat_id=chat_id, sender_id=sender_id, type=message_type, text=text)
+    db.add(message)
+    await db.flush()
+    return message
+
+
+async def get_message_by_id(db: AsyncSession, message_id: int) -> Message | None:
+    result = await db.execute(select(Message).where(Message.id == message_id))
+    return result.scalar_one_or_none()
+
+
+async def list_chat_messages(
+    db: AsyncSession,
+    chat_id: int,
+    *,
+    limit: int = 50,
+    before_id: int | None = None,
+) -> list[Message]:
+    query = select(Message).where(Message.chat_id == chat_id)
+    if before_id is not None:
+        query = query.where(Message.id < before_id)
+    result = await db.execute(query.order_by(Message.id.desc()).limit(limit))
+    return list(result.scalars().all())
+
+
+async def delete_message(db: AsyncSession, message: Message) -> None:
+    await db.delete(message)

app/messages/router.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, Depends, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.service import get_current_user
+from app.database.session import get_db
+from app.messages.schemas import MessageCreateRequest, MessageRead, MessageUpdateRequest
+from app.messages.service import create_chat_message, delete_message, get_messages, update_message
+from app.users.models import User
+
+router = APIRouter(prefix="/messages", tags=["messages"])
+
+
+@router.post("", response_model=MessageRead, status_code=status.HTTP_201_CREATED)
+async def create_message(
+    payload: MessageCreateRequest,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> MessageRead:
+    return await create_chat_message(db, sender_id=current_user.id, payload=payload)
+
+
+@router.get("/{chat_id}", response_model=list[MessageRead])
+async def list_messages(
+    chat_id: int,
+    limit: int = 50,
+    before_id: int | None = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> list[MessageRead]:
+    return await get_messages(db, chat_id=chat_id, user_id=current_user.id, limit=limit, before_id=before_id)
+
+
+@router.put("/{message_id}", response_model=MessageRead)
+async def edit_message(
+    message_id: int,
+    payload: MessageUpdateRequest,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> MessageRead:
+    return await update_message(db, message_id=message_id, user_id=current_user.id, payload=payload)
+
+
+@router.delete("/{message_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def remove_message(
+    message_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> None:
+    await delete_message(db, message_id=message_id, user_id=current_user.id)

app/messages/schemas.py

@@ -0,0 +1,27 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from app.messages.models import MessageType
+
+
+class MessageRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    chat_id: int
+    sender_id: int
+    type: MessageType
+    text: str | None
+    created_at: datetime
+    updated_at: datetime
+
+
+class MessageCreateRequest(BaseModel):
+    chat_id: int
+    type: MessageType = MessageType.TEXT
+    text: str | None = Field(default=None, max_length=4096)
+
+
+class MessageUpdateRequest(BaseModel):
+    text: str = Field(min_length=1, max_length=4096)

app/messages/service.py

@@ -0,0 +1,67 @@
+from fastapi import HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.chats.service import ensure_chat_membership
+from app.messages import repository
+from app.messages.models import Message
+from app.messages.schemas import MessageCreateRequest, MessageUpdateRequest
+
+
+async def create_chat_message(db: AsyncSession, *, sender_id: int, payload: MessageCreateRequest) -> Message:
+    await ensure_chat_membership(db, chat_id=payload.chat_id, user_id=sender_id)
+    if payload.type.value == "text" and not (payload.text and payload.text.strip()):
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Text message cannot be empty")
+
+    message = await repository.create_message(
+        db,
+        chat_id=payload.chat_id,
+        sender_id=sender_id,
+        message_type=payload.type,
+        text=payload.text,
+    )
+    await db.commit()
+    await db.refresh(message)
+    return message
+
+
+async def get_messages(
+    db: AsyncSession,
+    *,
+    chat_id: int,
+    user_id: int,
+    limit: int = 50,
+    before_id: int | None = None,
+) -> list[Message]:
+    await ensure_chat_membership(db, chat_id=chat_id, user_id=user_id)
+    safe_limit = max(1, min(limit, 100))
+    return await repository.list_chat_messages(db, chat_id, limit=safe_limit, before_id=before_id)
+
+
+async def update_message(
+    db: AsyncSession,
+    *,
+    message_id: int,
+    user_id: int,
+    payload: MessageUpdateRequest,
+) -> Message:
+    message = await repository.get_message_by_id(db, message_id)
+    if not message:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Message not found")
+    await ensure_chat_membership(db, chat_id=message.chat_id, user_id=user_id)
+    if message.sender_id != user_id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can edit only your own messages")
+    message.text = payload.text
+    await db.commit()
+    await db.refresh(message)
+    return message
+
+
+async def delete_message(db: AsyncSession, *, message_id: int, user_id: int) -> None:
+    message = await repository.get_message_by_id(db, message_id)
+    if not message:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Message not found")
+    await ensure_chat_membership(db, chat_id=message.chat_id, user_id=user_id)
+    if message.sender_id != user_id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can delete only your own messages")
+    await repository.delete_message(db, message)
+    await db.commit()