Hoe ga je om met fouten en raise je HTTP-uitzonderingen?

Question

Accepted Answer

FastAPI verwerkt fouten door **exceptions op te werpen** die het omzet in juiste HTTP-responses. `HTTPException` dekt de meeste gevallen af; aangepaste exception handlers geven je controle over foutformattering op globaal niveau.

## HTTPException opwerpen

```python
from fastapi import HTTPException

@app.get("/items/{id}")
def get_item(id: int):
    item = db.get(id)
    if not item:
        raise HTTPException(status_code=404, detail="Item not found")   # → 404 JSON response
    if not item.is_public:
        raise HTTPException(status_code=403, detail="Forbidden")
    return item
```

`raise HTTPException(status_code=..., detail=...)` is de idomatische manier om een fout te retourneren — FastAPI produceert een JSON-response `{"detail": "..."}` met de gegeven status. De `detail` kan elke JSON-serialiseerbare waarde zijn (string, dict, list).

## Validatiefouten zijn automatisch (422)

```text
When request data fails Pydantic validation, FastAPI AUTOMATICALLY returns a 422
with a structured list of exactly which fields are wrong — you write nothing.
```

## Aangepaste exception handlers (globale formattering)

```python
from fastapi import Request
from fastapi.responses import JSONResponse

class ItemNotFound(Exception):
    def __init__(self, item_id: int): self.item_id = item_id

@app.exception_handler(ItemNotFound)         # handle a custom exception type globally
def handle_not_found(request: Request, exc: ItemNotFound):
    return JSONResponse(status_code=404, content={"error": f"Item {exc.item_id} not found"})

@app.get("/items/{id}")
def get(id: int):
    raise ItemNotFound(id)        # raise your domain exception; the handler formats it
```

Aangepaste exception handlers laten je je eigen (domein)exceptions toewijzen aan responses, waardoor foutformattering centraal wordt en handler-code schoon blijft.

## Standaardhandlers overschrijven

```python
from fastapi.exceptions import RequestValidationError

@app.exception_handler(RequestValidationError)   # customize the 422 validation-error format
def validation_handler(request, exc):
    return JSONResponse(status_code=422, content={"errors": exc.errors()})
```

## Waarom het belangrijk is

Juiste foutafhandeling is essentieel voor het bouwen van betrouwbare, professionele API's, en FastAPI's aanpak is schoon en consistent.

De idomatische `HTTPException` maakt het gemakkelijk om juiste foutresponses terug te geven met de passende statuscodes en berichten — fundamenteel voor elk endpoint dat kan mislukken (niet gevonden, verboden, slechte staat).

Evenredig waardevol is dat **validatiefouten automatisch worden afgehandeld** (Pydantic-fouten produceren gestructureerde 422-responses zonder code van jou), en dat **aangepaste exception handlers** je eigen domeinexceptions toewijzen aan responses en een consistent foutformaat afdwingen over de hele API — verbeterend zowel onderhoudbaarheid (gecentraliseerde foutlogica) als clientervaring (voorspelbare foutvormen).

Het begrijpen van `HTTPException`, automatische validatiefouten en aangepaste handlers dekt het praktische spectrum van foutafhandeling, wat het belangrijke kennis maakt voor het bouwen van robuuste API's.