NestJS integreert schoon met databases via ORM's — meestal TypeORM (officiële @nestjs/typeorm integratie) en Prisma (een moderne, type-veilige ORM gebruikt via een aangepaste service). Beide passen natuurlijk in NestJS's module/provider/DI structuur.
({
: [
.({
: ,
: 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 gebruikt @Entity classes (gemapt naar tabellen) en injecteerbare Repository's voor queries — past natuurlijk in NestJS's DI model via @InjectRepository.
// 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 genereert een volledig type-veilige client vanuit een schema-bestand; je wikkelt het in een injecteerbare PrismaService en gebruikt het in je 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-integratie is essentieel — vrijwel elke backend persisteert gegevens, en begrijpen hoe je op de idiomatische manier een database met NestJS verbindt, is kernpraktische kennis.
Beiden grote ORM's passen schoon in NestJS's architectuur: TypeORM via de officiële @nestjs/typeorm module (verbindingen configureren, @Entity classes definiëren, Repository's via DI injecteren) en Prisma via een ingewikkelde injecteerbare PrismaService (uitstekende type-veiligheid geven).
Weten hoe je de verbinding instelt, modellen definieert en de data-access layer in services injecteert — database-logica in services houdend, gescheiden van controllers — is fundamenteel voor het bouwen van echte NestJS applicaties.
Kritisch is het begrijpen van het migrations-over-synchronize principe (nooit auto-syncing schema in productie, waar het gegevens kan vernietigen, maar in plaats daarvan versiegestuurde migraties gebruiken) een belangrijk praktijk voor productie-veiligheid.
Dit is dagelijks, must-know materiaal, omdat gegevenspersistentie centraal staat in backend-ontwikkeling en de ORM-integratie is hoe NestJS apps daadwerkelijk hun gegevens opslaan en ophalen.