Prisma für JavaScript (Node.js): Komplettguide mit Beispielen

Prisma ist ein moderner ORM (Object-Relational Mapping) für Node.js und TypeScript, der die Arbeit mit Datenbanken grundlegend verändert. Im Gegensatz zu traditionellen ORMs bietet Prisma ein deklaratives Datenmodell, automatische Generierung eines typsicheren Clients und ein leistungsstarkes Tool für Migrationen. Wenn Sie es leid sind, SQL-Abfragen manuell zu schreiben, sich mit Datentypen herumzuschlagen oder komplexe ORM-Konfigurationen zu erstellen, wird Prisma Ihre Rettung sein.

Warum Prisma verwenden? Erstens bietet es Typsicherheit auf Datenbankebene. Das bedeutet, dass Fehler durch falsche Feldtypen oder fehlende Beziehungen bereits zur Kompilierzeit erkannt werden, nicht erst zur Laufzeit. Zweitens stellt Prisma eine intuitive API für CRUD-Operationen, Filterung, Sortierung und Datenaggregation bereit. Drittens generiert es automatisch eine Dokumentation Ihres Datenschemas und ermöglicht eine einfache Verwaltung von Schemaänderungen durch Migrationen.

Prisma unterstützt die wichtigsten relationalen Datenbanken: PostgreSQL, MySQL, SQLite, SQL Server und MongoDB (im Document-Modus). Dank seiner Architektur eignet es sich sowohl für kleine Projekte als auch für Enterprise-Anwendungen. In diesem Artikel gehen wir detailliert auf die Installation, die wichtigsten Methoden und praktische Beispiele für die Verwendung von Prisma in der Node.js-Umgebung ein.

Installation

Die Installation von Prisma erfolgt in zwei Schritten: Installation der CLI (Command Line Interface) und Initialisierung des Projekts. Führen Sie die folgenden Befehle im Terminal Ihres Projekts aus:

npm install prisma --save-dev
npm install @prisma/client

Initialisieren Sie Prisma nach der Installation im Projekt:

npx prisma init

Dieser Befehl erstellt ein Verzeichnis prisma mit der Datei schema.prisma und eine Datei .env für Umgebungsvariablen. Geben Sie in der .env-Datei die Verbindungszeichenfolge zu Ihrer Datenbank an. Für PostgreSQL zum Beispiel:

DATABASE_URL="postgresql://benutzer:passwort@localhost:5432/mydb"

Für MySQL:

DATABASE_URL="mysql://benutzer:passwort@localhost:3306/mydb"

Für SQLite (dateibasierte Datenbank):

DATABASE_URL="file:./dev.db"

Schnellstart: Minimales Arbeitsbeispiel

Erstellen wir ein einfaches Benutzermodell und führen grundlegende Operationen durch. Bearbeiten Sie die Datei prisma/schema.prisma:

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite" // oder "postgresql", "mysql"
  url      = env("DATABASE_URL")
}

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

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

Führen Sie nun die Migration aus, um die Tabellen in der Datenbank zu erstellen:

npx prisma migrate dev --name init

Generieren Sie nach erfolgreicher Migration den Prisma Client:

npx prisma generate

Erstellen Sie nun eine Datei index.js und schreiben Sie ein einfaches Skript:

// index.js
const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

async function main() {
  // Neuen Benutzer erstellen
  const user = await prisma.user.create({
    data: {
      email: 'alice@example.com',
      name: 'Alice',
    },
  });
  console.log('Benutzer erstellt:', user);

  // Beitrag für den Benutzer erstellen
  const post = await prisma.post.create({
    data: {
      title: 'Mein erster Beitrag',
      content: 'Das ist der Inhalt meines ersten Beitrags.',
      authorId: user.id,
    },
  });
  console.log('Beitrag erstellt:', post);

  // Alle Benutzer mit ihren Beiträgen abrufen
  const usersWithPosts = await prisma.user.findMany({
    include: { posts: true },
  });
  console.log('Benutzer mit Beiträgen:', JSON.stringify(usersWithPosts, null, 2));
}

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

Führen Sie das Skript aus:

node index.js

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Benutzer erstellt: { id: 1, email: 'alice@example.com', name: 'Alice' }
Beitrag erstellt: { id: 1, title: 'Mein erster Beitrag', content: 'Das ist der Inhalt meines ersten Beitrags.', published: false, authorId: 1 }
Benutzer mit Beiträgen: [
  {
    "id": 1,
    "email": "alice@example.com",
    "name": "Alice",
    "posts": [
      {
        "id": 1,
        "title": "Mein erster Beitrag",
        "content": "Das ist der Inhalt meines ersten Beitrags.",
        "published": false,
        "authorId": 1
      }
    ]
  }
]

Herzlichen Glückwunsch! Sie haben gerade Ihre erste Prisma-Anwendung erstellt. Wie Sie sehen, ist der Code sauber, typsicher und leicht verständlich. Im nächsten Abschnitt werden wir die wichtigsten Methoden von Prisma im Detail behandeln.

Wichtige Methoden von Prisma Client

Prisma Client bietet eine Vielzahl von Methoden für die Datenbankinteraktion. Hier sind die wichtigsten:

create – Datensätze erstellen

Erstellt einen neuen Datensatz in der Datenbank:

const newUser = await prisma.user.create({
  data: {
    email: 'max@example.com',
    name: 'Max Mustermann',
  },
});

findMany – Mehrere Datensätze abrufen

Ruft mehrere Datensätze ab, optional mit Filtern:

const users = await prisma.user.findMany({
  where: { name: { contains: 'Max' } },
  orderBy: { id: 'desc' },
  take: 10,
});

findUnique – Einen einzelnen Datensatz abrufen

Ruft einen einzelnen Datensatz anhand eines eindeutigen Feldes ab:

const user = await prisma.user.findUnique({
  where: { email: 'max@example.com' },
});

update – Datensätze aktualisieren

Aktualisiert einen oder mehrere Datensätze:

const updatedUser = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'Max Müller' },
});

delete – Datensätze löschen

Löscht einen Datensatz:

const deletedUser = await prisma.user.delete({
  where: { id: 1 },
});

upsert – Erstellen oder Aktualisieren

Erstellt einen Datensatz, falls er nicht existiert, oder aktualisiert ihn:

const upsertedUser = await prisma.user.upsert({
  where: { email: 'max@example.com' },
  update: { name: 'Max Müller' },
  create: { email: 'max@example.com', name: 'Max Mustermann' },
});

Erweiterte Abfragen mit Prisma

Prisma unterstützt auch komplexe Abfragen wie Aggregationen, Transaktionen und Raw Queries. Hier ein Beispiel für eine Aggregation:

const aggregation = await prisma.post.aggregate({
  _count: { id: true },
  _avg: { authorId: true },
  where: { published: true },
});
console.log(`Anzahl veröffentlichter Beiträge: ${aggregation._count.id}`);

Fazit

Prisma ist ein leistungsstarker und benutzerfreundlicher ORM für Node.js, der die Produktivität von Entwicklern erheblich steigert. Mit seiner Typsicherheit, der intuitiven API und den automatischen Migrationen ist es die ideale Wahl für moderne Webanwendungen. Probieren Sie es in Ihrem nächsten Projekt aus – Sie werden den Unterschied merken!