forked from mtusi2026/mtusi2026lab2
add migrations, create domain and crud layers
This commit is contained in:
+2
-1
@@ -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/
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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)
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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),
|
||||
}
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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)
|
||||
@@ -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
@@ -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,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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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 ###
|
||||
Reference in New Issue
Block a user