NestJS integriert Datenbanken sauber über ORMs — am häufigsten TypeORM (offizielle @nestjs/typeorm Integration) und Prisma (ein modernes, typensicheres ORM, das über einen benutzerdefinierten Service verwendet wird). Beide passen sich NestJS's Modul-/Provider-/DI-Struktur natürlich an.
({
: [
.({
: ,
: 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 verwendet @Entity Klassen (auf Tabellen abgebildet) und injizierbare Repositorys für Abfragen — passen natürlich auf NestJS's DI-Modell über @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 generiert einen vollständig typensicheren Client aus einer Schemadatei; Sie wickeln ihn in einen injzierbaren PrismaService ein und verwenden ihn in Ihren 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
Datenbankintegration ist unerlässlich — fast jedes Backend speichert Daten, und zu verstehen, wie man eine Datenbank auf idiomatische Weise mit NestJS verbindet, ist grundlegendes praktisches Wissen.
Beiden großen ORMs passen sich NestJS's Architektur sauber an: TypeORM über das offizielle @nestjs/typeorm Modul (Verbindungen konfigurieren, @Entity Klassen definieren, Repositorys durch DI injizieren) und Prisma über einen umschlossenen injzierbaren PrismaService (was hervorragende Typensicherheit bietet).
Zu wissen, wie man die Verbindung einrichtet, Modelle definiert und die Datenzugriffsschicht in Services einspritzt — Datenbanklogik in Services beibehalten, getrennt von Controllern — ist grundlegend für den Aufbau echter NestJS-Anwendungen.
Kritisch ist das Verständnis des Prinzips Migrationen-statt-Synchronisierung (niemals Auto-Synchronisierung von Schema in der Produktion, wo es Daten zerstören kann, sondern stattdessen versionskontrollierte Migrationen verwenden) eine wichtige Produktionssicherheitspraxis.
Dies ist alltägliches, muss-man-kennen Material, da Datenpersistenz für die Backend-Entwicklung zentral ist und die ORM-Integration ist, wie NestJS-Anwendungen tatsächlich ihre Daten speichern und abrufen.