How do you integrate a database (TypeORM/Prisma) with NestJS?

Question

Accepted Answer

NestJS integrates cleanly with databases via ORMs — most commonly **TypeORM** (official `@nestjs/typeorm` integration) and **Prisma** (a modern, type-safe ORM used via a custom service). Both fit NestJS's module/provider/DI structure. ## 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 uses `@Entity` classes (mapped to tables) and injectable `Repository`s for queries — fitting NestJS's DI model naturally via `@InjectRepository`. ## 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 generates a fully type-safe client from a schema file; you wrap it in an injectable `PrismaService` and use it in your services. ## Migrations over 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 ``` ## Why it matters Database integration is essential — almost every back-end persists data, and understanding how to connect a database to NestJS the idiomatic way is core practical knowledge. Both major ORMs fit NestJS's architecture cleanly: TypeORM via the official `@nestjs/typeorm` module (configuring connections, defining `@Entity` classes, injecting `Repository`s through DI) and Prisma via a wrapped injectable `PrismaService` (giving excellent type safety). Knowing how to set up the connection, define models, and inject the data-access layer into services — keeping database logic in services, separate from controllers — is fundamental to building real NestJS applications. Critically, understanding the **migrations-over-synchronize** principle (never auto-syncing schema in production, where it can destroy data, but instead using version-controlled migrations) is an important production-safety practice. This is everyday, must-know material, since data persistence is central to back-end development and the ORM integration is how NestJS apps actually store and retrieve their data.