NestJS డేటాబేస్లను ORMs ద్వారా깔끔하గా ఇంటిగ్రేట్ చేస్తుంది — చాలా సాధారణంగా TypeORM (అధికారిక @nestjs/typeorm ఇంటిగ్రేషన్) మరియు Prisma (ఆధુनిక, టైప్-సేఫ్ ORM ఇది కస్టమ్ సర్వీస్ ద్వారా ఉపయోగించబడుతుంది). రెండూ NestJS యొక్క module/provider/DI స్ట్రక్చర్కు సరిపోతాయి.
({
: [
.({
: ,
: process..,
: [],
: ,
}),
.([]),
],
})
{}
// 2. define an entity (maps to a table)
@Entity()
export class User {
@PrimaryGeneratedColumn() id: number;
@Column() name: string;
@Column({ unique: true }) email: string;
}
// 3. inject the repository into a service
@Injectable()
export class UsersService {
constructor(
@InjectRepository(User) private usersRepo: Repository<User>,
) {}
findAll() { return this.usersRepo.find(); }
findOne(id: number) { return this.usersRepo.findOneBy({ id }); }
create(data: Partial<User>) { return this.usersRepo.save(data); }
}
TypeORM @Entity క్లాసులను (టేబిల్లకు మ్యాపర్లు) మరియు చేతిలో పట్టుకోదగ్గ Repositoryలను ఉపయోగిస్తుంది — @InjectRepository ద్వారా NestJS యొక్క DI మోడల్కు సహజంగా సరిపోతుంది.
// 1. a PrismaService wraps the Prisma client (and manages connection lifecycle)
@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
async onModuleInit() { await this.$connect(); } // connect on startup
}
// 2. inject it and use the type-safe client
@Injectable()
export class UsersService {
constructor(private prisma: PrismaService) {}
findAll() { return this.prisma.user.findMany(); }
findOne(id: number) { return this.prisma.user.findUnique({ where: { id } }); }
create(data) { return this.prisma.user.create({ data }); }
}
Prisma స్కీమా ఫైల్ నుండి పూర్తిగా టైప్-సేఫ్ క్లায়েంట్ను జెనరేట్ చేస్తుంది; మీరు దానిని ఇంజెక్టబల్ PrismaServiceలో చుట్టుకుని మీ సర్విసులలో దానిని ఉపయోగిస్తారు.
⚠️ NEVER use `synchronize: true` (TypeORM) in production — it auto-alters your schema
and can DROP data. Use MIGRATIONS (version-controlled schema changes) instead.
Prisma: prisma migrate dev/deploy manages schema changes via migration files.
TypeORM → repository/active-record patterns, decorators, mature, official Nest integration
Prisma → schema-first, excellent type safety, great DX, growing popularity
డేటాబేస్ ఇంటిగ్రేషన్ అপরిहार్యం — దాదాపు ప్రతిটి back-end డేటాను నిలిపేస్తుంది, మరియు NestJSకు డేటాబేస్ను సంబంధితమైన విధంగా ఎలా కనెక్ట్ చేయాలో అర్థం చేసుకోవడం ఇది ప్రధానమైన ఆచరణాత్మక జ్ఞానం.
రెండు ప్రధాన ORMs NestJS ఆర్కిటెక్చర్కు깔끔కగా సరిపోతాయి: TypeORM అధికారిక @nestjs/typeorm మాడ్యూల్ ద్వారా (కనెక్షన్లను కాన్ఫిగర్ చేయడం, @Entity క్లాసులను నిర్వచించడం, DI ద్వారా Repositoryలను ఇంజెక్ట్ చేయడం) మరియు Prisma చేతిలో పట్టుకోదగ్గ PrismaService ద్వారా (అద్భుతమైన టైప్ సేఫ్టీ ఇవ్వడం).
కనెక్షన్ను సెటప్ చేయడం, మోడల్లను నిర్వచించడం, మరియు డేటా-యాక్సెస్ లేయర్ను సర్విసులలో ఇంజెక్ట్ చేయడం — డేటాబేస్ లాజిక్ను సర్విసులలో ఉంచడం, నియంత్రకాల నుండి వేరుగా — నిజమైన NestJS అప్లికేషన్లను నిర్మించడానికి ఇది ప్రాథమికం.
కీలకంగా, migrations-over-synchronize సూత్రం (ఎప్పుడూ స్కీమాను ఉత్పత్తిలో స్వయంచాలకంగా సింక్ చేయవద్దు, ఇది డేటాను నాశనం చేయవచ్చు, కానీ బదులుగా సంస్కరణ-నియంత్రిత మైగ్రేషన్లను ఉపయోగించండి) ను అర్థం చేసుకోవడం ఒక ముఖ్యమైన ఉత్పత్తి-సురక్ష ఆచరణ.
ఇది రోజువారీ, తప్పక-తెలుసుకోవాల్సిన విషయం, ఎందుకంటే డేటా నిలకడ back-end అభివృద్ధికి కేంద్రీయమైనది మరియు ORM ఇంటిగ్రేషన్ NestJS అప్లికేషన్లు వాస్తవానికి తమ డేటాను ఎలా సేవ చేస్తాయి మరియు పునరుద్ధరిస్తాయి.
జూనియర్ నుండి సీనియర్ వరకు వివరణాత్మక సమాధానాలతో IT ఇంటర్వ్యూ ప్రశ్నల లైబ్రరీ.
విరాళం