¿Cómo funciona la inyección de dependencias (Depends)?

Question

Accepted Answer

El sistema de **inyección de dependencias** de FastAPI te permite declarar dependencias reutilizables (funciones/clases) que FastAPI llama e **inyecta** en tus operaciones de ruta a través de `Depends()`. Se utiliza para lógica compartida como sesiones de base de datos, autenticación y parámetros comunes — manteniendo el código DRY y comprobable.

## Una dependencia básica

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

Declarar `params = Depends(pagination)` le dice a FastAPI que llame a `pagination` (resolviendo también *sus* parámetros de la solicitud) y pasar el resultado a tu función. La dependencia es reutilizable en muchos endpoints.

## Dependencias con limpieza (yield) — por ejemplo, sesiones de base de datos

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

Una dependencia `yield` proporciona un recurso y ejecuta la limpieza después de la solicitud — el patrón estándar para sesiones de base de datos (abrir antes, cerrar después, automáticamente).

## Las dependencias pueden depender de dependencias

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

Las dependencias forman un árbol — FastAPI resuelve toda la cadena. Así es como se implementa típicamente la autenticación (una dependencia `get_current_user`).

## Dependencias de clase y reutilización

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## Por qué es importante

La inyección de dependencias es una de las características más poderosas e importantes de FastAPI — es cómo compartes y reutilizas lógica de manera limpia en endpoints (sesiones de base de datos, autenticación, parámetros de consulta comunes, verificaciones de permisos) sin duplicación.

Comprenderla es esencial porque respalda patrones principales: la **dependencia `yield`** es la forma estándar de gestionar sesiones de base de datos (con limpieza garantizada después de cada solicitud), y una **dependencia `get_current_user`** es la forma idiomática de implementar autenticación.

DI también hace que el código sea altamente **comprobable** — puedes anular dependencias con mocks en las pruebas.

La elegancia del sistema (las dependencias resuelven sus propios parámetros de la solicitud, pueden depender de otras dependencias formando un árbol e integrarse con la documentación) lo convierte en una herramienta versátil para estructurar aplicaciones reales, por lo que dominar `Depends` es clave para construir aplicaciones FastAPI bien organizadas, mantenibles y comprobables.