Comment intégrer une base de données (TypeORM/Prisma) avec NestJS ?

Question

Accepted Answer

NestJS s'intègre proprement avec les bases de données via des ORMs — le plus couramment **TypeORM** (intégration officielle `@nestjs/typeorm`) et **Prisma** (un ORM moderne et type-safe utilisé via un service personnalisé). Les deux s'adaptent bien à la structure module/provider/DI de NestJS. ## Intégration TypeORM ```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 utilise des classes `@Entity` (mappées aux tables) et des `Repository`s injectables pour les requêtes — s'adaptant naturellement au modèle de DI de NestJS via `@InjectRepository`. ## Intégration Prisma ```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 génère un client entièrement type-safe à partir d'un fichier de schéma ; vous l'encapsulez dans un `PrismaService` injectable et l'utilisez dans vos services. ## Migrations plutôt que synchronize ```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 ``` ## Pourquoi c'est important L'intégration de base de données est essentielle — presque tous les back-ends persistent des données, et comprendre comment connecter une base de données à NestJS de manière idiomatique est une connaissance pratique fondamentale. Les deux ORMs majeurs s'adaptent bien à l'architecture de NestJS : TypeORM via le module officiel `@nestjs/typeorm` (configuration des connexions, définition des classes `@Entity`, injection des `Repository`s via la DI) et Prisma via un `PrismaService` injectable enveloppé (offrant une excellente sécurité de type). Savoir comment configurer la connexion, définir les modèles, et injecter la couche d'accès aux données dans les services — en gardant la logique de base de données dans les services, séparée des contrôleurs — est fondamental pour construire des applications NestJS réelles. En particulier, comprendre le principe **migrations-plutôt-que-synchronize** (ne jamais auto-synchroniser le schéma en production, où cela peut détruire des données, mais plutôt utiliser des migrations versionnées) est une pratique importante de sécurité en production. C'est du matériel incontournable au quotidien, puisque la persistance des données est centrale au développement back-end et l'intégration de l'ORM est la façon dont les applications NestJS stockent et récupèrent réellement leurs données.