Serialization ఆబ్జెక్ట్లను రెస్పాన్స్లలో పంపిన JSON కి ఎలా రూపాంతరించాలో నియంత్రిస్తుంది — కీలకంగా, **సంবంధితమైన ఫీల్డ్లను బయటకు లేదా (పాస్వర్డ్ల వంటివి) మరియు అవుట్పుట్ను రూపుచేస్తుంది. NestJS ఇందుని ClassSerializerInterceptor మరియు class-transformer డెకోరేటర్ల ద్వారా నిర్వహిస్తుంది.
()
() {
..(id);
}
డేటాబేస్ ఎంటిటీలను నేరుగా రిటర్న్ చేయడం ఫీల్డ్లను బయటపెట్టవచ్చు, ఇవి క్లায়েంట్కు ఎప్పుడూ చేరకూడదు (పాస్వర్డ్ హ్యాష్లు, అంతర్గత ఫ్లాగ్లు, టోకెన్లు) — ఇది ఒక తీవ్రమైన సెక్యూరిటీ/గోప్యతా సమస్య.
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 రెస్పాన్స్లను సీరియలైజ్ చేస్తున్నప్పుడు class-transformer డెకోరేటర్లను అన్వయిస్తుంది, కాబట్టి @Exclude() ఫీల్డ్లు స్వయంచాలకంగా తీసివేయబడతాయి — కానీ మీరు క్లాస్ ఇన్స్టాన్సులను మాత్రమే రిటర్న్ చేస్తే (సాధారణ ఆబ్జెక్ట్లను కాకుండా).
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!
సాధారణ సమస్య: సీరియలైజేషన్ డెకోరేటర్లు వాస్తవ క్లాస్ ఇన్స్టాన్సులపై మాత్రమే పనిచేస్తాయి, కాబట్టి మీరు ఒక ఇన్స్టాన్స్ను రిటర్న్ చేయాలి (ORM ఎంటిటీలు సాధారణంగా ఇన్స్టాన్సులు; మానవీయంగా నిర్మిత సాధారణ ఆబ్జెక్ట్లను మార్పిడి అవసరం).
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.
రెస్పాన్స్ సీరియలైజేషన్ను నియంత్రించడం సెక్యూరిటీ మరియు శుభ్ర API డిజైన్ రెండింటికీ ముఖ్యమైనది.
సర్వాధిక సంకీర్ణ కారణం సున్నితమైన డేటా లీక్లను నిరోధించడం — డేటాబేస్ ఎంటిటీలను నేరుగా రిటర్న్ చేయడం పాస్వర్డ్ హ్యాష్లు, అంతర్గత ఫీల్డ్లు, టోకెన్లు లేదా క్లైంట్ల వద్దకు రాకూడని ఇతర డేటాను బయటపెట్టవచ్చు, ఇది సాధారణమైన మరియు తీవ్రమైన హమ్మకం.
NestJS యొక్క ClassSerializerInterceptor class-transformer డెకోరేటర్ల (@Exclude, @Expose, @Transform) ఉపయోగించి రెస్పాన్స్లను రూపుచేయడానికి శుభ్ర, ప్రకటన చేసిన వాయువు ఒక మార్గాన్ని అందిస్తుంది — స్వయంచాలకంగా బయటపడిన ఫీల్డ్లను తీసివేయడం, పునర్నామకరణ మరియు విలువలను రూపాంతరం చేయడం.
ఇందుని అర్థం చేసుకోవడం ఏదైనా API కోసం ప్రతిదిన ముఖ్యమైన జ్ఞానం, ఇది యూజర్ లేదా డొమైన్ డేటాను రిటర్న్ చేస్తుంది, మరియు కీ సమస్యను తెలుసుకోవడం — సీరియలైజేషన్ క్లాస్ ఇన్స్టాన్సులపై మాత్రమే పనిచేస్తుంది, సాధారణ ఆబ్జెక్ట్ల పై కాకుండా ("పాస్వర్డ్ ఇంకా ఎందుకు చూపిస్తున్నది?" బగ్ల యొక్క తరచుగా వస్తువు) — ఆచరణాత్మకంగా ముఖ్యమైనది.
సమానంగా విలువైనది అంకితమైన రెస్పాన్స్ DTOs (ఎంటిటీలను సర్వజన-సురక్షితమైన ఫీల్డ్లను మాత్రమే కలిగిన స్పష్టమైన అవుట్పుట్ క్లాస్లకు మ్యాపింగ్) యొక్క ప్రత్యామ్నాయ నమూనా గుర్తించడం, ఇది API ఒప్పందాన్ని డేటాబేస్ మోడల్ నుండి విడదీస్తుంది మరియు సున్నితమైన డేటా కోసం సురక్షితమైన విధానం.
సీరియలైజేషన్ను సరిగ్గా నియంత్రించడం సురక్షితమైన, బాగా-రూపకల్పన చేసిన NestJS APIs యొక్క సంకేతం మరియు ఏదైనా ప్రజా-విషయం కాని డేటాను నిర్వహించే నిజ జీవితం అనువర్తనాలలో ఎక్కువ తరచుగా సంబంధితమైన ఆందోళన.