pip install "sqlalchemy[asyncio]" asyncpg

# app/core/database.py — moteur et session asynchrones
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from sqlalchemy.orm import DeclarativeBase

DATABASE_URL = "postgresql+asyncpg://user:password@localhost:5432/mydb"

engine = create_async_engine(
    DATABASE_URL,
    pool_size=10,
    max_overflow=20,
    pool_pre_ping=True,
)

AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)


class Base(DeclarativeBase):
    pass


async def get_db():
    async with AsyncSessionLocal() as session:
        yield session

# Requêtes async — await sur chaque appel réseau vers la DB
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from typing import Annotated
from fastapi import Depends, APIRouter, HTTPException

router = APIRouter(prefix="/products", tags=["products"])


@router.get("/{product_id}")
async def get_product(product_id: int, db: Annotated[AsyncSession, Depends(get_db)]):
    product = await db.get(Product, product_id)
    if not product:
        raise HTTPException(status_code=404, detail="Produit introuvable")
    return product


@router.get("")
async def list_products(db: Annotated[AsyncSession, Depends(get_db)], min_price: float = 0):
    stmt = select(Product).where(Product.price >= min_price)
    result = await db.execute(stmt)
    return result.scalars().all()

# Création avec commit asynchrone
@router.post("")
async def create_product(data: ProductCreate, db: Annotated[AsyncSession, Depends(get_db)]):
    product = Product(**data.model_dump())
    db.add(product)
    await db.commit()
    await db.refresh(product)
    return product

# Eager loading en async — selectinload évite le lazy loading implicite (qui échoue en async)
from sqlalchemy.orm import selectinload

@router.get("/{product_id}/with-reviews")
async def get_product_with_reviews(product_id: int, db: Annotated[AsyncSession, Depends(get_db)]):
    stmt = select(Product).where(Product.id == product_id).options(selectinload(Product.reviews))
    result = await db.execute(stmt)
    product = result.scalar_one_or_none()
    if not product:
        raise HTTPException(status_code=404, detail="Introuvable")
    # product.reviews est déjà chargé : accéder à une relation NON préchargée lèverait une erreur
    # (le lazy loading synchrone implicite n'existe pas dans un contexte async)
    return product

# Transaction explicite regroupant plusieurs opérations
async def transfer_stock(db: AsyncSession, from_id: int, to_id: int, quantity: int):
    async with db.begin():  # commit automatique en sortie, rollback si exception
        source = await db.get(Product, from_id, with_for_update=True)
        target = await db.get(Product, to_id, with_for_update=True)

        if source.stock < quantity:
            raise ValueError("Stock insuffisant")

        source.stock -= quantity
        target.stock += quantity

# Pièges courants : NE PAS mélanger sync et async au hasard
# MAUVAIS : appeler du code sync bloquant dans une route async (bloque l'event loop)
@router.get("/bad-example")
async def bad_example():
    import time
    time.sleep(2)  # bloque TOUT le serveur pendant 2 secondes, pas seulement cette requête
    return {}

# BON : si du code bloquant est inévitable, le déporter dans un threadpool
from fastapi.concurrency import run_in_threadpool

@router.get("/good-example")
async def good_example():
    result = await run_in_threadpool(blocking_legacy_function)
    return result

def blocking_legacy_function():
    import time
    time.sleep(2)
    return {"ok": True}