feat: собрать базовый каркас FastAPI приложения

Что сделано:
- настроены конфигурация приложения, база данных и Redis-клиент
- добавлен bootstrap FastAPI и жизненный цикл приложения
- подключен health-роут для проверки состояния API

Author: RomanVetrov

app/__init__.py

@@ -0,0 +1,26 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    DATABASE_URL: str
+    SECRET_KEY: str
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 10
+    REFRESH_TOKEN_EXPIRE_DAYS: int = 7
+    REDIS_URL: str = "redis://localhost:6379/0"
+    # Argon2 tuning (can be overridden via .env)
+    ARGON_TIME_COST: int = 3
+    ARGON_MEMORY_COST: int = 65536  # KiB (≈64 MiB)
+    ARGON_PARALLELISM: int = 2
+    ARGON_HASH_LEN: int = 32
+    ARGON_SALT_LEN: int = 16
+    ARGON_MAX_PASSWORD_LEN: int = 1024  # basic DoS guard
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+settings = Settings()

app/config.py

@@ -0,0 +1,25 @@
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from app.config import settings
+
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=False,
+)
+
+AsyncSessionLocal = async_sessionmaker(
+    engine,
+    expire_on_commit=False,
+)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+async def get_db() -> AsyncGenerator[AsyncSession]:
+    async with AsyncSessionLocal() as session:
+        yield session

app/database.py

@@ -0,0 +1,23 @@
+import logging
+
+import structlog
+
+
+def setup_logging() -> None:
+    """Настраивает structlog для всего приложения. Вызывается один раз при старте."""
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(message)s",
+    )
+
+    structlog.configure(
+        processors=[
+            structlog.stdlib.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+    )

app/logging_config.py

@@ -0,0 +1,44 @@
+from contextlib import asynccontextmanager
+from typing import Awaitable, cast
+
+from fastapi import FastAPI
+
+from app.logging_config import setup_logging
+from app.middleware import LoggingMiddleware, MetricsMiddleware, RequestIDMiddleware
+from app.redis import redis_client
+from app.routes.auth import router as auth_router
+from app.routes.health import router as health_router
+from app.routes.metrics import router as metrics_router
+from app.routes.tags import router as tags_router
+from app.routes.tasks import router as tasks_router
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await cast(Awaitable[bool], redis_client.ping())
+    try:
+        yield
+    finally:
+        await redis_client.aclose()
+
+
+setup_logging()
+
+app = FastAPI(
+    title="Task Manager API",
+    description="API для управления задачами с авторизацией",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+# middleware регистрируются в обратном порядке (луковица).
+# RequestID должен сработать первым, поэтому добавляем его последним.
+app.add_middleware(MetricsMiddleware)
+app.add_middleware(LoggingMiddleware)
+app.add_middleware(RequestIDMiddleware)
+
+app.include_router(metrics_router)
+app.include_router(auth_router, prefix="/api/v1")
+app.include_router(health_router, prefix="/api/v1")
+app.include_router(tasks_router, prefix="/api/v1")
+app.include_router(tags_router, prefix="/api/v1")

app/main.py

@@ -0,0 +1,13 @@
+from redis.asyncio import Redis
+
+from app.config import settings
+
+redis_client = Redis.from_url(
+    settings.REDIS_URL,
+    encoding="utf-8",
+    decode_responses=True,
+)
+
+
+async def get_redis() -> Redis:
+    return redis_client

app/redis.py

@@ -0,0 +1,23 @@
+from typing import Awaitable, cast
+
+from fastapi import APIRouter, Depends
+from redis.asyncio import Redis
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.redis import get_redis
+
+router = APIRouter(prefix="/health", tags=["health"])
+
+
+@router.get("/redis")
+async def redis_health(redis: Redis = Depends(get_redis)) -> dict[str, str]:
+    ok = await cast(Awaitable[bool], redis.ping())
+    return {"redis": "ok" if ok else "down"}
+
+
+@router.get("/db")
+async def db_health(session: AsyncSession = Depends(get_db)) -> dict[str, str]:
+    await session.execute(text("SELECT 1"))
+    return {"db": "ok"}