ORM für TypeScript: Vergleich und Beispiele

In der modernen Webentwicklung mit TypeScript ist die Wahl des richtigen ORM (Object-Relational Mapping) eine der wichtigsten Entscheidungen, die die Architektur, Leistung und Wartbarkeit eines Projekts beeinflusst. Ein ORM ermöglicht die Arbeit mit einer Datenbank über Objekte der Programmiersprache und abstrahiert SQL-Abfragen. In diesem Artikel betrachten wir die drei beliebtesten ORMs für TypeScript: TypeORM, Prisma und MikroORM. Sie erfahren deren Stärken und Schwächen und sehen Codebeispiele für jedes.

1. TypeORM

TypeORM ist eines der ältesten und ausgereiftesten ORMs für TypeScript und JavaScript. Es unterstützt die Active Record- und Data Mapper-Entwurfsmuster sowie eine Vielzahl von Datenbanken: PostgreSQL, MySQL, SQLite, MongoDB und andere.

Besonderheiten von TypeORM:

Unterstützung von Decorators zur Definition von Entitäten
Flexible Beziehungen: OneToOne, OneToMany, ManyToMany
Migrationen und Schema-Synchronisation
Unterstützung von Subscriptions und Lifecycle-Events
Query Builder für komplexe Abfragen

Codebeispiel mit TypeORM:

import { Entity, PrimaryGeneratedColumn, Column, BaseEntity, createConnection } from "typeorm";

@Entity()export class User extends BaseEntity {  @PrimaryGeneratedColumn()  id: number;

  @Column()  name: string;

  @Column()  email: string;}

async function main() {  await createConnection({    type: "postgres",    host: "localhost",    port: 5432,    username: "test",    password: "test",    database: "test",    entities: [User],    synchronize: true,  });

  const user = new User();  user.name = "Ivan";  user.email = "ivan@example.com";  await user.save();

  const users = await User.find();  console.log(users);}

Vorteile: große Community, viele Tutorials, Unterstützung von MongoDB. Nachteile: komplexe Konfiguration, Probleme mit Lazy Loading, manchmal unintuitive API.

2. Prisma

Prisma ist ein modernes ORM, das den Ansatz für die Arbeit mit Datenbanken neu definiert. Anstelle eines traditionellen ORMs bietet es drei Komponenten: Prisma Client (ein automatisch generierter typsicherer Client), Prisma Migrate (ein Migrationssystem) und Prisma Studio (eine grafische Oberfläche).

Besonderheiten von Prisma:

Deklaratives Datenschema (schema.prisma)
Vollständige Typisierung basierend auf dem Schema – keine manuellen Typen
Automatische Client-Generierung
Unterstützung von Transaktionen und Paginierung
Integration mit GraphQL (Nexus, TypeGraphQL)

Codebeispiel mit Prisma:

// schema.prismamodel User {  id    Int     @id @default(autoincrement())  name  String  email String  @unique  posts Post[]}

model Post {  id        Int     @id @default(autoincrement())  title     String  content   String?  authorId  Int  author    User    @relation(fields: [authorId], references: [id])}

// main.tsimport { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {  const user = await prisma.user.create({    data: {      name: 'Maria',      email: 'maria@example.com',      posts: {        create: { title: 'Mein erster Beitrag' }      }    },    include: { posts: true }  });

  const users = await prisma.user.findMany({    include: { posts: true }  });  console.log(users);}

main()  .catch(e => console.error(e))  .finally(() => prisma.$disconnect());

Vorteile: beste Typisierung in ihrer Klasse, einfache Syntax, hervorragende Dokumentation. Nachteile: Abhängigkeit vom Schema, Komplexität bei benutzerdefinierten Abfragen, höherer Speicherverbrauch.