готово
This commit is contained in:
@@ -0,0 +1,160 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import (
|
||||
BigInteger,
|
||||
Boolean,
|
||||
CheckConstraint,
|
||||
DateTime,
|
||||
ForeignKey,
|
||||
ForeignKeyConstraint,
|
||||
Index,
|
||||
Integer,
|
||||
String,
|
||||
Text,
|
||||
UniqueConstraint,
|
||||
false,
|
||||
)
|
||||
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
|
||||
|
||||
from src.core.db.types import Utf8Text
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
pass
|
||||
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = "users"
|
||||
__table_args__ = (
|
||||
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'"),
|
||||
CheckConstraint(
|
||||
"octet_length(display_name) BETWEEN 1 AND 400", name="users_display_name_bytes_check"
|
||||
),
|
||||
)
|
||||
|
||||
id: Mapped[UUID] = mapped_column(primary_key=True)
|
||||
username: Mapped[str] = mapped_column(String(32), unique=True)
|
||||
display_name: Mapped[str] = mapped_column(Utf8Text())
|
||||
password_hash: Mapped[str] = mapped_column(Text)
|
||||
is_admin: Mapped[bool] = mapped_column(Boolean, default=False, server_default=false())
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = "chats"
|
||||
__table_args__ = (
|
||||
CheckConstraint("octet_length(title) BETWEEN 1 AND 400", name="chats_title_bytes_check"),
|
||||
)
|
||||
|
||||
id: Mapped[UUID] = mapped_column(primary_key=True)
|
||||
title: Mapped[str] = mapped_column(Utf8Text())
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
members: Mapped[list["ChatMember"]] = relationship(order_by="ChatMember.user_id")
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
__tablename__ = "chat_members"
|
||||
__table_args__ = (Index("chat_members_user_idx", "user_id", "chat_id"),)
|
||||
|
||||
chat_id: Mapped[UUID] = mapped_column(
|
||||
ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True
|
||||
)
|
||||
user_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
|
||||
|
||||
|
||||
class Message(Base):
|
||||
__tablename__ = "messages"
|
||||
__table_args__ = (
|
||||
ForeignKeyConstraint(
|
||||
["chat_id", "sender_id"], ["chat_members.chat_id", "chat_members.user_id"]
|
||||
),
|
||||
CheckConstraint("octet_length(text) BETWEEN 0 AND 16000", name="messages_text_bytes_check"),
|
||||
UniqueConstraint("chat_id", "id"),
|
||||
Index("messages_history_idx", "chat_id", "created_at", "id"),
|
||||
)
|
||||
|
||||
id: Mapped[UUID] = mapped_column(primary_key=True)
|
||||
chat_id: Mapped[UUID] = mapped_column(ForeignKey("chats.id"))
|
||||
sender_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"))
|
||||
attachments: Mapped[list["MessageAttachment"]] = relationship(
|
||||
lazy="selectin", order_by="MessageAttachment.position"
|
||||
)
|
||||
text: Mapped[str] = mapped_column(Utf8Text())
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
|
||||
|
||||
class MessageRequest(Base):
|
||||
# Таблица обслуживает только POST /chats/{chat_id}/messages: метод и путь
|
||||
# однозначно заданы таблицей и chat_id. Общая область ключа: sender/chat/key.
|
||||
__tablename__ = "message_requests"
|
||||
|
||||
sender_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
|
||||
chat_id: Mapped[UUID] = mapped_column(ForeignKey("chats.id"), primary_key=True)
|
||||
key: Mapped[str] = mapped_column(String(128), primary_key=True)
|
||||
request_text: Mapped[str] = mapped_column(Utf8Text())
|
||||
request_attachment_ids: Mapped[str] = mapped_column(Text, default="", server_default="")
|
||||
message_id: Mapped[UUID | None] = mapped_column(ForeignKey("messages.id"))
|
||||
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
|
||||
|
||||
class Attachment(Base):
|
||||
__tablename__ = "attachments"
|
||||
__table_args__ = (
|
||||
UniqueConstraint("chat_id", "id"),
|
||||
CheckConstraint("size_bytes BETWEEN 1 AND 10485760"),
|
||||
CheckConstraint("content_type IN ('image/png', 'image/jpeg')"),
|
||||
Index("attachments_chat_idx", "chat_id"),
|
||||
)
|
||||
|
||||
id: Mapped[UUID] = mapped_column(primary_key=True)
|
||||
chat_id: Mapped[UUID] = mapped_column(ForeignKey("chats.id"))
|
||||
owner_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"))
|
||||
filename: Mapped[str] = mapped_column(String(255))
|
||||
object_key: Mapped[str] = mapped_column(Text, unique=True)
|
||||
content_type: Mapped[str] = mapped_column(String(32))
|
||||
size_bytes: Mapped[int] = mapped_column(BigInteger)
|
||||
sha256: Mapped[str] = mapped_column(String(64))
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
storage_missing_since: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
|
||||
|
||||
class MessageAttachment(Base):
|
||||
__tablename__ = "message_attachments"
|
||||
__table_args__ = (
|
||||
ForeignKeyConstraint(
|
||||
["chat_id", "message_id"], ["messages.chat_id", "messages.id"], ondelete="CASCADE"
|
||||
),
|
||||
ForeignKeyConstraint(
|
||||
["chat_id", "attachment_id"], ["attachments.chat_id", "attachments.id"]
|
||||
),
|
||||
UniqueConstraint("message_id", "position"),
|
||||
CheckConstraint("position BETWEEN 0 AND 9"),
|
||||
)
|
||||
|
||||
message_id: Mapped[UUID] = mapped_column(primary_key=True)
|
||||
attachment_id: Mapped[UUID] = mapped_column(primary_key=True)
|
||||
chat_id: Mapped[UUID] = mapped_column()
|
||||
position: Mapped[int] = mapped_column(Integer)
|
||||
|
||||
|
||||
class UploadIntent(Base):
|
||||
__tablename__ = "upload_intents"
|
||||
__table_args__ = (CheckConstraint("state IN ('pending', 'committed', 'abandoned')"),)
|
||||
|
||||
object_key: Mapped[str] = mapped_column(Text, primary_key=True)
|
||||
state: Mapped[str] = mapped_column(String(16))
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
|
||||
|
||||
class StorageFinding(Base):
|
||||
__tablename__ = "storage_findings"
|
||||
__table_args__ = (CheckConstraint("kind IN ('orphan', 'missing')"),)
|
||||
|
||||
object_key: Mapped[str] = mapped_column(Text, primary_key=True)
|
||||
kind: Mapped[str] = mapped_column(String(16), primary_key=True)
|
||||
fingerprint: Mapped[str | None] = mapped_column(Text)
|
||||
first_seen: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
last_seen: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
resolved_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
@@ -0,0 +1,16 @@
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.core.db.models import User
|
||||
from src.core.db.repo.user import to_user
|
||||
from src.service.dto import UserCredentialsDTO
|
||||
|
||||
|
||||
async def fetch_user_credentials(
|
||||
session: AsyncSession,
|
||||
username: str,
|
||||
) -> UserCredentialsDTO | None:
|
||||
user = await session.scalar(select(User).where(User.username == username))
|
||||
if user is None:
|
||||
return None
|
||||
return UserCredentialsDTO(user=to_user(user), password_hash=user.password_hash)
|
||||
@@ -0,0 +1,59 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import select, tuple_
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
from sqlalchemy.orm import selectinload
|
||||
|
||||
from src.core.db.models import Chat, ChatMember
|
||||
from src.service.dto import ChatDTO
|
||||
|
||||
|
||||
def to_chat(chat: Chat) -> ChatDTO:
|
||||
return ChatDTO(
|
||||
chat.id, chat.title, tuple(member.user_id for member in chat.members), chat.created_at
|
||||
)
|
||||
|
||||
|
||||
async def fetch_chat_by_id(session: AsyncSession, chat_id: UUID) -> ChatDTO | None:
|
||||
chat = await session.scalar(
|
||||
select(Chat).options(selectinload(Chat.members)).where(Chat.id == chat_id),
|
||||
)
|
||||
return to_chat(chat) if chat else None
|
||||
|
||||
|
||||
async def fetch_chats(
|
||||
session: AsyncSession,
|
||||
user_id: UUID,
|
||||
limit: int,
|
||||
after: tuple[datetime, UUID] | None = None,
|
||||
) -> list[ChatDTO]:
|
||||
query = (
|
||||
select(Chat)
|
||||
.options(selectinload(Chat.members))
|
||||
.join(ChatMember)
|
||||
.where(ChatMember.user_id == user_id)
|
||||
)
|
||||
if after is not None:
|
||||
query = query.where(tuple_(Chat.created_at, Chat.id) > after)
|
||||
chats = await session.scalars(query.order_by(Chat.created_at, Chat.id).limit(limit))
|
||||
return [to_chat(chat) for chat in chats]
|
||||
|
||||
|
||||
async def create_chat(
|
||||
session: AsyncSession,
|
||||
chat_id: UUID,
|
||||
title: str,
|
||||
member_ids: list[UUID],
|
||||
created_at: datetime,
|
||||
) -> ChatDTO:
|
||||
chat = Chat(
|
||||
id=chat_id,
|
||||
title=title,
|
||||
created_at=created_at,
|
||||
members=[ChatMember(user_id=user_id) for user_id in member_ids],
|
||||
)
|
||||
session.add(chat)
|
||||
# ORM сохраняет чат и участников в транзакции текущего запроса.
|
||||
await session.flush()
|
||||
return to_chat(chat)
|
||||
@@ -0,0 +1,148 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import select, tuple_
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.core.db.models import Attachment, Message, MessageAttachment, MessageRequest
|
||||
from src.service.dto import MessageDTO
|
||||
|
||||
|
||||
def to_message(message: Message) -> MessageDTO:
|
||||
return MessageDTO(
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
tuple(link.attachment_id for link in message.attachments),
|
||||
)
|
||||
|
||||
|
||||
def history_query(chat_id: UUID, limit: int, after: tuple[datetime, UUID] | None = None):
|
||||
query = select(Message).where(Message.chat_id == chat_id)
|
||||
if after is not None:
|
||||
query = query.where(tuple_(Message.created_at, Message.id) > after)
|
||||
return query.order_by(Message.created_at, Message.id).limit(limit)
|
||||
|
||||
|
||||
async def fetch_messages_by_chat_id(
|
||||
session: AsyncSession,
|
||||
chat_id: UUID,
|
||||
limit: int,
|
||||
after: tuple[datetime, UUID] | None = None,
|
||||
) -> list[MessageDTO]:
|
||||
messages = await session.scalars(history_query(chat_id, limit, after))
|
||||
return [to_message(message) for message in messages]
|
||||
|
||||
|
||||
async def create_message(
|
||||
session: AsyncSession,
|
||||
message_id: UUID,
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
created_at: datetime,
|
||||
attachment_ids: list[UUID] | None = None,
|
||||
) -> MessageDTO:
|
||||
message = Message(
|
||||
id=message_id,
|
||||
chat_id=chat_id,
|
||||
sender_id=sender_id,
|
||||
text=text,
|
||||
created_at=created_at,
|
||||
attachments=[
|
||||
MessageAttachment(chat_id=chat_id, attachment_id=aid, position=i)
|
||||
for i, aid in enumerate(attachment_ids or [])
|
||||
],
|
||||
)
|
||||
session.add(message)
|
||||
await session.flush()
|
||||
return to_message(message)
|
||||
|
||||
|
||||
async def create_idempotent_message(
|
||||
session: AsyncSession,
|
||||
message_id: UUID,
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
created_at: datetime,
|
||||
idempotency_key: str,
|
||||
attachment_ids: list[UUID] | None = None,
|
||||
) -> MessageDTO:
|
||||
from sqlalchemy import func, update
|
||||
from sqlalchemy import text as sql_text
|
||||
from sqlalchemy.dialects.postgresql import insert
|
||||
|
||||
from src.core.errors import ApiError
|
||||
from src.service.exceptions import IdempotencyConflictException
|
||||
|
||||
attachment_ids = attachment_ids or []
|
||||
request_attachments = ",".join(str(aid) for aid in attachment_ids)
|
||||
if attachment_ids:
|
||||
found = set(
|
||||
await session.scalars(
|
||||
select(Attachment.id).where(
|
||||
Attachment.chat_id == chat_id, Attachment.id.in_(attachment_ids)
|
||||
)
|
||||
)
|
||||
)
|
||||
if found != set(attachment_ids):
|
||||
raise ApiError(404, "not_found", "Вложение не найдено")
|
||||
|
||||
identity = (
|
||||
MessageRequest.sender_id == sender_id,
|
||||
MessageRequest.chat_id == chat_id,
|
||||
MessageRequest.key == idempotency_key,
|
||||
)
|
||||
# UNIQUE/UPSERT сериализует конкурентные повторы даже на разных процессах.
|
||||
# Проигравший ждёт COMMIT; при rollback он сам получает право на создание.
|
||||
values = dict(
|
||||
sender_id=sender_id,
|
||||
chat_id=chat_id,
|
||||
key=idempotency_key,
|
||||
request_text=text,
|
||||
request_attachment_ids=request_attachments,
|
||||
message_id=None,
|
||||
expires_at=func.clock_timestamp() + sql_text("interval '24 hours'"),
|
||||
)
|
||||
claim = (
|
||||
insert(MessageRequest)
|
||||
.values(**values)
|
||||
.on_conflict_do_update(
|
||||
index_elements=["sender_id", "chat_id", "key"],
|
||||
set_={
|
||||
k: v
|
||||
for k, v in values.items()
|
||||
if k in {"request_text", "request_attachment_ids", "message_id", "expires_at"}
|
||||
},
|
||||
where=MessageRequest.expires_at <= func.clock_timestamp(),
|
||||
)
|
||||
.returning(MessageRequest.key)
|
||||
)
|
||||
owned = await session.scalar(claim)
|
||||
if owned is None:
|
||||
existing = (await session.execute(select(MessageRequest).where(*identity))).scalar_one()
|
||||
if existing.request_text != text or existing.request_attachment_ids != request_attachments:
|
||||
raise IdempotencyConflictException
|
||||
message = await session.get(Message, existing.message_id)
|
||||
if message is None:
|
||||
raise RuntimeError("Нарушена атомарность результата идемпотентности")
|
||||
return to_message(message)
|
||||
|
||||
if attachment_ids:
|
||||
missing = await session.scalar(
|
||||
select(Attachment.id)
|
||||
.where(Attachment.id.in_(attachment_ids), Attachment.storage_missing_since.is_not(None))
|
||||
.limit(1)
|
||||
)
|
||||
if missing is not None:
|
||||
raise ApiError(409, "conflict", "Оригинал вложения недоступен")
|
||||
|
||||
message = await create_message(
|
||||
session, message_id, chat_id, sender_id, text, created_at, attachment_ids
|
||||
)
|
||||
await session.execute(update(MessageRequest).where(*identity).values(message_id=message.id))
|
||||
# COMMIT сообщения и ключа выполняется вместе в get_db_session до HTTP 201.
|
||||
return message
|
||||
@@ -0,0 +1,120 @@
|
||||
import json
|
||||
import re
|
||||
from dataclasses import asdict
|
||||
from datetime import datetime, timezone
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.dialects.postgresql import insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.core import cache
|
||||
from src.core.db.models import User
|
||||
from src.service.dto import UserDTO
|
||||
|
||||
|
||||
def to_user(user: User) -> UserDTO:
|
||||
return UserDTO(user.id, user.username, user.display_name, user.created_at)
|
||||
|
||||
|
||||
async def fetch_user_by_id(session: AsyncSession, user_id: UUID) -> UserDTO | None:
|
||||
key = f"user:v1:{user_id}"
|
||||
cached = await cache.get(key)
|
||||
if cached is not None:
|
||||
try:
|
||||
data = json.loads(cached)
|
||||
if (
|
||||
not isinstance(data, dict)
|
||||
or set(data) != {"id", "username", "display_name", "created_at"}
|
||||
or not all(isinstance(value, str) for value in data.values())
|
||||
):
|
||||
raise ValueError
|
||||
created_at = datetime.fromisoformat(data["created_at"])
|
||||
if created_at.tzinfo is None:
|
||||
raise ValueError
|
||||
data["display_name"].encode("utf-8")
|
||||
user = UserDTO(
|
||||
UUID(data["id"]),
|
||||
data["username"],
|
||||
data["display_name"],
|
||||
created_at.astimezone(timezone.utc),
|
||||
)
|
||||
if (
|
||||
user.id != user_id
|
||||
or re.fullmatch(r"[a-z0-9_]{3,32}", user.username) is None
|
||||
or not 1 <= len(user.display_name) <= 100
|
||||
or not user.display_name.strip()
|
||||
or user.created_at.tzinfo is None
|
||||
):
|
||||
raise ValueError
|
||||
return user
|
||||
except (ValueError, KeyError, TypeError, OverflowError):
|
||||
await cache.delete(key)
|
||||
model = await session.get(User, user_id)
|
||||
user = to_user(model) if model else None
|
||||
if user:
|
||||
await cache.set(key, json.dumps(asdict(user), default=str))
|
||||
return user
|
||||
|
||||
|
||||
async def fetch_user_by_username(session: AsyncSession, username: str) -> UserDTO | None:
|
||||
model = await session.scalar(select(User).where(User.username == username))
|
||||
return to_user(model) if model else None
|
||||
|
||||
|
||||
async def create_user(
|
||||
session: AsyncSession,
|
||||
user_id: UUID,
|
||||
username: str,
|
||||
display_name: str,
|
||||
created_at: datetime,
|
||||
password_hash: str,
|
||||
) -> UserDTO:
|
||||
user = User(
|
||||
id=user_id,
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=created_at,
|
||||
password_hash=password_hash,
|
||||
)
|
||||
session.add(user)
|
||||
await session.flush()
|
||||
return to_user(user)
|
||||
|
||||
|
||||
async def users_exist(session: AsyncSession, user_ids: list[UUID]) -> bool:
|
||||
count = await session.scalar(
|
||||
select(func.count()).select_from(User).where(User.id.in_(user_ids))
|
||||
)
|
||||
return count == len(user_ids)
|
||||
|
||||
|
||||
async def create_admin(
|
||||
session: AsyncSession,
|
||||
user_id: UUID,
|
||||
username: str,
|
||||
display_name: str,
|
||||
password_hash: str,
|
||||
created_at: datetime,
|
||||
) -> UserDTO | None:
|
||||
user = await session.scalar(
|
||||
insert(User)
|
||||
.values(
|
||||
id=user_id,
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
password_hash=password_hash,
|
||||
created_at=created_at,
|
||||
is_admin=True,
|
||||
)
|
||||
.on_conflict_do_nothing(index_elements=[User.username])
|
||||
.returning(User)
|
||||
)
|
||||
return to_user(user) if user else None
|
||||
|
||||
|
||||
async def admin_exists(session: AsyncSession, username: str) -> bool:
|
||||
user_id = await session.scalar(
|
||||
select(User.id).where(User.username == username, User.is_admin.is_(True))
|
||||
)
|
||||
return user_id is not None
|
||||
@@ -0,0 +1,48 @@
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
|
||||
|
||||
from src.core.cache import close_cache, open_cache
|
||||
from src.core.settings import settings
|
||||
|
||||
session_factory: async_sessionmaker[AsyncSession] | None = None
|
||||
|
||||
|
||||
def create_engine():
|
||||
return create_async_engine(
|
||||
settings.sqlalchemy_database_url,
|
||||
pool_size=settings.database_pool_size,
|
||||
max_overflow=settings.database_max_overflow,
|
||||
pool_timeout=settings.database_pool_timeout_seconds,
|
||||
pool_pre_ping=settings.database_pool_pre_ping,
|
||||
hide_parameters=True,
|
||||
connect_args={
|
||||
"timeout": settings.database_connect_timeout_seconds,
|
||||
"command_timeout": settings.database_command_timeout_seconds,
|
||||
"server_settings": {"statement_timeout": str(settings.database_statement_timeout_ms)},
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def database_lifespan(app):
|
||||
global session_factory
|
||||
engine = create_engine()
|
||||
session_factory = async_sessionmaker(engine, expire_on_commit=False)
|
||||
open_cache()
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
await close_cache()
|
||||
await engine.dispose()
|
||||
session_factory = None
|
||||
|
||||
|
||||
async def get_db_session():
|
||||
if session_factory is None:
|
||||
raise RuntimeError("Фабрика сессий не запущена")
|
||||
async with session_factory() as session:
|
||||
# Одна транзакция на запрос: аутентификация и бизнес-операция вместе.
|
||||
# Depends(scope='function') завершает COMMIT до отправки ответа.
|
||||
async with session.begin():
|
||||
yield session
|
||||
@@ -0,0 +1,15 @@
|
||||
"""Unicode-строки в UTF-8 bytea: PostgreSQL text не допускает U+0000."""
|
||||
|
||||
from sqlalchemy import LargeBinary
|
||||
from sqlalchemy.types import TypeDecorator
|
||||
|
||||
|
||||
class Utf8Text(TypeDecorator[str]):
|
||||
impl = LargeBinary
|
||||
cache_ok = True
|
||||
|
||||
def process_bind_param(self, value: str | None, dialect) -> bytes | None:
|
||||
return None if value is None else value.encode("utf-8")
|
||||
|
||||
def process_result_value(self, value: bytes | None, dialect) -> str | None:
|
||||
return None if value is None else value.decode("utf-8")
|
||||
Reference in New Issue
Block a user