готово

This commit is contained in:
2026-11-12 19:38:03 +03:00
parent ec540a1a72
commit f3ba37f736
142 changed files with 10257 additions and 0 deletions
View File
+160
View File
@@ -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))
View File
+16
View File
@@ -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)
+59
View File
@@ -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)
+148
View File
@@ -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
+120
View File
@@ -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
+48
View File
@@ -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
+15
View File
@@ -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")