La ce servește response_model?

Question

Accepted Answer

Parametrul **`response_model`** declară forma răspunsului unui endpoint. FastAPI îl folosește pentru a **valida, filtra și serializa** datele returnate — și pentru a documenta răspunsul în documentele API. Sarcina sa cea mai importantă: asigurarea că expui doar câmpurile dorite (de exemplu, să nu cureți niciodată o parolă).

## Problema: scurgerile de câmpuri sensibile

```python
class User(BaseModel):
    name: str
    email: str
    password: str        # ⚠️ should NEVER be in the response!

@app.get("/users/{id}")
def get_user(id: int) -> User:
    return db.get_user(id)   # returning the full object would expose the password
```

## Soluția: un model de răspuns separat

```python
class UserOut(BaseModel):    # the SAFE public shape — no password
    name: str
    email: str

@app.get("/users/{id}", response_model=UserOut)
def get_user(id: int):
    return db.get_user(id)   # returns a full user, but FastAPI FILTERS it to UserOut
# response → { "name": "...", "email": "..." }  — password stripped automatically
```

Cu `response_model=UserOut`, FastAPI ia ceea ce returnezi și **o filtrează** doar la câmpurile declarate în `UserOut` — deci parola (și oricare alte câmpuri suplimentare) este eliminată din răspuns, chiar dacă ai returnat obiectul complet.

## Ce face response_model

```text
✓ FILTERS the output to only the declared fields (key for hiding sensitive data)
✓ VALIDATES that your response matches the declared schema (catches mistakes)
✓ SERIALIZES the data to JSON correctly
✓ DOCUMENTS the response shape in the OpenAPI/Swagger docs
```

## Alternativă modernă: anotația tipului de returnare

```python
@app.get("/users/{id}")
def get_user(id: int) -> UserOut:    # the -> return type works like response_model
    return db.get_user(id)
# response_model_exclude_unset=True → omit fields not explicitly set
```

## De ce este important

`response_model` este important atât pentru **securitate**, cât și pentru un design API curat.

Rolul sau cel mai critic este prevenirea scurgerilor accidentale de date — prin declararea exactă a câmpurilor pe care trebuie să le conțină răspunsul, FastAPI filtrează tot ceea ce altceva (cum ar fi hash-urile de parolă, flag-uri interne sau token-uri) chiar dacă codul tău returnează un obiect complet din baza de date, eliminând o vulnerabilitate comună și serioasă.

Beyond that, it validates your responses against a declared schema (catching bugs where you return the wrong shape), ensures correct serialization, and documents the response in the auto-generated API docs.

Modelul de a folosi modele separate de intrare și ieșire (cu `response_model` controlând ce este expus) este o best practice pentru API-uri sigure și bine definite, ceea ce face această cunoaștere importantă pentru orice endpoint care returnează date.