feat: реализовать регистрацию, вход и refresh для пользователей

Что сделано:
- добавлены модель пользователя, схемы и репозиторий
- реализована бизнес-логика аутентификации и проверки активного пользователя
- подключены JWT, хеширование паролей и защита refresh-потока
- добавлены роуты auth и лимитирование для чувствительных операций

Author: RomanVetrov

app/limits/__init__.py

@@ -0,0 +1,26 @@
+from collections.abc import Callable
+
+from fastapi import Depends, Request
+from redis.asyncio import Redis
+
+from app.limits.service import enforce_rate_limit
+from app.redis import get_redis
+
+
+def rate_limit_by_ip(limit: int, window_seconds: int, scope: str) -> Callable:
+    """Фабрика зависимости: ограничивает запросы по IP для заданного scope."""
+
+    async def dependency(
+        request: Request,
+        redis: Redis = Depends(get_redis),
+    ) -> None:
+        client_ip = request.client.host if request.client else "unknown"
+        key = f"rl:{scope}:ip:{client_ip}"
+        await enforce_rate_limit(
+            redis,
+            key=key,
+            limit=limit,
+            window_seconds=window_seconds,
+        )
+
+    return dependency

app/limits/dependencies.py

@@ -0,0 +1,39 @@
+from typing import Awaitable, cast
+
+from fastapi import HTTPException, status
+from redis.asyncio import Redis
+
+# Атомарный инкремент с установкой TTL через Lua.
+# INCR и EXPIRE как два отдельных вызова не атомарны:
+# если процесс упадёт между ними - ключ останется без TTL навсегда.
+# защита от брутфорса на 2 линии обороны в time_cost=3 у argon2
+_RATE_LIMIT_SCRIPT = """
+local current = redis.call('INCR', KEYS[1])
+if current == 1 then
+    redis.call('EXPIRE', KEYS[1], ARGV[1])
+end
+return current
+"""
+
+
+async def enforce_rate_limit(
+    redis: Redis,
+    *,
+    key: str,
+    limit: int,
+    window_seconds: int,
+) -> None:
+    """Проверяет лимит запросов для ключа. Поднимает 429 с Retry-After при превышении."""
+    current = int(
+        await cast(
+            Awaitable[int], redis.eval(_RATE_LIMIT_SCRIPT, 1, key, window_seconds)
+        )
+    )
+
+    if current > limit:
+        retry_after = await redis.ttl(key)
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=f"Слишком много запросов. Повторите через {retry_after} сек.",
+            headers={"Retry-After": str(max(retry_after, 1))},
+        )

app/limits/service.py

@@ -0,0 +1,24 @@
+from datetime import datetime
+
+from sqlalchemy import DateTime, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+
+UTC_NOW = text("timezone('utc', now())")  # всегда UTC на стороне БД
+
+
+class CreatedAtMixin:
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=UTC_NOW,
+        nullable=False,
+    )
+
+
+class TimestampMixin(CreatedAtMixin):
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=UTC_NOW,
+        server_onupdate=UTC_NOW,
+        nullable=False,
+    )

app/models/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import uuid
+
+from sqlalchemy import Boolean, String, text
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.database import Base
+from app.models.mixins import TimestampMixin
+
+
+class User(TimestampMixin, Base):
+    __tablename__ = "users"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    email: Mapped[str] = mapped_column(
+        String(254), unique=True, nullable=False, index=True
+    )
+    hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean(), server_default=text("true"))

app/models/mixins.py

@@ -0,0 +1,33 @@
+"""Репозиторий для работы с пользователями."""
+
+from __future__ import annotations
+
+import uuid
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.user import User
+
+
+async def get_user_by_id(session: AsyncSession, user_id: uuid.UUID) -> User | None:
+    """Возвращает пользователя по id или None."""
+    return await session.get(User, user_id)
+
+
+async def get_user_by_email(session: AsyncSession, email: str) -> User | None:
+    """Возвращает пользователя по email или None."""
+    stmt = select(User).where(User.email == email)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def create_user(
+    session: AsyncSession, *, email: str, hashed_password: str
+) -> User:
+    """Создаёт и сохраняет нового пользователя, возвращает его с заполненным id."""
+    new_user = User(email=email, hashed_password=hashed_password)
+    session.add(new_user)
+    await session.commit()
+    await session.refresh(new_user)
+    return new_user

app/models/user.py

