Serializarea controlează modul în care obiectele sunt transformate în JSON trimis în răspunsuri — crucial, excludând câmpurile sensibile (cum ar fi parolele) și modelând rezultatul. NestJS gestionează acest lucru cu ClassSerializerInterceptor și decoratorii din class-transformer.
()
() {
..(id);
}
Returnarea directă a entităților din bază de date poate expune câmpuri care nu ar trebui să ajungă la client (hash-uri de parole, flag-uri interne, tokenuri) — o problemă serioasă de securitate/confidențialitate.
import { Exclude } from "class-transformer";
export class User {
id: number;
name: string;
email: string;
@Exclude() // this field is REMOVED from responses
password: string;
}
// enable the serializer interceptor (globally or per-controller)
@UseInterceptors(ClassSerializerInterceptor)
@Controller("users")
export class UsersController {
@Get(":id")
findOne(@Param("id") id): User {
return this.usersService.findOne(id); // password is automatically stripped
}
}
// or globally: app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)))
ClassSerializerInterceptor aplică decoratorii din class-transformer la serializarea răspunsurilor, deci câmpurile marcate cu @Exclude() sunt automat eliminate — dar doar dacă returnezi instanțe de clase (nu obiecte simple).
export class User {
@Expose() id: number; // explicitly include (with excludeAll strategy)
@Exclude() password: string; // remove from output
@Expose({ name: "full_name" }) // rename in the output
name: string;
@Transform(({ value }) => value.toUpperCase()) // transform the value
code: string;
@Exclude({ toPlainOnly: true }) // exclude only when serializing OUT (not on input)
internalField: string;
}
// ⚠️ the interceptor only transforms CLASS INSTANCES — plain objects pass through unchanged
return new User(data); // ✅ decorators apply
return plainToInstance(User, data); // ✅ convert a plain object to an instance
return { ...data }; // ❌ plain object — @Exclude is IGNORED!
O capcană comună: decoratorii de serializare funcționează doar pe instanțe reale de clase, deci trebuie să returnezi o instanță (entitățile ORM sunt de obicei instanțe; obiectele simple construite manual necesită conversie).
Instead of decorating entities, map to a separate Response DTO containing only the
fields meant for the client — explicit, decoupled from the DB model, and very safe.
Controlarea serializării răspunsurilor este importantă atât pentru securitate, cât și pentru design API curat.
Motivul cel mai critic este prevenirea scurgerilor de date sensibile — returnarea directă a entităților din bază de date poate expune hash-uri de parole, câmpuri interne, tokenuri sau alte date care nu trebuie niciodată să ajungă la clienți, o vulnerabilitate comună și serioasă.
ClassSerializerInterceptor al NestJS, împreună cu decoratorii din class-transformer (@Exclude, @Expose, @Transform), oferă o modalitate curată și declarativă de a modela răspunsurile — eliminând automat câmpurile excluse, redenumind și transformând valori.
Înțelegerea acestui aspect este cunoștință esențială zi de zi pentru orice API care returnează date de utilizatori sau domeniu, iar cunoașterea capcanei cheie — că serializarea funcționează doar pe instanțe de clase, nu pe obiecte simple (sursă frecventă de bug-uri "de ce încă se vede parola?") — este practic importantă.
Egal de valoroasă este recunoașterea modelului alternativ de DTO-uri dedicate de răspuns (maparea entităților la clase de ieșire explicite care conțin doar câmpuri sigure pentru client), care decuplează contractul API de modelul bazei de date și este cea mai sigură abordare pentru date sensibile.
Controlarea corectă a serializării este o caracteristică a API-urilor NestJS sigure și bine proiectate și o preocupare frecvent relevantă în aplicații reale care gestionează orice date non-publice.