NestJS ORMs மூலம் databases-உடன் சுத்தமாக integrate செய்கிறது — மிகவும் பொதுவாக TypeORM (அதிகாரப்பூர்வ @nestjs/typeorm integration) மற்றும் Prisma (ஒரு custom service மூலம் பயன்படுத்தப்படும் ஒரு modern, type-safe 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 classes-ஐ (tables-உடன் map செய்யப்பட்டவை) மற்றும் queries-க்கான injectable Repositorys-ஐ பயன்படுத்துகிறது — @InjectRepository மூலம் NestJS-இன் DI model-க்கு இயற்கையாக பொருந்துகிறது.
// 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 ஒரு schema file-இலிருந்து முழுமையான type-safe client-ஐ உருவாக்குகிறது; நீங்கள் அதை ஒரு injectable PrismaService-இல் wrap செய்து உங்கள் services-இல் பயன்படுத்துகிறீர்கள்.
⚠️ 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
Database integration அத்தியாவசியம் — கிட்டத்தட்ட ஒவ்வொரு back-end-ம் data-ஐ persist செய்கிறது, மற்றும் ஒரு database-ஐ NestJS-உடன் idiomatic வழியில் எவ்வாறு இணைப்பது என்பதை புரிந்துகொள்வது முக்கிய நடைமுறை அறிவு.
இரண்டு முக்கிய ORMs-ம் NestJS-இன் architecture-க்கு சுத்தமாக பொருந்துகின்றன: TypeORM அதிகாரப்பூர்வ @nestjs/typeorm module மூலம் (connections-ஐ configure செய்தல், @Entity classes-ஐ வரையறுத்தல், DI மூலம் Repositorys-ஐ inject செய்தல்) மற்றும் Prisma ஒரு wrapped injectable PrismaService மூலம் (சிறந்த type safety-ஐ வழங்குதல்).
Connection-ஐ எவ்வாறு அமைப்பது, models-ஐ வரையறுப்பது, மற்றும் data-access layer-ஐ services-இல் inject செய்வது — database logic-ஐ services-இல் வைத்து, controllers-இலிருந்து தனியாக — என்பதை அறிவது உண்மையான NestJS applications-ஐ உருவாக்க அடிப்படை.
முக்கியமாக, migrations-over-synchronize கொள்கையை (production-இல் schema-ஐ ஒருபோதும் auto-sync செய்யாமல், அங்கு அது data-ஐ அழிக்கலாம், மாறாக version-controlled migrations-ஐ பயன்படுத்துதல்) புரிந்துகொள்வது ஒரு முக்கியமான production-safety நடைமுறை.
இது தினசரி, அவசியம் அறிய வேண்டிய material, ஏனெனில் data persistence back-end development-க்கு மையமானது மற்றும் ORM integration தான் NestJS apps உண்மையில் தங்கள் data-ஐ store செய்து retrieve செய்யும் விதம்.