Hvordan modellerer du nestede og komplekse request bodies?

Question

Accepted Answer

Pydantic-modeller kan **nestes** — et modellfelt kan i seg selv være en annen modell, en liste med modeller, eller komplekse typer — slik at FastAPI automatisk validerer dypt strukturert JSON (objekter innen objekter, arrays av objekter).

## Nestede modeller

```python
from pydantic import BaseModel

class Address(BaseModel):
    street: str
    city: str
    zip: str

class User(BaseModel):
    name: str
    address: Address                    # a NESTED model
    tags: list[str] = []                # a list of strings
    addresses: list[Address] = []       # a list of NESTED models

@app.post("/users")
def create(user: User):                  # validates the WHOLE nested structure
    return user
```

```json
// FastAPI validates this entire structure, including the nested address:
{ "name": "Ann",
  "address": { "street": "1 Main", "city": "NY", "zip": "10001" },
  "tags": ["vip"] }
```

Et modellfelt som er skrevet som en annen modell (eller `list[Model]`) valideres rekursivt — nestede objekter og arrays av objekter kontrolleres alle mot deres skjemaer automatisk.

## Komplekse og spesielle typer

```python
from pydantic import BaseModel, HttpUrl, EmailStr
from datetime import datetime
from enum import Enum

class Status(str, Enum):                 # enums constrain to allowed values
    active = "active"
    inactive = "inactive"

class Item(BaseModel):
    url: HttpUrl                          # validates URL format
    email: EmailStr                       # validates email format
    created: datetime                     # parses ISO 8601 strings → datetime
    status: Status                        # must be one of the enum values
    metadata: dict[str, int]              # typed dict
    coordinates: tuple[float, float]      # typed tuple
```

Pydantic håndterer rike typer: enums (begrens til tillatte verdier), `datetime` (parser ISO-strenger), `HttpUrl`/`EmailStr` (formatvalidering), og typede dicts/tuples — alt validert automatisk.

## Generiske / gjenbrukbare wrappere

```python
from typing import Generic, TypeVar
T = TypeVar("T")
class Paginated(BaseModel, Generic[T]):   # a reusable generic response wrapper
    items: list[T]
    total: int
# Paginated[User] → { items: [User...], total: N }
```

## Hvorfor det er viktig

Reelle APIer sjelden håndterer flate data — de håndterer komplekse, nestede strukturer (en bruker med en adresse og en liste med ordrer, en ordre med linjeelementer, konfigrasjonsobjekter), og Pydantics evne til å **neste modeller** gjør validering av disse dypt strukturerte request bodies problemfritt.

Å forstå at et modellfelt kan være en annen modell, en liste med modeller, eller en rik type — og at FastAPI **validerer hele den nestede strukturen rekursivt** og automatisk — er viktig for å bygge APIer som aksepterer realistisk, kompleks input trygt.

Støtten for rike typer (enums for begrensede verdier, `datetime`-parsing, `HttpUrl`/`EmailStr`-formatvalidering, typede samlinger) sikrer videre at komplekse data er korrekte uten manuelle sjekker.

Å vite hvordan du modellerer nestede og komplekse bodies (og gjenbrukbare generiske wrappere for ting som paginering) er praktisk kunnskap for å bygge APIer som håndterer den strukturerte dataen virkelige applikasjoner krever, med full validering gitt automatisk — en nøkkelstyrke i FastAPIs Pydantic-baserte design.