"""Зависимости ручек: сессия БД, сервисы, вход и текущая сессия, страница. Сервисы получают сессию БД, а чаты и сообщения — ещё и кэш процесса (`src/infra/cache/instance.py`). Вложения — фабрику короткой сессии на шаг, кэш, хранилище объектов (`src/infra/s3/instance.py`) и места загрузок процесса (`src/infra/upload_slots.py`). """ import base64 import binascii import re from collections.abc import AsyncIterator from contextlib import AbstractAsyncContextManager from dataclasses import dataclass from typing import Annotated from fastapi import Depends, Query, Security from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer from fastapi.security.http import HTTPBase from sqlalchemy.ext.asyncio import AsyncSession from src.config import settings from src.core import exceptions from src.core.services import ( AttachmentService, ChatService, MessageService, SessionService, UserService, ) from src.infra.cache.instance import cache from src.infra.db import ping from src.infra.db.scope import session_scope from src.infra.db.session import engine, session_factory from src.infra.logger import current_user_id from src.infra.s3.instance import object_storage from src.infra.upload_slots import upload_slots from src.schemas import dataclasses from src.utils.constants import ( PAGE_LIMIT_DEFAULT, PAGE_LIMIT_MAX, PAGE_LIMIT_MIN, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, READINESS_DB_TIMEOUT_SECONDS, USERNAME_PATTERN, ) def db_session_scope() -> AbstractAsyncContextManager[AsyncSession]: """Сессия БД процесса API на один шаг; commit делает сервис. `session_scope` (`src/infra/db/scope.py`) с фабрикой процесса API и сроком `[database] request_timeout_seconds`: незакоммиченное откатывается, отказ БД — 503 `unavailable`. """ return session_scope( session_factory, timeout_seconds=settings.database.request_timeout_seconds, ) async def get_db_session() -> AsyncIterator[AsyncSession]: """Одна сессия БД на запрос — `db_session_scope` на весь запрос. Зависимость с `yield` FastAPI закрывает после отправки ответа, поэтому срок и соединение пула охватывают и отдачу тела. Ручкам с длинной передачей (вложения) она не подходит: им — `CurrentUserBrief` и сервис с `db_session_scope` на шаг (design change `attachments`, решение 5). """ async with db_session_scope() as db_session: yield db_session DbSessionDep = Annotated[AsyncSession, Depends(get_db_session)] async def require_database() -> None: """Readiness: Postgres отвечает на `SELECT 1` за отведённое время. Любая ошибка — 503: готовность не должна отвечать 500. Не логирует: healthcheck спрашивает каждые несколько секунд. """ try: await ping(engine, timeout=READINESS_DB_TIMEOUT_SECONDS) except Exception as e: raise exceptions.ServiceUnavailable from e async def get_user_service(db_session: DbSessionDep) -> UserService: return UserService(db_session=db_session) async def get_chat_service(db_session: DbSessionDep) -> ChatService: return ChatService(db_session=db_session, cache=cache) async def get_message_service(db_session: DbSessionDep) -> MessageService: return MessageService(db_session=db_session, cache=cache) async def get_session_service(db_session: DbSessionDep) -> SessionService: return SessionService(db_session=db_session) async def get_attachment_service() -> AttachmentService: """Без сессии запроса: сервис открывает `db_session_scope` на шаг.""" return AttachmentService( db_scope=db_session_scope, cache=cache, storage=object_storage, slots=upload_slots, ) UserServiceDep = Annotated[UserService, Depends(get_user_service)] ChatServiceDep = Annotated[ChatService, Depends(get_chat_service)] MessageServiceDep = Annotated[MessageService, Depends(get_message_service)] SessionServiceDep = Annotated[SessionService, Depends(get_session_service)] AttachmentServiceDep = Annotated[ AttachmentService, Depends(get_attachment_service), ] # схемы basicAuth и bearerAuth из contracts/openapi.json: объявлены в # /openapi.json и дают кнопку Authorize в /docs. auto_error=False — нет # заголовка или схема чужая даёт None, а 401 в формате контракта бросает # сервис. HTTPBase отдаёт credentials как есть: HTTPBasic FastAPI # декодирует ASCII и на пароле не из ASCII сам ответил бы 401 basic_scheme = HTTPBase( scheme="basic", scheme_name="basicAuth", auto_error=False, ) bearer_scheme = HTTPBearer( scheme_name="bearerAuth", bearerFormat="opaque session token", auto_error=False, ) @dataclass(frozen=True, slots=True) class BasicCredentials: username: str password: str def parse_basic( credentials: HTTPAuthorizationCredentials | None, ) -> BasicCredentials | None: """username и пароль из `Authorization: Basic`; None — разбор не удался. base64 строго, UTF-8, разделитель — первое двоеточие: в username его не бывает, в пароле оно допустимо. Значения, которые не могут быть верными (формат username и длина пароля публичны), отсекаются здесь: до БД и KDF не доходит ни мусор, ни пароль в мегабайт. """ if credentials is None or credentials.scheme.lower() != "basic": return None try: decoded = base64.b64decode(credentials.credentials, validate=True) username, separator, password = decoded.decode().partition(":") except (binascii.Error, UnicodeDecodeError): return None if not separator or not re.fullmatch(USERNAME_PATTERN, username): return None if not PASSWORD_MIN_LENGTH <= len(password) <= PASSWORD_MAX_LENGTH: return None return BasicCredentials(username=username, password=password) async def get_basic_credentials( credentials: Annotated[ HTTPAuthorizationCredentials | None, Security(basic_scheme), ], ) -> BasicCredentials: """Учётные данные входа; любой сбой разбора — тот же 401, что и неверный пароль.""" parsed = parse_basic(credentials) if parsed is None: raise exceptions.InvalidCredentials return parsed BasicCredentialsDep = Annotated[ BasicCredentials, Depends(get_basic_credentials), ] async def get_current_session( credentials: Annotated[ HTTPAuthorizationCredentials | None, Security(bearer_scheme), ], sessions: SessionServiceDep, ) -> dataclasses.CurrentSessionDTO: """Действующая сессия по Bearer-токену; иначе 401.""" current = await sessions.authenticate( token=credentials.credentials if credentials else None, ) current_user_id.set(str(current.user.id)) return current CurrentSession = Annotated[ dataclasses.CurrentSessionDTO, Depends(get_current_session), ] async def get_current_user( current: CurrentSession, ) -> dataclasses.UserFullDTO: return current.user CurrentUser = Annotated[dataclasses.UserFullDTO, Depends(get_current_user)] async def get_current_user_brief( credentials: Annotated[ HTTPAuthorizationCredentials | None, Security(bearer_scheme), ], ) -> dataclasses.UserFullDTO: """Пользователь по Bearer-токену с короткой сессией БД; иначе 401. Обычная функция, а не генератор: сессия закрыта и соединение вернулось в пул до тела запроса. Для ручек с длинной передачей байтов (design change `attachments`, решение 5). """ async with db_session_scope() as db_session: current = await SessionService(db_session=db_session).authenticate( token=credentials.credentials if credentials else None, ) current_user_id.set(str(current.user.id)) return current.user CurrentUserBrief = Annotated[ dataclasses.UserFullDTO, Depends(get_current_user_brief), ] @dataclass(frozen=True, slots=True) class PageQuery: limit: int cursor: str | None async def get_page_query( limit: Annotated[ int, Query(ge=PAGE_LIMIT_MIN, le=PAGE_LIMIT_MAX), ] = PAGE_LIMIT_DEFAULT, cursor: Annotated[str | None, Query(min_length=1)] = None, ) -> PageQuery: return PageQuery(limit=limit, cursor=cursor) PageQueryDep = Annotated[PageQuery, Depends(get_page_query)]