@@ -0,0 +1,188 @@
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from fastapi.security import OAuth2PasswordRequestForm
+from redis.asyncio import Redis
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database import get_db
+from app.limits.dependencies import rate_limit_by_ip
+from app.models.user import User
+from app.redis import get_redis
+from app.schemas.auth import RefreshTokenRequest, RegisterCreate, TokenPair, UserRead
+from app.security.dependences import get_current_user
+from app.security.jwt import (
+    TokenExpired,
+    TokenInvalid,
+    create_access_token,
+    create_refresh_token,
+    decode_refresh_token,
+)
+from app.security.refresh_guard import require_active_refresh_user
+from app.services.auth import (
+    UserAlreadyExists,
+    UserInactive,
+    authenticate_active_user,
+    register_user,
+)
+
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+
+def _refresh_ttl_seconds() -> int:
+    """TTL refresh-токена в секундах из настроек (неделя)"""
+    return settings.REFRESH_TOKEN_EXPIRE_DAYS * 24 * 60 * 60
+
+
+def _refresh_key(user_id: UUID, jti: str) -> str:
+    """Ключ для хранения refresh-токена в Redis: rt:{user_id}:{jti}."""
+    return f"rt:{user_id}:{jti}"
+
+
+def _parse_refresh_token_or_401(refresh_token: str) -> tuple[UUID, str]:
+    """Декодирует refresh-токен и возвращает (user_id, jti). Поднимает 401 при ошибке."""
+    try:
+        token_data = decode_refresh_token(refresh_token)
+    except (TokenExpired, TokenInvalid):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Недействительный или истёкший refresh токен",
+        )
+
+    try:
+        user_id = UUID(token_data.sub)
+    except (ValueError, TypeError):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Некорректный идентификатор пользователя в refresh токене",
+        )
+
+    jti = str(token_data.payload["jti"])
+    return user_id, jti
+
+
+async def _issue_token_pair(user_id: UUID, redis: Redis) -> TokenPair:
+    """Создаёт новую пару токенов и сохраняет jti refresh-токена в Redis."""
+    access_token = create_access_token(subject=str(user_id))
+    refresh_token, jti = create_refresh_token(subject=str(user_id))
+
+    await redis.set(
+        _refresh_key(user_id, jti),
+        str(user_id),
+        ex=_refresh_ttl_seconds(),
+    )
+
+    return TokenPair(
+        access_token=access_token,
+        refresh_token=refresh_token,
+        token_type="bearer",
+    )
+
+
+@router.post(
+    "/register",
+    response_model=UserRead,
+    status_code=status.HTTP_201_CREATED,
+    summary="Регистрация пользователя",
+    dependencies=[
+        Depends(rate_limit_by_ip(limit=5, window_seconds=60, scope="auth_register"))
+    ],
+)
+async def create_user(
+    payload: RegisterCreate,
+    session: AsyncSession = Depends(get_db),
+) -> UserRead:
+    try:
+        new_user = await register_user(session, payload.email, payload.password)
+    except UserAlreadyExists:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Пользователь с таким Email уже зарегистрирован",
+        )
+    return UserRead.model_validate(new_user)
+
+
+@router.post(
+    "/login",
+    response_model=TokenPair,
+    summary="Вход в систему",
+    dependencies=[
+        Depends(rate_limit_by_ip(limit=10, window_seconds=60, scope="auth_login"))
+    ],
+)
+async def login_user(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    session: AsyncSession = Depends(get_db),
+    redis: Redis = Depends(get_redis),
+) -> TokenPair:
+    try:
+        user = await authenticate_active_user(
+            session,
+            form_data.username,
+            form_data.password,
+        )
+    except UserInactive:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Аккаунт заблокирован",
+        )
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Неверный логин или пароль",
+            headers={"WWW-Authenticate": "bearer"},
+        )
+
+    return await _issue_token_pair(user.id, redis)
+
+
+@router.post(
+    "/refresh",
+    response_model=TokenPair,
+    summary="Обновить access/refresh токены",
+    dependencies=[
+        Depends(rate_limit_by_ip(limit=10, window_seconds=60, scope="auth_refresh"))
+    ],
+)
+async def refresh_token_pair(
+    payload: RefreshTokenRequest,
+    session: AsyncSession = Depends(get_db),
+    redis: Redis = Depends(get_redis),
+) -> TokenPair:
+    user_id, jti = _parse_refresh_token_or_401(payload.refresh_token)
+
+    await require_active_refresh_user(session, user_id)
+
+    deleted = await redis.delete(_refresh_key(user_id, jti))
+    if deleted != 1:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Refresh токен отозван или уже использован",
+        )
+
+    return await _issue_token_pair(user_id, redis)
+
+
+@router.post(
+    "/logout",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Выход из системы",
+)
+async def logout_user(
+    payload: RefreshTokenRequest,
+    session: AsyncSession = Depends(get_db),
+    redis: Redis = Depends(get_redis),
+) -> Response:
+    user_id, jti = _parse_refresh_token_or_401(payload.refresh_token)
+
+    await require_active_refresh_user(session, user_id)
+
+    await redis.delete(_refresh_key(user_id, jti))
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.get("/me", response_model=UserRead, summary="Получить текущего пользователя")
+async def current_user(current_user: User = Depends(get_current_user)) -> UserRead:
+    return UserRead.model_validate(current_user)