Sérialisation contrôle la façon dont les objets sont transformés en JSON envoyé dans les réponses — crucially, en excluant les champs sensibles (comme les mots de passe) et en façonnant la sortie. NestJS gère cela avec le ClassSerializerInterceptor et les décorateurs class-transformer.
// ❌ returning an entity directly leaks the password hash!
(":id")
findOne(("id") id: string) {
return this.usersService.findOne(id); // { id, name, email, password: "$2b$..." } 😱
}
Retourner directement les entités de base de données peut exposer des champs qui ne doivent jamais atteindre le client (hashs de mots de passe, drapeaux internes, tokens) — un problème sérieux de sécurité/confidentialité.
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)))
Le ClassSerializerInterceptor applique les décorateurs class-transformer lors de la sérialisation des réponses, de sorte que les champs @Exclude() sont automatiquement supprimés — mais seulement si vous retournez des instances de classe (pas des objets ordinaires).
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!
Une erreur courante : les décorateurs de sérialisation ne fonctionnent que sur les instances de classe réelles, vous devez donc retourner une instance (les entités ORM sont généralement des instances ; les objets ordinaires construits manuellement ont besoin de conversion).
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.
Contrôler la sérialisation des réponses est important pour la sécurité et la conception d'API propre.
La raison la plus critique est de prévenir les fuites de données sensibles — retourner directement les entités de base de données peut exposer des hashs de mots de passe, des champs internes, des tokens ou d'autres données qui ne doivent jamais atteindre les clients, une vulnérabilité courante et sérieuse.
Le ClassSerializerInterceptor de NestJS avec les décorateurs class-transformer (@Exclude, @Expose, @Transform) offre un moyen propre et déclaratif de façonner les réponses — en supprimant automatiquement les champs exclus, en renommant et en transformant les valeurs.
Comprendre cela est une connaissance essentielle quotidienne pour toute API qui retourne des données utilisateur ou de domaine, et connaître le piège clé — que la sérialisation ne fonctionne que sur les instances de classe, pas les objets ordinaires (une source fréquente de bugs « pourquoi le mot de passe est-il encore visible ? ») — est pratiquement important.
Également précieux est de reconnaître le modèle alternatif des DTOs de réponse dédiés (mapping des entités à des classes de sortie explicites contenant uniquement des champs sûrs pour les clients), qui découple le contrat API du modèle de base de données et est l'approche la plus sûre pour les données sensibles.
Contrôler correctement la sérialisation est un hallmark des APIs NestJS sécurisées et bien conçues et une préoccupation fréquemment pertinente dans les applications réelles traitant des données non publiques.