add migrations, create domain and crud layers

This commit is contained in:
2026-10-26 21:59:40 +03:00
parent 76b34fca4b
commit 3082b84f61
27 changed files with 481 additions and 278 deletions
+2 -1
View File
@@ -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
/venv
.ruff_cache/
+9 -2
View File
@@ -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()
+1 -12
View File
@@ -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."""
+50 -4
View File
@@ -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()
+58 -40
View File
@@ -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
+29 -26
View File
@@ -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
+5 -1
View File
@@ -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
+29 -16
View File
@@ -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
+11 -17
View File
@@ -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)
+9 -16
View File
@@ -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)
+16 -5
View File
@@ -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)]
+13 -13
View File
@@ -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)
+4 -8
View File
@@ -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
+2 -1
View File
@@ -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"]
+3 -1
View File
@@ -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),
}
+1 -3
View File
@@ -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")
+13
View File
@@ -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)
+1 -1
View File
@@ -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"]
+2 -1
View File
@@ -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
+1
View File
@@ -1,5 +1,6 @@
from datetime import datetime
from uuid import UUID
from pydantic import Field
from app.schemas.base import Base, BaseCreate, BasePage
+6 -2
View File
@@ -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
)
+1 -10
View File
@@ -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."""
+40 -35
View File
@@ -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
+33 -24
View File
@@ -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
+14 -11
View File
@@ -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
+21 -28
View File
@@ -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
@@ -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 ###