TypeORM/Prisma ఉపయోగించి డేటాబేస్‌ను NestJS తో ఎలా ఇంటిగ్రేట్ చేస్తారు?

Question

Accepted Answer

NestJS డేటాబేస్‌లను ORMs ద్వారా깔끔하గా ఇంటిగ్రేట్ చేస్తుంది — చాలా సాధారణంగా **TypeORM** (అధికారిక `@nestjs/typeorm` ఇంటిగ్రేషన్) మరియు **Prisma** (ఆధુनిక, టైప్-సేఫ్ ORM ఇది కస్టమ్ సర్వీస్ ద్వారా ఉపయోగించబడుతుంది). రెండూ NestJS యొక్క module/provider/DI స్ట్రక్చర్‌కు సరిపోతాయి. ## TypeORM integration ```ts // 1. configure the connection in a module @Module({ imports: [ TypeOrmModule.forRoot({ type: "postgres", url: process.env.DATABASE_URL, entities: [User], synchronize: false, // ⚠️ NEVER true in production (use migrations) }), TypeOrmModule.forFeature([User]), // register entities for this feature module ], }) export class UsersModule {} ``` ```ts // 2. define an entity (maps to a table) @Entity() export class User { @PrimaryGeneratedColumn() id: number; @Column() name: string; @Column({ unique: true }) email: string; } ``` ```ts // 3. inject the repository into a service @Injectable() export class UsersService { constructor( @InjectRepository(User) private usersRepo: Repository, ) {} findAll() { return this.usersRepo.find(); } findOne(id: number) { return this.usersRepo.findOneBy({ id }); } create(data: Partial) { return this.usersRepo.save(data); } } ``` TypeORM `@Entity` క్లాసులను (టేబిల్‌లకు మ్యాపర్‌లు) మరియు చేతిలో పట్టుకోదగ్గ `Repository`లను ఉపయోగిస్తుంది — `@InjectRepository` ద్వారా NestJS యొక్క DI మోడల్‌కు సహజంగా సరిపోతుంది. ## Prisma integration ```ts // 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 } ``` ```ts // 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`లో చుట్టుకుని మీ సర్విసులలో దానిని ఉపయోగిస్తారు. ## సింక్రোనైజ్ కంటే మైగ్రేషన్‌లు ```text ⚠️ 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 vs Prisma ```text 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 అప్లికేషన్‌లు వాస్తవానికి తమ డేటాను ఎలా సేవ చేస్తాయి మరియు పునరుద్ధరిస్తాయి.