Hoe definieer je routes (path operations)?

Question

Accepted Answer

In FastAPI is een **path operation** een route — een functie versierd met een HTTP-method decorator (`@app.get`, `@app.post`, enz.) die verzoeken naar een pad afhandelt. De retourwaarde van de functie wordt automatisch naar JSON geserialiseerd.

## Routes voor elke HTTP-methode definiëren

```python
from fastapi import FastAPI
app = FastAPI()

@app.get("/items")                # GET /items
def list_items():
    return [{"id": 1}, {"id": 2}]  # dict/list → automatically JSON-serialized

@app.get("/items/{item_id}")      # GET /items/5 — path parameter
def get_item(item_id: int):        # type hint converts "5" → int (and validates)
    return {"id": item_id}

@app.post("/items")               # POST /items
def create_item(item: Item):
    return item

@app.put("/items/{item_id}")      # PUT, PATCH, DELETE work the same way
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    return {"deleted": item_id}
```

Elke decorator wijst een HTTP-methode + pad toe aan een handler. De functienaam is van jou; de decorator definieert de route. Geretourneerde dicts/lists/Pydantic-modellen worden automatisch naar JSON geserialiseerd — geen handmatige `json.dumps`.

## Volgorde is belangrijk voor overlappende paden

```python
@app.get("/users/me")            # ✅ specific route FIRST
def read_me(): ...
@app.get("/users/{user_id}")     # dynamic AFTER — else "me" matches {user_id}
def read_user(user_id: int): ...
```

FastAPI match routes in declaratievolgorde, dus plaats statische paden voor dynamische.

## Operation metadata (voedt de docs)

```python
@app.get("/items", tags=["items"], summary="List items", status_code=200)
def list_items(): ...
```

Decorator-parameters (`tags`, `summary`, `status_code`, `response_model`) configureren gedrag en verrijken de automatisch gegenereerde documentatie.

## Waarom het belangrijk is

Path operations zijn de basis van elke FastAPI-applicatie — ze definiëren de eindpunten van je API en hoe verzoeken worden afgehandeld.

Het begrijpen van het decorator-per-HTTP-methode patroon, dat retourwaarden automatisch naar JSON worden geserialiseerd (geen boilerplate), dat type hints op parameters conversie en validatie aansturen, en dat routevolgorde belangrijk is voor overlappende paden, is essentiële dagelijkse kennis voor het bouwen van elk eindpunt.

De decorator-metadata voedt ook FastAPI's automatische documentatie, waarbij routes rechtstreeks aan de docs worden gekoppeld.

Dit is het eerste en meest fundamentele wat je in FastAPI moet beheersen.