Piye cara nggabung request body sing kompleks lan nested?

Question

Accepted Answer

Model Pydantic bisa **nested** — field model bisa dadi model liyane, list saka model, utawa tipe kompleks — ngidini FastAPI validasi JSON sing terstruktur jero (objek ing objek, array saka objek) kanthi otomatis.

## Model nested

```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"] }
```

Field model sing ketik dadi model liyane (utawa `list[Model]`) divalidasi secara rekursif — objek nested lan array saka objek kabeh dicek ngarep schema-e kanthi otomatis.

## Tipe kompleks lan special

```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 nangani tipe kaya iku: enum (watesake marang nilai sing diidinkan), `datetime` (parse string ISO), `HttpUrl`/`EmailStr` (validasi format), lan typed dict/tuple — kabeh divalidasi kanthi otomatis.

## Wrapper generic / reusable

```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 }
```

## Apa gawe penting

API real-world jarang nangani data sing flat — nangani struktur kompleks lan nested (user karo alamat lan list order, order karo line item, object konfigurasi), lan kemampuan Pydantic kanggo **nested model** gawe validasi request body sing terstruktur jero dadi gampang.

Ngerti yen field model bisa dadi model liyane, list model, utawa tipe kaya iku — lan yen FastAPI **validasi struktur nested kabeh secara rekursif** lan otomatis — penting kanggo bangun API sing trima input realistis lan kompleks karo aman.

Dukungan tipe kaya iku (enum kanggo nilai wates, parsing `datetime`, validasi format `HttpUrl`/`EmailStr`, koleksi typed) luwih ngedadekke data kompleks bener tanpa cek manual.

Ngerti carane model body nested lan kompleks (lan reusable generic wrapper kanggo perkara kaya pagination) yakni katrangan praktis kanggo bangun API sing tangani data terstruktur sing dibutuhi aplikasi nyata, karo validasi lengkap diberekne otomatis — kekuatan utama saka desain FastAPI sing berbasis Pydantic.