From 3082b84f61c0554719763c97db37d6c19cb7a7c5 Mon Sep 17 00:00:00 2001 From: gytall Date: Mon, 26 Oct 2026 21:59:40 +0300 Subject: [PATCH] add migrations, create domain and crud layers --- .gitignore | 3 +- app/core/security.py | 11 +- app/domain/__init__.py | 13 +-- app/domain/auth.py | 54 ++++++++- app/domain/chats.py | 98 +++++++++------- app/domain/messages.py | 55 ++++----- app/domain/pagination.py | 6 +- app/domain/users.py | 45 +++++--- app/endpoints/auth.py | 28 ++--- app/endpoints/chats.py | 25 ++-- app/endpoints/dependencies.py | 21 +++- app/endpoints/messages.py | 26 ++--- app/endpoints/users.py | 12 +- app/models/__init__.py | 3 +- app/models/base.py | 4 +- app/models/chat_member.py | 4 +- app/models/counter.py | 13 +++ app/schemas/__init__.py | 2 +- app/schemas/chat.py | 3 +- app/schemas/message.py | 1 + app/schemas/user.py | 8 +- app/storage/__init__.py | 11 +- app/storage/chats.py | 75 ++++++------ app/storage/messages.py | 57 ++++++---- app/storage/sessions.py | 25 ++-- app/storage/users.py | 49 ++++---- .../db06fd3126ff_create_initial_schema.py | 107 ++++++++++++++++++ 27 files changed, 481 insertions(+), 278 deletions(-) create mode 100644 app/models/counter.py create mode 100644 migrations/versions/db06fd3126ff_create_initial_schema.py diff --git a/.gitignore b/.gitignore index d3561ad5..6f50f78f 100644 --- a/.gitignore +++ b/.gitignore @@ -30,4 +30,5 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. -/venv \ No newline at end of file +/venv +.ruff_cache/ \ No newline at end of file diff --git a/app/core/security.py b/app/core/security.py index 4cb2b28f..70952e78 100644 --- a/app/core/security.py +++ b/app/core/security.py @@ -13,15 +13,18 @@ TOKEN_BYTES = 32 _hasher = PasswordHasher() _executor = ThreadPoolExecutor( - max_workers=os.cpu_count() or 1, thread_name_prefix="argon2" + max_workers=max(1, (os.cpu_count() or 1) // _hasher.parallelism), + thread_name_prefix="argon2", ) def _hash_password_sync(password: str) -> str: + """Блокирующий расчёт Argon2id-хеша со случайной солью в формате PHC.""" return _hasher.hash(password) def _verify_password_sync(password: str, password_hash: str) -> bool: + """Блокирующая проверка пароля по PHC-строке; False при несовпадении или повреждённом хеше.""" try: return _hasher.verify(password_hash, password) except (VerificationError, InvalidHashError): @@ -32,11 +35,13 @@ _DUMMY_HASH = _hash_password_sync(secrets.token_urlsafe(TOKEN_BYTES)) async def hash_password(password: str) -> str: + """Хеширует пароль в пуле потоков, не блокируя event loop.""" loop = asyncio.get_running_loop() return await loop.run_in_executor(_executor, _hash_password_sync, password) async def verify_password(password: str, password_hash: str) -> bool: + """Проверяет пароль в пуле потоков, не блокируя event loop.""" loop = asyncio.get_running_loop() return await loop.run_in_executor( _executor, _verify_password_sync, password, password_hash @@ -44,13 +49,15 @@ async def verify_password(password: str, password_hash: str) -> bool: async def dummy_verify_password(password: str) -> None: - """Выравнивает время ответа для несуществующего пользователя.""" + """Проверка против фиктивного хеша: время ответа не выдаёт отсутствие пользователя.""" await verify_password(password, _DUMMY_HASH) def generate_token() -> str: + """Непрозрачный токен сессии: 32 случайных байта в base64url.""" return secrets.token_urlsafe(TOKEN_BYTES) def hash_token(token: str) -> str: + """SHA-256 токена в hex: детерминированный ключ для хранилища сессий.""" return hashlib.sha256(token.encode()).hexdigest() diff --git a/app/domain/__init__.py b/app/domain/__init__.py index 2a78e69f..93c96d54 100644 --- a/app/domain/__init__.py +++ b/app/domain/__init__.py @@ -1,12 +1 @@ -"""Бизнес-логика. Здесь решается, какая ошибка API соответствует ситуации. - -Правила слоя: - * функции это `async def`, первым аргументом принимают AsyncSession; - * CPU-тяжёлое (Argon2) — только через security.hash_password/verify_password (они уходят в thread); - * не запускайте asyncio.gather на ОДНОЙ сессии: AsyncSession не потокобезопасна и не рассчитана на параллельные запросы; - * возвращают pydantic-схемы (app.schemas), а не ORM-объекты; - * вызывают app.storage.* и бросают ApiError из app.errors.exceptions; - * ВЛАДЕЮТ ТРАНЗАКЦИЕЙ: именно здесь await session.commit(); при ошибке — rollback - (незакоммиченная сессия в любом случае откатывается при закрытии в dependency); - * никаких Request/Response/HTTP-заголовков — это слой endpoints. -""" +"""Бизнес-логика: проверки доступа, транзакции и ошибки API.""" diff --git a/app/domain/auth.py b/app/domain/auth.py index b1904786..57aefbe9 100644 --- a/app/domain/auth.py +++ b/app/domain/auth.py @@ -1,8 +1,15 @@ +from datetime import UTC, datetime, timedelta + from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession +from app.core import security +from app.domain.users import to_user_schema +from app.errors.exceptions import unauthorized_basic, unauthorized_bearer from app.schemas.session import AuthSession -from app.schemas.user import User +from app.schemas.user import PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, User +from app.storage import sessions as sessions_storage +from app.storage import users as users_storage async def create_session( @@ -13,14 +20,53 @@ async def create_session( ttl_seconds: int, ) -> AuthSession: """Проверяет учётные данные и выдаёт новый Bearer-токен.""" - raise NotImplementedError + if not PASSWORD_MIN_LENGTH <= len(password) <= PASSWORD_MAX_LENGTH: + raise unauthorized_basic() + + user = await users_storage.get_user_by_username(session, username) + await session.commit() + + if user is None: + await security.dummy_verify_password(password) + raise unauthorized_basic() + + if not await security.verify_password(password, user.password_hash): + raise unauthorized_basic() + + token = security.generate_token() + expires_at = datetime.now(UTC) + timedelta(seconds=ttl_seconds) + await sessions_storage.create_session( + redis, + token_hash=security.hash_token(token), + user_id=user.id, + expires_at=expires_at, + ) + auth_session = AuthSession( + token=token, expires_at=expires_at, user=to_user_schema(user) + ) + return auth_session async def authenticate_token(session: AsyncSession, redis: Redis, token: str) -> User: """Возвращает владельца действующей сессии или бросает 401.""" - raise NotImplementedError + user_id = await sessions_storage.get_session_user_id( + redis, security.hash_token(token) + ) + if user_id is None: + raise unauthorized_bearer() + + user = await users_storage.get_user_by_id(session, user_id) + if user is None: + raise unauthorized_bearer() + + current_user = to_user_schema(user) + return current_user async def revoke_session(redis: Redis, token: str) -> None: """Отзывает текущую сессию; повторный отзыв даёт 401.""" - raise NotImplementedError + is_deleted = await sessions_storage.delete_session( + redis, security.hash_token(token) + ) + if not is_deleted: + raise unauthorized_bearer() diff --git a/app/domain/chats.py b/app/domain/chats.py index 833cf473..c810a982 100644 --- a/app/domain/chats.py +++ b/app/domain/chats.py @@ -1,5 +1,6 @@ from uuid import UUID +from sqlalchemy.exc import IntegrityError from sqlalchemy.ext.asyncio import AsyncSession from app.domain.pagination import ( @@ -8,26 +9,30 @@ from app.domain.pagination import ( decode_cursor, split_page, ) -from app.errors.exceptions import invalid_request +from app.errors.exceptions import invalid_request, not_found from app.models.chat import Chat as ChatModel from app.schemas.chat import Chat, ChatPage, CreateChat from app.schemas.user import User +from app.storage import chats as chats_storage +from app.storage import users as users_storage from app.storage.types import Position +UNKNOWN_MEMBER_MESSAGE = "member_ids содержит неизвестного пользователя" + def to_chat_schema(chat: ChatModel) -> Chat: - """ORM -> схема. member_ids собираются из chat.members (relationship). - - Алгоритм: Chat(id=chat.id, title=chat.title, - member_ids=[m.user_id for m in chat.members], created_at=chat.created_at) - Синхронная: chat.members уже загружены (selectin / refresh в storage), - ленивой загрузки в async нет. - """ - raise NotImplementedError("TODO") + """Преобразует ORM-модель чата с загруженными участниками в схему.""" + chat_schema = Chat( + id=chat.id, + title=chat.title, + member_ids=[member.user_id for member in chat.members], + created_at=chat.created_at, + ) + return chat_schema def validate_new_chat(creator: User, new_chat: CreateChat) -> None: - """Проверки, не требующие БД (перенесено из lab1 как есть).""" + """Проверяет состав участников без обращения к базе.""" member_ids = new_chat.member_ids if creator.id not in member_ids: @@ -37,30 +42,45 @@ def validate_new_chat(creator: User, new_chat: CreateChat) -> None: raise invalid_request("member_ids содержит дубликаты") -async def create_chat(session: AsyncSession, creator: User, new_chat: CreateChat) -> Chat: - """POST /chats. +async def create_chat( + session: AsyncSession, creator: User, new_chat: CreateChat +) -> Chat: + """Создаёт чат с участниками атомарно; неверный состав даёт 400.""" + validate_new_chat(creator, new_chat) - Алгоритм: - 1. validate_new_chat(creator, new_chat) - 2. known = await storage.users.get_existing_user_ids(session, new_chat.member_ids) - known != set(new_chat.member_ids) -> raise invalid_request("member_ids содержит неизвестного пользователя") - 3. chat = await storage.chats.create_chat(session, title=new_chat.title, member_ids=new_chat.member_ids) - await session.commit() — чат и все участники появляются вместе или не появляются вовсе - (при исключении между create_chat и commit: await session.rollback(); raise) - 4. return to_chat_schema(chat) - """ - raise NotImplementedError("TODO") + existing_ids = await users_storage.get_existing_user_ids( + session, new_chat.member_ids + ) + if existing_ids != set(new_chat.member_ids): + raise invalid_request(UNKNOWN_MEMBER_MESSAGE) + + try: + chat = await chats_storage.create_chat( + session, title=new_chat.title, member_ids=new_chat.member_ids + ) + await session.commit() + except IntegrityError: + await session.rollback() + raise invalid_request(UNKNOWN_MEMBER_MESSAGE) from None + + created_chat = to_chat_schema(chat) + return created_chat async def get_chat(session: AsyncSession, user: User, chat_id: UUID) -> Chat: - """GET /chats/{id}. + """Возвращает чат участнику; чужой и несуществующий чат дают 404.""" + chat = await chats_storage.get_chat_for_member(session, chat_id, user.id) + if chat is None: + raise not_found() - Алгоритм: - 1. chat = await storage.chats.get_chat_for_member(session, chat_id, user.id) - 2. chat is None -> raise not_found() (и для чужого, и для несуществующего чата — одинаково) - 3. return to_chat_schema(chat) - """ - raise NotImplementedError("TODO") + found_chat = to_chat_schema(chat) + return found_chat + + +async def ensure_chat_member(session: AsyncSession, user: User, chat_id: UUID) -> None: + """Бросает 404, если пользователь не состоит в чате или чата нет.""" + if not await chats_storage.is_chat_member(session, chat_id, user.id): + raise not_found() async def list_chats( @@ -69,18 +89,16 @@ async def list_chats( cursor: str | None, limit: int, ) -> ChatPage: - """GET /chats — keyset-пагинация (логика курсора перенесена из lab1). - - Алгоритм: - 1. after = decode_cursor(cursor, KIND_CHATS, user.id), если cursor не None (битый/чужой -> 400) - 2. rows = await storage.chats.list_chats_for_user(session, user.id, after, limit + 1) - 3. items, has_next = split_page(rows, limit) - 4. next_cursor = build_next_cursor(KIND_CHATS, user.id, items, has_next) - 5. return ChatPage(items=[to_chat_schema(c) for c in items], next_cursor=next_cursor) - """ + """Возвращает страницу чатов пользователя по (created_at, id).""" after: Position | None = None if cursor is not None: after = decode_cursor(cursor, KIND_CHATS, user.id) - _ = (split_page, build_next_cursor, after) - raise NotImplementedError("TODO") + rows = await chats_storage.list_chats_for_user(session, user.id, after, limit + 1) + page_rows, has_next = split_page(rows, limit) + items = [to_chat_schema(chat) for chat in page_rows] + page = ChatPage( + items=items, + next_cursor=build_next_cursor(KIND_CHATS, user.id, items, has_next), + ) + return page diff --git a/app/domain/messages.py b/app/domain/messages.py index b84cdc43..2f7405f1 100644 --- a/app/domain/messages.py +++ b/app/domain/messages.py @@ -2,14 +2,17 @@ from uuid import UUID from sqlalchemy.ext.asyncio import AsyncSession +from app.domain.chats import ensure_chat_member from app.domain.pagination import ( KIND_MESSAGES, build_next_cursor, decode_cursor, split_page, ) +from app.errors.exceptions import unavailable from app.schemas.message import CreateMessage, Message, MessagePage from app.schemas.user import User +from app.storage import messages as messages_storage from app.storage.types import Position @@ -20,21 +23,19 @@ async def send_message( new_message: CreateMessage, max_messages: int, ) -> Message: - """POST /chats/{id}/messages. + """Отправляет сообщение от имени участника; при исчерпании лимита даёт 503.""" + await ensure_chat_member(session, sender, chat_id) - Алгоритм: - 1. await domain.chats.get_chat(session, sender, chat_id) -> 404 для постороннего - 2. await storage.messages.count_messages(session) >= max_messages - -> raise unavailable("Достигнут лимит количества сообщений") (503) - Ранее подтверждённые сообщения НЕ удаляются. - 3. message = await storage.messages.create_message(session, chat_id=chat_id, sender_id=sender.id, text=new_message.text) - 4. await session.commit() - 5. return Message.model_validate(message) - Гонка у лимита: два запроса могут одновременно пройти п.2. Решите, допустимо ли - превышение на несколько сообщений (напишите в отчёте), либо сериализуйте проверку - через pg_advisory_xact_lock в той же транзакции. - """ - raise NotImplementedError("TODO") + if not await messages_storage.reserve_message_slot(session, max_messages): + raise unavailable("Достигнут лимит количества сообщений") + + message = await messages_storage.create_message( + session, chat_id=chat_id, sender_id=sender.id, text=new_message.text + ) + await session.commit() + + sent_message = Message.model_validate(message) + return sent_message async def list_messages( @@ -44,16 +45,18 @@ async def list_messages( cursor: str | None, limit: int, ) -> MessagePage: - """GET /chats/{id}/messages — keyset-пагинация. + """Возвращает страницу истории чата по (created_at, id).""" + after: Position | None = None + if cursor is not None: + after = decode_cursor(cursor, KIND_MESSAGES, chat_id) - Алгоритм: - 1. await domain.chats.get_chat(session, user, chat_id) -> 404, если нет доступа - 2. after = decode_cursor(cursor, KIND_MESSAGES, chat_id), если cursor не None - (битый или чужой cursor -> 400) - 3. rows = await storage.messages.list_messages(session, chat_id, after, limit + 1) - 4. items, has_next = split_page(rows, limit) - 5. next_cursor = build_next_cursor(KIND_MESSAGES, chat_id, items, has_next) - 6. return MessagePage(items=[Message.model_validate(m) for m in items], next_cursor=next_cursor) - """ - _ = (decode_cursor, KIND_MESSAGES, split_page, build_next_cursor, Position) - raise NotImplementedError("TODO") + await ensure_chat_member(session, user, chat_id) + + rows = await messages_storage.list_messages(session, chat_id, after, limit + 1) + page_rows, has_next = split_page(rows, limit) + items = [Message.model_validate(message) for message in page_rows] + page = MessagePage( + items=items, + next_cursor=build_next_cursor(KIND_MESSAGES, chat_id, items, has_next), + ) + return page diff --git a/app/domain/pagination.py b/app/domain/pagination.py index 9a06e830..9894437c 100644 --- a/app/domain/pagination.py +++ b/app/domain/pagination.py @@ -15,7 +15,7 @@ T = TypeVar("T") class Positioned(Protocol): - """Всё, у чего есть позиция в порядке (created_at, id): ORM-модели и схемы.""" + """Объект с позицией в порядке (created_at, id).""" @property def id(self) -> UUID: ... @@ -30,6 +30,7 @@ def encode_cursor( created_at: datetime, item_id: UUID, ) -> str: + """Кодирует позицию и ресурс, к которому она привязана, в непрозрачный cursor.""" payload = { "kind": kind, "resource_id": str(resource_id), @@ -41,6 +42,7 @@ def encode_cursor( def decode_cursor(cursor: str, kind: str, resource_id: UUID) -> Position: + """Возвращает позицию из cursor; битый или чужой cursor даёт 400.""" try: payload = json.loads(base64.urlsafe_b64decode(cursor)) cursor_kind = payload["kind"] @@ -61,6 +63,7 @@ def decode_cursor(cursor: str, kind: str, resource_id: UUID) -> Position: def split_page(rows: list[T], limit: int) -> tuple[list[T], bool]: + """Отделяет страницу от лишней строки limit + 1, по которой видно продолжение.""" has_next = len(rows) > limit items = rows[:limit] return items, has_next @@ -72,6 +75,7 @@ def build_next_cursor( items: Sequence[Positioned], has_next: bool, ) -> str | None: + """Возвращает cursor на последний элемент страницы или None, если она последняя.""" if not has_next: return None diff --git a/app/domain/users.py b/app/domain/users.py index 0bbbbb2c..461bf0d9 100644 --- a/app/domain/users.py +++ b/app/domain/users.py @@ -1,28 +1,41 @@ from sqlalchemy.exc import IntegrityError from sqlalchemy.ext.asyncio import AsyncSession +from app.core import security +from app.errors.exceptions import conflict from app.models.user import User as UserModel from app.schemas.user import CreateUser, User +from app.storage import users as users_storage + +USERNAME_TAKEN_MESSAGE = "Имя пользователя уже занято" def to_user_schema(user: UserModel) -> User: - """ORM -> публичная схема (без password_hash). Синхронная: только преобразование.""" - return User.model_validate(user) + """Преобразует ORM-модель в публичную схему без password_hash.""" + user_schema = User.model_validate(user) + return user_schema async def register_user(session: AsyncSession, new_user: CreateUser) -> User: - """POST /users. + """Регистрирует пользователя; занятый username даёт 409.""" + existing_user = await users_storage.get_user_by_username(session, new_user.username) + await session.commit() + if existing_user is not None: + raise conflict(USERNAME_TAKEN_MESSAGE) - Алгоритм: - 1. password_hash = await security.hash_password(new_user.password) - — ДО обращения к БД: Argon2 идёт в thread, транзакцию из-за него не держим. - 2. try: - user = await storage.users.create_user(session, username=..., display_name=..., password_hash=...) - await session.commit() - 3. except IntegrityError: - await session.rollback() - raise conflict("Username уже занят") - Источник истины для гонки двух одинаковых username — UNIQUE в БД, не SELECT перед INSERT. - 4. return to_user_schema(user) - """ - raise NotImplementedError("TODO") + password_hash = await security.hash_password(new_user.password) + + try: + user = await users_storage.create_user( + session, + username=new_user.username, + display_name=new_user.display_name, + password_hash=password_hash, + ) + await session.commit() + except IntegrityError: + await session.rollback() + raise conflict(USERNAME_TAKEN_MESSAGE) from None + + created_user = to_user_schema(user) + return created_user diff --git a/app/endpoints/auth.py b/app/endpoints/auth.py index aa8131ab..69f4535f 100644 --- a/app/endpoints/auth.py +++ b/app/endpoints/auth.py @@ -1,15 +1,12 @@ -from fastapi import APIRouter, Depends, Response -from redis.asyncio import Redis -from sqlalchemy.ext.asyncio import AsyncSession +from fastapi import APIRouter, Response -from app.core.config import Settings from app.domain.auth import create_session, revoke_session from app.endpoints.dependencies import ( - get_basic_credentials, - get_bearer_token, - get_db, - get_redis, - get_settings, + AppSettings, + BasicCredentials, + BearerToken, + DbSession, + RedisClient, ) from app.schemas.session import AuthSession @@ -18,10 +15,10 @@ router = APIRouter(prefix="/api/v1/auth", tags=["auth"]) @router.post("/sessions", status_code=201) async def login( - credentials: tuple[str, str] = Depends(get_basic_credentials), - session: AsyncSession = Depends(get_db), - redis: Redis = Depends(get_redis), - settings: Settings = Depends(get_settings), + credentials: BasicCredentials, + session: DbSession, + redis: RedisClient, + settings: AppSettings, ) -> AuthSession: username, password = credentials return await create_session( @@ -30,9 +27,6 @@ async def login( @router.delete("/sessions/current", status_code=204) -async def logout( - token: str = Depends(get_bearer_token), - redis: Redis = Depends(get_redis), -) -> Response: +async def logout(token: BearerToken, redis: RedisClient) -> Response: await revoke_session(redis, token) return Response(status_code=204) diff --git a/app/endpoints/chats.py b/app/endpoints/chats.py index 0c49289a..91f2b211 100644 --- a/app/endpoints/chats.py +++ b/app/endpoints/chats.py @@ -1,39 +1,32 @@ +from typing import Annotated from uuid import UUID -from fastapi import APIRouter, Depends, Query -from sqlalchemy.ext.asyncio import AsyncSession +from fastapi import APIRouter, Query from app.domain.chats import create_chat, get_chat, list_chats -from app.endpoints.dependencies import get_current_user, get_db +from app.endpoints.dependencies import CurrentUser, DbSession from app.schemas.chat import Chat, ChatPage, CreateChat -from app.schemas.user import User router = APIRouter(prefix="/api/v1/chats", tags=["chats"]) @router.post("", status_code=201) async def create_new_chat( - new_chat: CreateChat, - creator: User = Depends(get_current_user), - session: AsyncSession = Depends(get_db), + new_chat: CreateChat, creator: CurrentUser, session: DbSession ) -> Chat: return await create_chat(session, creator, new_chat) @router.get("") async def list_user_chats( - limit: int = Query(50, ge=1, le=100), - cursor: str | None = Query(None, min_length=1), - user: User = Depends(get_current_user), - session: AsyncSession = Depends(get_db), + user: CurrentUser, + session: DbSession, + limit: Annotated[int, Query(ge=1, le=100)] = 50, + cursor: Annotated[str | None, Query(min_length=1)] = None, ) -> ChatPage: return await list_chats(session, user, cursor, limit) @router.get("/{chat_id}") -async def get_chat_by_id( - chat_id: UUID, - user: User = Depends(get_current_user), - session: AsyncSession = Depends(get_db), -) -> Chat: +async def get_chat_by_id(chat_id: UUID, user: CurrentUser, session: DbSession) -> Chat: return await get_chat(session, user, chat_id) diff --git a/app/endpoints/dependencies.py b/app/endpoints/dependencies.py index b48d1906..2c5df7e8 100644 --- a/app/endpoints/dependencies.py +++ b/app/endpoints/dependencies.py @@ -1,6 +1,7 @@ import base64 import binascii from collections.abc import AsyncIterator +from typing import Annotated from fastapi import Depends, Header, Request from redis.asyncio import Redis @@ -38,7 +39,9 @@ def _split_authorization(authorization: str | None) -> tuple[str, str] | None: return scheme.lower(), value.strip() -async def get_bearer_token(authorization: str | None = Header(default=None)) -> str: +async def get_bearer_token( + authorization: Annotated[str | None, Header()] = None, +) -> str: parts = _split_authorization(authorization) if parts is None or parts[0] != "bearer": raise unauthorized_bearer() @@ -46,7 +49,7 @@ async def get_bearer_token(authorization: str | None = Header(default=None)) -> async def get_basic_credentials( - authorization: str | None = Header(default=None), + authorization: Annotated[str | None, Header()] = None, ) -> tuple[str, str]: """(username, password) из `Authorization: Basic`; пароль может содержать ':'.""" parts = _split_authorization(authorization) @@ -64,9 +67,17 @@ async def get_basic_credentials( return username, password +DbSession = Annotated[AsyncSession, Depends(get_db)] +RedisClient = Annotated[Redis, Depends(get_redis)] +AppSettings = Annotated[Settings, Depends(get_settings)] +BearerToken = Annotated[str, Depends(get_bearer_token)] +BasicCredentials = Annotated[tuple[str, str], Depends(get_basic_credentials)] + + async def get_current_user( - token: str = Depends(get_bearer_token), - session: AsyncSession = Depends(get_db), - redis: Redis = Depends(get_redis), + token: BearerToken, session: DbSession, redis: RedisClient ) -> User: return await authenticate_token(session, redis, token) + + +CurrentUser = Annotated[User, Depends(get_current_user)] diff --git a/app/endpoints/messages.py b/app/endpoints/messages.py index a267e253..afadef53 100644 --- a/app/endpoints/messages.py +++ b/app/endpoints/messages.py @@ -1,13 +1,11 @@ +from typing import Annotated from uuid import UUID -from fastapi import APIRouter, Depends, Query -from sqlalchemy.ext.asyncio import AsyncSession +from fastapi import APIRouter, Query -from app.core.config import Settings from app.domain.messages import list_messages, send_message -from app.endpoints.dependencies import get_current_user, get_db, get_settings +from app.endpoints.dependencies import AppSettings, CurrentUser, DbSession from app.schemas.message import CreateMessage, Message, MessagePage -from app.schemas.user import User router = APIRouter(prefix="/api/v1/chats", tags=["messages"]) @@ -16,19 +14,21 @@ router = APIRouter(prefix="/api/v1/chats", tags=["messages"]) async def send_new_message( chat_id: UUID, new_message: CreateMessage, - sender: User = Depends(get_current_user), - session: AsyncSession = Depends(get_db), - settings: Settings = Depends(get_settings), + sender: CurrentUser, + session: DbSession, + settings: AppSettings, ) -> Message: - return await send_message(session, sender, chat_id, new_message, settings.max_messages) + return await send_message( + session, sender, chat_id, new_message, settings.max_messages + ) @router.get("/{chat_id}/messages") async def get_history_messages( chat_id: UUID, - limit: int = Query(50, ge=1, le=100), - cursor: str | None = Query(None, min_length=1), - user: User = Depends(get_current_user), - session: AsyncSession = Depends(get_db), + user: CurrentUser, + session: DbSession, + limit: Annotated[int, Query(ge=1, le=100)] = 50, + cursor: Annotated[str | None, Query(min_length=1)] = None, ) -> MessagePage: return await list_messages(session, user, chat_id, cursor, limit) diff --git a/app/endpoints/users.py b/app/endpoints/users.py index 5cc234e8..c502d010 100644 --- a/app/endpoints/users.py +++ b/app/endpoints/users.py @@ -1,21 +1,17 @@ -from fastapi import APIRouter, Depends -from sqlalchemy.ext.asyncio import AsyncSession +from fastapi import APIRouter from app.domain.users import register_user -from app.endpoints.dependencies import get_current_user, get_db +from app.endpoints.dependencies import CurrentUser, DbSession from app.schemas.user import CreateUser, User router = APIRouter(prefix="/api/v1/users", tags=["users"]) @router.post("", status_code=201) -async def create_user( - new_user: CreateUser, - session: AsyncSession = Depends(get_db), -) -> User: +async def create_user(new_user: CreateUser, session: DbSession) -> User: return await register_user(session, new_user) @router.get("/me") -async def get_me(user: User = Depends(get_current_user)) -> User: +async def get_me(user: CurrentUser) -> User: return user diff --git a/app/models/__init__.py b/app/models/__init__.py index 3a3e380d..9d56e6e2 100644 --- a/app/models/__init__.py +++ b/app/models/__init__.py @@ -1,7 +1,8 @@ from app.models.base import Base from app.models.chat import Chat from app.models.chat_member import ChatMember +from app.models.counter import Counter from app.models.message import Message from app.models.user import User -__all__ = ["Base", "User", "Chat", "ChatMember", "Message"] +__all__ = ["Base", "Chat", "ChatMember", "Counter", "Message", "User"] diff --git a/app/models/base.py b/app/models/base.py index c902adec..15a748e5 100644 --- a/app/models/base.py +++ b/app/models/base.py @@ -1,9 +1,11 @@ import uuid from datetime import datetime +from typing import Any, ClassVar from sqlalchemy import DateTime, MetaData from sqlalchemy.dialects.postgresql import UUID as PG_UUID from sqlalchemy.orm import DeclarativeBase +from sqlalchemy.types import TypeEngine NAMING_CONVENTION = { "ix": "ix_%(column_0_label)s", @@ -19,7 +21,7 @@ class Base(DeclarativeBase): metadata = MetaData(naming_convention=NAMING_CONVENTION) - type_annotation_map = { + type_annotation_map: ClassVar[dict[Any, TypeEngine[Any]]] = { uuid.UUID: PG_UUID(as_uuid=True), datetime: DateTime(timezone=True), } diff --git a/app/models/chat_member.py b/app/models/chat_member.py index dcacdfe5..567ffd66 100644 --- a/app/models/chat_member.py +++ b/app/models/chat_member.py @@ -20,9 +20,7 @@ class ChatMember(Base): chat_id: Mapped[uuid.UUID] = mapped_column( ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True ) - user_id: Mapped[uuid.UUID] = mapped_column( - ForeignKey("users.id"), primary_key=True - ) + user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True) chat: Mapped["Chat"] = relationship(back_populates="members", lazy="raise") user: Mapped["User"] = relationship(back_populates="memberships", lazy="raise") diff --git a/app/models/counter.py b/app/models/counter.py new file mode 100644 index 00000000..5f6706b5 --- /dev/null +++ b/app/models/counter.py @@ -0,0 +1,13 @@ +from sqlalchemy import BigInteger, String +from sqlalchemy.orm import Mapped, mapped_column + +from app.models.base import Base + + +class Counter(Base): + """Именованный счётчик с атомарным обновлением.""" + + __tablename__ = "counters" + + name: Mapped[str] = mapped_column(String(64), primary_key=True) + value: Mapped[int] = mapped_column(BigInteger) diff --git a/app/schemas/__init__.py b/app/schemas/__init__.py index ac3ac2a7..2f038940 100644 --- a/app/schemas/__init__.py +++ b/app/schemas/__init__.py @@ -3,4 +3,4 @@ from app.schemas.message import Message from app.schemas.session import AuthSession from app.schemas.user import User -__all__ = ["User", "Chat", "Message", "AuthSession"] +__all__ = ["AuthSession", "Chat", "Message", "User"] diff --git a/app/schemas/chat.py b/app/schemas/chat.py index 806cf13f..c0436dab 100644 --- a/app/schemas/chat.py +++ b/app/schemas/chat.py @@ -1,5 +1,6 @@ -from uuid import UUID from datetime import datetime +from uuid import UUID + from pydantic import Field from app.schemas.base import Base, BaseCreate, BasePage diff --git a/app/schemas/message.py b/app/schemas/message.py index 5c64c406..f4ef2add 100644 --- a/app/schemas/message.py +++ b/app/schemas/message.py @@ -1,5 +1,6 @@ from datetime import datetime from uuid import UUID + from pydantic import Field from app.schemas.base import Base, BaseCreate, BasePage diff --git a/app/schemas/user.py b/app/schemas/user.py index 94e94a9b..0b9b3e87 100644 --- a/app/schemas/user.py +++ b/app/schemas/user.py @@ -4,6 +4,9 @@ from pydantic import Field from app.schemas.base import Base, BaseCreate +PASSWORD_MIN_LENGTH = 12 +PASSWORD_MAX_LENGTH = 128 + class User(Base): """Публичное представление пользователя. Пароль/хеш сюда не попадают никогда.""" @@ -16,5 +19,6 @@ class User(Base): class CreateUser(BaseCreate): username: str = Field(pattern=r"^[a-z0-9_]{3,32}$") display_name: str = Field(min_length=1, max_length=100) - # 12-128 Unicode code points (pydantic считает именно code points). - password: str = Field(min_length=12, max_length=128, repr=False) + password: str = Field( + min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH, repr=False + ) diff --git a/app/storage/__init__.py b/app/storage/__init__.py index 3401a6e1..c881665f 100644 --- a/app/storage/__init__.py +++ b/app/storage/__init__.py @@ -1,10 +1 @@ -"""Слой доступа к данным (CRUD) — по файлу на сущность. - -Правила слоя: - * функции это `async def`, первым аргументом принимают AsyncSession; каждый запрос — через `await session.execute(...)`; - * возвращают ORM-объекты (или None), но НЕ HTTP-ошибки: решать, что значит - «не найдено» (404) или «занято» (409), — задача domain; - * НЕ вызывают await session.commit()/rollback(): границу транзакции задаёт domain; - максимум — await session.flush(), чтобы получить ошибки ограничений сразу; - * только параметризованные запросы через ORM / sqlalchemy.select (никакого f-string SQL). -""" +"""Доступ к данным PostgreSQL и Redis.""" diff --git a/app/storage/chats.py b/app/storage/chats.py index 2823c745..f88ee0cc 100644 --- a/app/storage/chats.py +++ b/app/storage/chats.py @@ -1,9 +1,11 @@ from collections.abc import Sequence from uuid import UUID +from sqlalchemy import exists, select, tuple_ from sqlalchemy.ext.asyncio import AsyncSession from app.models.chat import Chat +from app.models.chat_member import ChatMember from app.storage.types import Position @@ -13,20 +15,14 @@ async def create_chat( title: str, member_ids: Sequence[UUID], ) -> Chat: - """INSERT chats + INSERT chat_members для каждого участника, затем flush. - - Алгоритм: - 1. chat = Chat(title=title); session.add(chat) - 2. await session.flush() (нужен chat.id) - 3. session.add_all(ChatMember(chat_id=chat.id, user_id=uid) for uid in member_ids) - 4. await session.flush() - 5. await session.refresh(chat, attribute_names=["members"]) - — в async нельзя полагаться на ленивую загрузку chat.members - (MissingGreenlet), поэтому либо refresh, либо relationship(lazy="selectin"). - 6. return chat - Всё в одной транзакции domain: упадёт вставка участника — откатится и чат. - """ - raise NotImplementedError("TODO") + """Добавляет чат вместе с участниками.""" + chat = Chat( + title=title, + members=[ChatMember(user_id=user_id) for user_id in member_ids], + ) + session.add(chat) + await session.flush() + return chat async def get_chat_for_member( @@ -34,16 +30,25 @@ async def get_chat_for_member( chat_id: UUID, user_id: UUID, ) -> Chat | None: - """Чат, только если user_id — его участник; иначе None. + """Возвращает чат, если пользователь в нём состоит, иначе None.""" + stmt = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(Chat.id == chat_id, ChatMember.user_id == user_id) + ) + result = await session.execute(stmt) + chat = result.scalar_one_or_none() + return chat - Алгоритм: - 1. stmt = select(Chat).join(ChatMember, ChatMember.chat_id == Chat.id) - .where(Chat.id == chat_id, ChatMember.user_id == user_id) - .options(selectinload(Chat.members)) - 2. result = await session.execute(stmt); return result.scalar_one_or_none() - Посторонний и несуществующий чат дают одинаковый None (-> 404). - """ - raise NotImplementedError("TODO") + +async def is_chat_member(session: AsyncSession, chat_id: UUID, user_id: UUID) -> bool: + """Возвращает True, если пользователь состоит в чате; одна проверка по PK.""" + stmt = select( + exists().where(ChatMember.chat_id == chat_id, ChatMember.user_id == user_id) + ) + result = await session.execute(stmt) + is_member = bool(result.scalar_one()) + return is_member async def list_chats_for_user( @@ -52,15 +57,15 @@ async def list_chats_for_user( after: Position | None, limit: int, ) -> list[Chat]: - """Чаты пользователя по (created_at, id) по возрастанию, строго после `after`. - - Алгоритм: - 1. stmt = select(Chat).join(ChatMember, ChatMember.chat_id == Chat.id) - .where(ChatMember.user_id == user_id) - 2. если after: stmt = stmt.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after)) - 3. stmt = stmt.order_by(Chat.created_at, Chat.id).limit(limit) - .options(selectinload(Chat.members)) - 4. result = await session.execute(stmt); return list(result.scalars().all()) - Вызывающий передаёт limit + 1, чтобы узнать, есть ли следующая страница. - """ - raise NotImplementedError("TODO") + """Возвращает чаты пользователя по (created_at, id) строго после позиции after.""" + stmt = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(ChatMember.user_id == user_id) + ) + if after is not None: + stmt = stmt.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after)) + stmt = stmt.order_by(Chat.created_at, Chat.id).limit(limit) + result = await session.execute(stmt) + chats = list(result.scalars().all()) + return chats diff --git a/app/storage/messages.py b/app/storage/messages.py index ca590391..19960367 100644 --- a/app/storage/messages.py +++ b/app/storage/messages.py @@ -1,10 +1,15 @@ from uuid import UUID +from sqlalchemy import select, tuple_ +from sqlalchemy.dialects.postgresql import insert from sqlalchemy.ext.asyncio import AsyncSession +from app.models.counter import Counter from app.models.message import Message from app.storage.types import Position +MESSAGES_COUNTER = "messages" + async def create_message( session: AsyncSession, @@ -13,11 +18,11 @@ async def create_message( sender_id: UUID, text: str, ) -> Message: - """INSERT сообщения и flush; id и created_at назначает сервер, не клиент. - - Алгоритм: message = Message(...); session.add(message); await session.flush(); return message. - """ - raise NotImplementedError("TODO") + """Добавляет сообщение; id и created_at назначает сервер.""" + message = Message(chat_id=chat_id, sender_id=sender_id, text=text) + session.add(message) + await session.flush() + return message async def list_messages( @@ -26,24 +31,28 @@ async def list_messages( after: Position | None, limit: int, ) -> list[Message]: - """Сообщения чата по (created_at, id) по возрастанию, строго после `after`. - - Алгоритм: - 1. stmt = select(Message).where(Message.chat_id == chat_id) - 2. если after: stmt = stmt.where(tuple_(Message.created_at, Message.id) > tuple_(*after)) - 3. stmt = stmt.order_by(Message.created_at, Message.id).limit(limit) - 4. result = await session.execute(stmt); return list(result.scalars().all()) - Keyset под индекс (chat_id, created_at, id), без OFFSET. Вызывающий передаёт limit + 1. - """ - raise NotImplementedError("TODO") + """Возвращает сообщения чата по (created_at, id) строго после позиции after.""" + stmt = select(Message).where(Message.chat_id == chat_id) + if after is not None: + stmt = stmt.where(tuple_(Message.created_at, Message.id) > tuple_(*after)) + stmt = stmt.order_by(Message.created_at, Message.id).limit(limit) + result = await session.execute(stmt) + messages = list(result.scalars().all()) + return messages -async def count_messages(session: AsyncSession) -> int: - """Общее число сообщений — для лимита MAX_MESSAGES (503). - - Алгоритм (простой): result = await session.execute(select(func.count()).select_from(Message)); - return result.scalar_one(). - count(*) — O(n) на каждую отправку. Альтернативы: оценка из pg_class.reltuples - или таблица-счётчик в той же транзакции. Выберите и обоснуйте в отчёте. - """ - raise NotImplementedError("TODO") +async def reserve_message_slot(session: AsyncSession, max_messages: int) -> bool: + """Атомарно увеличивает счётчик сообщений, если лимит не исчерпан.""" + stmt = ( + insert(Counter) + .values(name=MESSAGES_COUNTER, value=1) + .on_conflict_do_update( + index_elements=[Counter.name], + set_={"value": Counter.value + 1}, + where=Counter.value < max_messages, + ) + .returning(Counter.value) + ) + result = await session.execute(stmt) + is_reserved = result.scalar_one_or_none() is not None + return is_reserved diff --git a/app/storage/sessions.py b/app/storage/sessions.py index f5444585..d8a30f29 100644 --- a/app/storage/sessions.py +++ b/app/storage/sessions.py @@ -7,6 +7,7 @@ SESSION_KEY_PREFIX = "session:" def session_key(token_hash: str) -> str: + """Возвращает ключ Redis для хеша токена.""" return f"{SESSION_KEY_PREFIX}{token_hash}" @@ -17,19 +18,21 @@ async def create_session( user_id: UUID, expires_at: datetime, ) -> None: - """Сохраняет сессию под хешем токена с абсолютным временем истечения.""" - raise NotImplementedError + """Добавляет сессию с абсолютным временем истечения.""" + await redis.set(session_key(token_hash), str(user_id), pxat=expires_at) -async def get_session_user_id( - redis: Redis, - token_hash: str, - now: datetime, -) -> UUID | None: - """ID владельца действующей сессии; None для неизвестной или истёкшей.""" - raise NotImplementedError +async def get_session_user_id(redis: Redis, token_hash: str) -> UUID | None: + """Возвращает id владельца действующей сессии или None.""" + raw_user_id = await redis.get(session_key(token_hash)) + if isinstance(raw_user_id, bytes): + raw_user_id = raw_user_id.decode() + user_id = UUID(raw_user_id) if raw_user_id else None + return user_id async def delete_session(redis: Redis, token_hash: str) -> bool: - """Удаляет сессию; True, если она существовала.""" - raise NotImplementedError + """Удаляет сессию; возвращает True, если она существовала.""" + deleted_count = await redis.delete(session_key(token_hash)) + is_deleted = deleted_count > 0 + return is_deleted diff --git a/app/storage/users.py b/app/storage/users.py index 9be8aaf3..45214e9b 100644 --- a/app/storage/users.py +++ b/app/storage/users.py @@ -1,6 +1,7 @@ from collections.abc import Collection from uuid import UUID +from sqlalchemy import select from sqlalchemy.ext.asyncio import AsyncSession from app.models.user import User @@ -13,42 +14,34 @@ async def create_user( display_name: str, password_hash: str, ) -> User: - """INSERT пользователя и flush. - - Алгоритм: - 1. user = User(username=..., display_name=..., password_hash=...) - 2. session.add(user) (синхронный вызов, без await) - 3. await session.flush() (здесь INSERT уходит в БД, user.id и created_at заполнены) - 4. return user - Нарушение UNIQUE(username) поднимется на flush как IntegrityError — - его перехватывает domain.users.register_user и превращает в 409. - commit здесь НЕ вызывается. - """ - raise NotImplementedError("TODO") + """Добавляет пользователя; занятый username даёт IntegrityError при flush.""" + user = User( + username=username, display_name=display_name, password_hash=password_hash + ) + session.add(user) + await session.flush() + return user async def get_user_by_id(session: AsyncSession, user_id: UUID) -> User | None: - """Алгоритм: return await session.get(User, user_id).""" - raise NotImplementedError("TODO") + """Возвращает пользователя по id или None.""" + user = await session.get(User, user_id) + return user async def get_user_by_username(session: AsyncSession, username: str) -> User | None: - """Алгоритм: - 1. stmt = select(User).where(User.username == username) - 2. result = await session.execute(stmt) - 3. return result.scalar_one_or_none() - """ - raise NotImplementedError("TODO") + """Возвращает пользователя по username или None.""" + stmt = select(User).where(User.username == username) + result = await session.execute(stmt) + user = result.scalar_one_or_none() + return user async def get_existing_user_ids( session: AsyncSession, user_ids: Collection[UUID] ) -> set[UUID]: - """Какие из user_ids существуют — ОДНИМ запросом. - - Алгоритм: - 1. stmt = select(User.id).where(User.id.in_(user_ids)) - 2. result = await session.execute(stmt) - 3. return set(result.scalars().all()) - """ - raise NotImplementedError("TODO") + """Возвращает те из user_ids, что существуют, одним запросом.""" + stmt = select(User.id).where(User.id.in_(user_ids)) + result = await session.execute(stmt) + existing_ids = set(result.scalars().all()) + return existing_ids diff --git a/migrations/versions/db06fd3126ff_create_initial_schema.py b/migrations/versions/db06fd3126ff_create_initial_schema.py new file mode 100644 index 00000000..eec6e51b --- /dev/null +++ b/migrations/versions/db06fd3126ff_create_initial_schema.py @@ -0,0 +1,107 @@ +"""create initial schema + +Revision ID: db06fd3126ff +Revises: +Create Date: 2026-10-26 17:09:16.675339 + +""" + +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + +revision: str = "db06fd3126ff" +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table( + "chats", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("title", sa.String(length=100), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("now()"), + nullable=False, + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_chats")), + ) + op.create_table( + "users", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("username", sa.String(length=32), nullable=False), + sa.Column("display_name", sa.String(length=100), nullable=False), + sa.Column("password_hash", sa.String(length=255), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("now()"), + nullable=False, + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_users")), + sa.UniqueConstraint("username", name=op.f("uq_users_username")), + ) + op.create_table( + "chat_members", + sa.Column("chat_id", sa.UUID(), nullable=False), + sa.Column("user_id", sa.UUID(), nullable=False), + sa.ForeignKeyConstraint( + ["chat_id"], + ["chats.id"], + name=op.f("fk_chat_members_chat_id_chats"), + ondelete="CASCADE", + ), + sa.ForeignKeyConstraint( + ["user_id"], ["users.id"], name=op.f("fk_chat_members_user_id_users") + ), + sa.PrimaryKeyConstraint("chat_id", "user_id", name=op.f("pk_chat_members")), + ) + op.create_index( + "ix_chat_members_user_id_chat_id", + "chat_members", + ["user_id", "chat_id"], + unique=False, + ) + op.create_table( + "messages", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("chat_id", sa.UUID(), nullable=False), + sa.Column("sender_id", sa.UUID(), nullable=False), + sa.Column("text", sa.Text(), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("clock_timestamp()"), + nullable=False, + ), + sa.ForeignKeyConstraint( + ["chat_id"], ["chats.id"], name=op.f("fk_messages_chat_id_chats") + ), + sa.ForeignKeyConstraint( + ["sender_id"], ["users.id"], name=op.f("fk_messages_sender_id_users") + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_messages")), + ) + op.create_index( + "ix_messages_chat_id_created_at_id", + "messages", + ["chat_id", "created_at", "id"], + unique=False, + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index("ix_messages_chat_id_created_at_id", table_name="messages") + op.drop_table("messages") + op.drop_index("ix_chat_members_user_id_chat_id", table_name="chat_members") + op.drop_table("chat_members") + op.drop_table("users") + op.drop_table("chats") + # ### end Alembic commands ###