Que padrões avançados de dependência o FastAPI suporta?

Question

Accepted Answer

Além do `Depends` básico, a injeção de dependência do FastAPI suporta padrões avançados: **sub-dependências**, **dependências com parâmetros** (baseadas em classe ou via factories), **recursos com escopo** (yield), **dependências globais/de roteador**, e **sobrescrita de dependências** para testes — tornando-o uma ferramenta versátil para estruturar aplicações reais.

## Sub-dependências (árvores de dependência)

```python
def get_token(authorization: str = Header()):
    return parse(authorization)

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

def get_admin(user: User = Depends(get_current_user)):    # depends on that, in turn
    if not user.is_admin: raise HTTPException(403)
    return user
# FastAPI resolves the whole chain, caching shared dependencies within a request
```

Dependências podem depender de outras dependências, formando uma árvore que FastAPI resolve automaticamente (e **cache** as compartilhadas por requisição, então `get_token` executa uma vez mesmo se usada por várias dependências).

## Dependências parametrizadas (baseadas em classe)

```python
class RateLimiter:
    def __init__(self, calls: int):        # configure the dependency
        self.calls = calls
    def __call__(self, request: Request):  # callable → acts as a dependency
        check_rate_limit(request, self.calls)

@app.get("/items", dependencies=[Depends(RateLimiter(calls=100))])  # configured per route
def items(): ...
```

Uma classe com `__call__` é uma dependência **configurável** — você a parametriza no momento do uso (ex: limites de taxa diferentes por rota).

## Dependências como efeitos colaterais (sem necessidade de retorno)

```python
@app.get("/admin", dependencies=[Depends(verify_admin)])   # run for the effect (auth check)
def admin(): ...                                            # don't need its return value
```

## Dependências globais e em nível de roteador

```python
app = FastAPI(dependencies=[Depends(verify_api_key)])      # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)])  # to all routes in a router
```

Aplique dependências em toda a aplicação ou por roteador para requisitos transversais (autenticação, rate limiting).

## Sobrescrita para testes

```python
app.dependency_overrides[get_db] = get_test_db    # swap any dependency in tests
```

## Por que isso importa

A injeção de dependência do FastAPI é uma de suas características mais poderosas, e esses padrões avançados são o que permite estruturar aplicações reais e complexas elegantemente.

Compreendê-los é conhecimento valioso de nível sênior: **sub-dependências** constroem camadas reutilizáveis (token → usuário → admin) com resolução automática e cache por requisição (evitando trabalho redundante); **dependências parametrizadas/baseadas em classe** criam componentes reutilizáveis e configuráveis (limitadores de taxa, verificações de permissão com diferentes configurações por rota); **dependências como efeitos colaterais** aplicam requisitos de forma limpa (autenticação) sem poluir assinaturas de função; e **dependências globais/em nível de roteador** aplicam preocupações transversais (autenticação, rate limiting) a grupos inteiros de rotas em um único lugar.

Crucialmente, **sobrescrita de dependências** torna até mesmo grafos de dependência complexos trivialmente testáveis.

Dominar esses padrões — compor dependências, parametrizá-las, escopo-á-las globalmente ou por roteador, e sobrescrevê-las em testes — é o que permite arquitetura limpa, DRY e testável em aplicações FastAPI não triviais, distinguindo desenvolvedores que conseguem aproveitar totalmente o sistema de DI do framework daqueles que usam apenas `Depends` básico.

É um tópico importante para construir aplicações FastAPI bem estruturadas, mantíveis e em larga escala.