ORM für TypeScript: Vergleich und Beispiele

ORM für TypeScript: Vergleich und Anwendungsbeispiele

In der modernen TypeScript-Entwicklung ist die Wahl des richtigen ORM (Object-Relational Mapping) eine grundlegende Entscheidung, die sich auf Leistung, Lesbarkeit des Codes und Entwicklungsgeschwindigkeit auswirkt. In diesem Artikel vergleichen wir die drei beliebtesten ORMs für TypeScript im Detail: Prisma, TypeORM und MikroORM. Sie erfahren ihre Stärken und Schwächen, sehen Codebeispiele und erhalten praktische Empfehlungen für Ihr Projekt.

1. Prisma – moderner Standard

Prisma ist ein ORM der nächsten Generation, das eine eigene deklarative Schemasprache verwendet. Es generiert automatisch einen typsicheren Client basierend auf Ihrem Datenbankschema. Prisma unterstützt PostgreSQL, MySQL, SQLite, SQL Server und MongoDB.

Vorteile:

Leistungsstarkes Typsystem – alle Abfragen werden zur Kompilierzeit geprüft
Integrierte Migrationen und visueller Editor Prisma Studio
Hervorragende Dokumentation und aktive Community
Autovervollständigung in der IDE

Nachteile:

Zusätzlicher Schritt der Client-Generierung
Weniger Flexibilität bei komplexen SQL-Abfragen
Relativ große Paketgröße

Codebeispiel:

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

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

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

const prisma = new PrismaClient();

async function main() {  // Benutzer mit Beitrag erstellen  const user = await prisma.user.create({    data: {      email: 'alice@example.com',      name: 'Alice',      posts: {        create: { title: 'Hello World' }      }    },    include: { posts: true }  });

  // Suche mit Filter  const users = await prisma.user.findMany({    where: { email: { contains: 'alice' } },    orderBy: { name: 'asc' }  });

  console.log(users);}

main();

2. TypeORM – bewährter Veteran

TypeORM ist eines der ältesten ORMs für TypeScript, inspiriert von Hibernate und Entity Framework. Es verwendet Dekorateure zur Definition von Entitäten und unterstützt die Active Record- und Data Mapper-Muster. Es funktioniert mit den meisten relationalen Datenbanken.

Vorteile:

Flexibles Dekoratorensystem
Unterstützung für Migrationen und Schema-Synchronisation
Große Anzahl an Integrationen und Erweiterungen
Ausgereiftes und zeitlich erprobtes Projekt

Nachteile:

Weniger strenge Typisierung im Vergleich zu Prisma
Komplexe Konfiguration für Anfänger
Langsame Entwicklung in letzter Zeit

Codebeispiel:

// entity/User.tsimport { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';import { Post } from './Post';

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

  @Column({ unique: true })  email: string;

  @Column({ nullable: true })  name: string;

  @OneToMany(() => Post, (post) => post.author)  posts: Post[];}

// app.tsimport { createConnection } from 'typeorm';import { User } from './entity/User';

async function main() {  const connection = await createConnection();  const userRepo = connection.getRepository(User);

  // Erstellen  const user = userRepo.create({    email: 'bob@example.com',    name: 'Bob'  });  await userRepo.save(user);

  // Suche  const users = await userRepo.find({    where: { name: Like('%Bob%') },    relations: ['posts']  });

  console.log(users);}

main();