Cheatsheet: FastAPI — Decoradores, dependencias y tips

FastAPI — Referencia Rápida

Los patrones más usados de FastAPI en un solo lugar. Todos los ejemplos son production-ready.

Path parameters y validación

from fastapi import FastAPI, Path, Query, HTTPException
from pydantic import BaseModel, Field
from enum import Enum

app = FastAPI(title="Mi API", version="1.0.0")

class SortOrder(str, Enum):
    asc = "asc"
    desc = "desc"

@app.get("/items/{item_id}")
async def get_item(
    item_id: int = Path(gt=0, description="ID del item"),
    q: str | None = Query(None, min_length=3, max_length=50),
    skip: int = Query(0, ge=0),
    limit: int = Query(20, le=100),
    sort: SortOrder = Query(SortOrder.desc),
):
    return {"item_id": item_id, "q": q}

Request/Response models con Pydantic

from datetime import datetime

class ItemCreate(BaseModel):
    name: str = Field(min_length=1, max_length=100)
    price: float = Field(gt=0, description="Precio en USD")
    tags: list[str] = Field(default_factory=list, max_length=10)

    model_config = {"json_schema_extra": {
        "examples": [{"name": "Widget", "price": 9.99, "tags": ["nuevo"]}]
    }}

class ItemResponse(ItemCreate):
    id: int
    created_at: datetime

@app.post("/items", response_model=ItemResponse, status_code=201)
async def create_item(item: ItemCreate):
    ...

Dependency Injection

from fastapi import Depends, Header
from typing import Annotated

async def get_current_user(authorization: str = Header()) -> User:
    token = authorization.replace("Bearer ", "")
    user = await verify_token(token)
    if not user:
        raise HTTPException(401, "Token inválido")
    return user

CurrentUser = Annotated[User, Depends(get_current_user)]

@app.get("/me")
async def get_me(user: CurrentUser):
    return user

# Dependency con yield (cleanup automático)
async def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

DB = Annotated[Session, Depends(get_db)]

@app.get("/users")
async def list_users(db: DB, user: CurrentUser):
    return db.query(User).all()

Background tasks

from fastapi import BackgroundTasks

def send_notification(email: str, message: str):
    # Tarea pesada que no bloquea la response
    ...

@app.post("/orders")
async def create_order(order: OrderCreate, bg: BackgroundTasks):
    result = save_order(order)
    bg.add_task(send_notification, order.email, "Pedido confirmado")
    return result  # Responde inmediatamente

Middleware y CORS

from fastapi.middleware.cors import CORSMiddleware
import time

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://tudominio.com"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.middleware("http")
async def add_timing_header(request, call_next):
    start = time.perf_counter()
    response = await call_next(request)
    response.headers["X-Process-Time"] = f"{time.perf_counter() - start:.3f}s"
    return response

Error handling global

from fastapi.responses import JSONResponse

class AppError(Exception):
    def __init__(self, message: str, status_code: int = 400):
        self.message = message
        self.status_code = status_code

@app.exception_handler(AppError)
async def app_error_handler(request, exc: AppError):
    return JSONResponse(
        status_code=exc.status_code,
        content={"error": exc.message},
    )

@app.exception_handler(Exception)
async def generic_error_handler(request, exc):
    return JSONResponse(status_code=500, content={"error": "Error interno"})