NestJS integreras smidigt med databaser via ORM:er — oftast TypeORM (officiell @nestjs/typeorm-integrering) och Prisma (en modern, typesäker ORM som används via en anpassad tjänst). Båda passar väl in i NestJS:s modul-/provider-/DI-struktur.
({
: [
.({
: ,
: 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 använder @Entity-klasser (mappade till tabeller) och injicerbara Repository:er för frågor — passar naturligt in i NestJS:s DI-modell 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 genererar en helt typesäker klient från en schemafil; du omsluter den i en injicerbar PrismaService och använder den i dina tjänster.
⚠️ 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
Databasintegrering är väsentlig — nästan alla backends lagrar data, och att förstå hur man kopplar en databas till NestJS på det idiomatiska sättet är grundläggande praktisk kunskap.
Båda större ORM:erna passar väl in i NestJS:s arkitektur: TypeORM via den officiella @nestjs/typeorm-modulen (konfigurering av anslutningar, definiering av @Entity-klasser, injicering av Repository:er genom DI) och Prisma via en omsluten injicerbar PrismaService (som ger utmärkt typsäkerhet).
Att veta hur man konfigurerar anslutningen, definierar modeller och injicerar dataaccesslagret i tjänster — med databaslogik i tjänster, separerat från controllers — är grundläggande för att bygga verkliga NestJS-applikationer.
Viktigt är att förstå principen migrations framför synchronize (aldrig automatisk schemassynkronisering i produktion, där det kan förstöra data, utan istället använd versionskontrollerade migrations) är en viktig praxis för produktionssäkerhet.
Detta är vardagligt, måste-veta-material, eftersom datapersistens är central för backendutveckling och ORM-integreringen är hur NestJS-appar faktiskt lagrar och hämtar sina data.