Cum scrii validare personalizată în Pydantic?

Question

Accepted Answer

Dincolo de constrângerile încorporate, Pydantic te lasă să scrii **logică de validare personalizată** cu validatori de câmp (validează un câmp) și validatori de model (validează pe mai multe câmpuri) — pentru reguli pe care constrângerile simple nu le pot exprima. (Sintaxa prezentată este pentru Pydantic v2.)

## Validatori de câmp — validare/transformare a unui singur câmp

```python
from pydantic import BaseModel, field_validator

class User(BaseModel):
    username: str
    password: str

@field_validator("username")
    @classmethod
    def username_alphanumeric(cls, v: str) -> str:
        if not v.isalnum():
            raise ValueError("username must be alphanumeric")   # → a 422 error
        return v.lower()                                         # can also TRANSFORM the value
```

Un `@field_validator` execută logică personalizată pe un câmp: ridică `ValueError` pentru a respinge intrarea nevalidă (FastAPI o transformă într-un răspuns 422 clar), sau returnează o valoare transformată (de ex. normalizare la litere mici).

## Validatori de model — validare între câmpuri

```python
from pydantic import model_validator

class SignupForm(BaseModel):
    password: str
    confirm_password: str

@model_validator(mode="after")
    def passwords_match(self):
        if self.password != self.confirm_password:    # compare MULTIPLE fields
            raise ValueError("passwords do not match")
        return self
```

Un `@model_validator(mode="after")` se execută după ce toate câmpurile sunt validate, cu acces la modelul întreg — folosit pentru reguli care implică **mai multe câmpuri** (de ex. confirmarea că parolele se potrivesc, sau că o dată de început precede o dată de sfârşit).

## Validarea încorporată este adesea suficientă la început

```python
class Product(BaseModel):
    price: float = Field(gt=0)          # use Field constraints for simple rules
    sku: str = Field(pattern=r"^[A-Z]{3}-\d+$")
    email: EmailStr                      # specialized types for formats
# reach for custom validators only when constraints/types can't express the rule
```

Preferă constrângerile `Field` și tipurile specializate pentru reguli simple; foloseşte validatori personalizaţi pentru logică de afaceri genuină.

## De ce este important

Validarea personalizată în Pydantic este importantă pentru impunerea regulilor de afaceri care depăşesc verificările simple de tip și constrângeri — iar din moment ce validarea este critică pentru **securitate și integritate a datelor**, a putea exprima orice regulă este valoroasă. **Validatorii de câmp** gestionează logica la nivel de câmp unic (verificări de format personalizate, normalizare/transformare), în timp ce **validatorii de model** gestionează necesitatea comună de **validare între câmpuri** (potrivirea parolelor, intervale de date, cerințe condiționale) pe care regulile la nivel de câmp nu o pot exprima.

Validatorii se integrează perfect cu FastAPI — un `ValueError` ridicat devine un răspuns 422 clar automat.

Înțelegerea când să foloseşti constrângeri/tipuri încorporate (pentru reguli simple) față de validatori personalizaţi (pentru logică de afaceri reală), și cum diferă validatorii de câmp versus validatorii de model, te lasă să te asiguri că datele primite satisfac pe deplin cerințele aplicației tale, făcând aceasta o cunoaştere importantă pentru construirea unor API-uri robuste și corecte.