Prisma Tutorial: Eine praktische Übung basierend auf Koa und PG

Vorwort

Prisma wird als das ORM-Tool (Object Relational Mapping) der nächsten Generation angesehen, das auf Basis von TypeScript entwickelt wurde und eine leistungsstarke Typsicherheit bietet. Dieser Artikel wird Koa.js verwenden, um einen einfachen Webdienst zu erstellen und ihn mit einer MySQL-Datenbank zu kombinieren, um zu demonstrieren, wie die Operationen zum Erstellen, Lesen, Aktualisieren und Löschen (CRUD) von Daten mit Prisma implementiert werden.

Überblick über Prisma

Prisma beansprucht, das ORM-Tool der nächsten Generation zu sein. Prisma ist ein Open-Source-Datenbank-Toolchain-Projekt, und seine Funktionen gehen weit über ein einfaches ORM hinaus. Es unterstützt mehrere Datenbanken wie PostgreSQL, MySQL, MongoDB, SQL Server und SQLite. Dieser Artikel verwendet MySQL als Beispiel zur Demonstration.

Bei der ersten Verwendung von Prisma ist der Prozess relativ umständlich und lässt sich grob in folgende Schritte unterteilen:

Abhängigkeiten installieren
Prisma-Projekt initialisieren
Prisma-Schema entwerfen (Datenbankinformationen und -modelle definieren)
Mit der Datenbank synchronisieren
Den Prisma-Client generieren
Den Prisma-Client verwenden, um CRUD-Operationen durchzuführen

Als Nächstes richten wir zunächst die Entwicklungsumgebung ein und stellen dann Prisma ausführlich vor.

Initialisieren der Umgebung

Erstellen eines Koa-Webdienstes

Erstellen Sie zunächst das Projektverzeichnis und installieren Sie die Abhängigkeiten:

mkdir koa-prisma
cd koa-prisma
pnpm init

# Koa-Abhängigkeiten installieren
pnpm add koa @koa/router koa-bodyparser

Unter anderem ist @koa/router eine Routing-Middleware, die die Integration von Routing-Funktionen erleichtert; koa-bodyparser wird verwendet, um die Daten des Anfrage-Bodys zu parsen und im Objekt ctx.request.body zu speichern.

Erstellen Sie dann eine neue Datei index.js und erstellen Sie einen einfachen Webdienst:

const Koa = require('koa')
const Router = require('@koa/router')
const bodyParser = require('koa-bodyparser')

const app = new Koa()

// Den Router instanziieren und das übliche Routenpräfix auf /users setzen
const router = new Router({
  prefix: '/users'
})

app.use(bodyParser())

// Die Benutzerliste abfragen
router.get('/', async ctx => {

})

// Einen einzelnen Benutzer abfragen
router.get('/:id', async ctx => {

})

// Einen Benutzer erstellen
router.post('/', async ctx => {

})

// Einen Benutzer aktualisieren
router.patch('/:id', async ctx => {

})

// Einen Benutzer löschen
router.delete('/:id', async ctx => {

})

// Die Routing-Middleware registrieren
app.use(router.routes()).use(router.allowedMethods())

app.listen(3000, () => {
  console.log('Der Server läuft auf Port 3000')
})

Der obige Code definiert fünf Routing-Methoden, die den Datenbankoperationen zum Abfragen, Einfügen, Aktualisieren und Löschen entsprechen. Nach Abschluss der Prisma-Initialisierung und der späteren Einführung des Prisma-Clients können diese Schnittstellen implementiert werden.

Verwenden Sie den Befehl nodemon, um den Dienst zu starten. Es wird empfohlen, dieses Modul global zu installieren:

nodemon src/index.js

Prisma-CLI

Installieren der Prisma-Abhängigkeiten

Installieren Sie zunächst die beiden Abhängigkeitsmodule von Prisma:

pnpm add -D prisma 
pnpm add @prisma/client

Unter anderem ist prisma ein CLI-Befehl, der zum Aufrufen verschiedener Funktionen von Prisma verwendet wird, z. B. Datenbankmigration, Erstellung des Prisma-Clients usw. Führen Sie den folgenden Befehl aus, um die Gebrauchsanweisung von prisma anzuzeigen:

npx prisma --help

prisma bietet sieben Befehle:

Befehl	Beschreibung
init	Prisma in der Anwendung initialisieren
generate	Wird hauptsächlich verwendet, um den Prisma-Client zu generieren
db	Das Schema und den Lebenszyklus der Datenbank verwalten
migrate	Die Datenbank migrieren
studio	Eine webbasierte Workbench zum Verwalten von Daten starten
validate	Überprüfen, ob die Syntax der Prisma-Schemadatei korrekt ist
format	Die Prisma-Schemadatei formatieren, die standardmäßig `prisma/schema.prisma` ist

Dieser Artikel verwendet hauptsächlich drei dieser Befehle, und Sie können die verbleibenden Befehle selbst erkunden.

Initialisieren von Prisma

Führen Sie den folgenden Befehl aus, um die Initialisierung abzuschließen:

npx prisma init

Dieser Befehl erstellt eine Datei .env und ein Verzeichnis prisma im aktuellen Verzeichnis und erstellt eine Datei schema.prisma im Verzeichnis prisma.

Die Datei .env wird verwendet, um Umgebungsvariablen zu speichern und enthält normalerweise einige Konfigurationsinformationen. Das Verzeichnis prisma wird zum Speichern von Dateien verwendet, die sich auf Prisma beziehen. Derzeit gibt es nur die Datei schema.prisma. Diese Datei ist die Prisma-Schemadatei, die zum Definieren der Datenbankverbindungsinformationen und -modelle verwendet wird.

Entwerfen des Prisma-Schemas

Installieren des VSC-Plugins

Vor dem Bearbeiten der Schemadatei wird empfohlen, das Prisma-Plugin in VS Code zu installieren. Dieses Plugin bietet Funktionen wie Codehervorhebung, Formatierung, automatische Vervollständigung, Sprung zur Definition und Überprüfung von .prisma-Dateien, was das Entwicklungserlebnis erheblich verbessert.

Einstellen des Generators

Verwenden Sie generate, um den Generator zu definieren, und deklarieren Sie ihn über die Eigenschaft provider als prisma-client-js (derzeit wird nur dieser unterstützt). Wenn der Befehl prisma generate ausgeführt wird, wird der Prisma-Client generiert, der zum Ausführen der CRUD-Operationen von Daten verwendet wird:

generator client {
  provider = "prisma-client-js"
}

Einstellen der Datenquelle

Verwenden Sie datasource, um die Datenquelle zu definieren und die Informationen festzulegen, die Prisma benötigt, um sich mit der Datenbank zu verbinden. Der provider gibt den Typ der verbundenen Datenbank an, der standardmäßig postgresql ist. Wir werden ihn in mysql ändern. Die url gibt die Datenbank-URL an. Um die Konfiguration getrennt zu halten, wird sie normalerweise in der Datei .env definiert und über die Funktion env() gelesen:

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

Die Datenbankverbindung in der Standarddatei .env ist für Postgresql:

DATABASE_URL=postgresql://johndoe:mypassword@localhost:5432/mydb?schema=public

Die MySQL-Datenbankverbindungs-URL besteht aus den folgenden erforderlichen Elementen:

Name	Platzhalter	Beschreibung
Host	HOST	Die IP-Adresse oder der Domänenname der Datenbank, z. B. localhost
Port	PORT	Der Datenbankport, z. B. 3306
User	USER	Der Datenbankbenutzername, z. B. root
Password	PASSWORD	Das Datenbankpasswort
Database	DATABASE	Der Datenbankname, z. B. mydb

Definieren Sie die MySQL-URL gemäß den obigen Regeln:

DATABASE_URL="postgresql://leapcell:leapcell123@localhost:9006/prisma"

Definieren des Benutzermodells

Als ORM-Tool haben die Modelle in Prisma die folgenden Funktionen:

Bilden die Entitäten der Anwendungsdomäne
Ordnen Tabellen der Datenbank zu (relationale Datenbanken wie PostgreSQL) oder Sammlungen (MongoDB)
Bilden die Grundlage der Abfragen in der Prisma-Client-API
In TypeScript bietet der Prisma-Client Typdefinitionen für die Modelle und ihre Varianten, um die Typsicherheit des Datenbankzugriffs zu gewährleisten

Beim Definieren eines Modells werden die integrierten Hilfsfunktionen von Prisma wie @id() und @default() verwendet. Beispielsweise wird @id() verwendet, um den Primärschlüssel zu deklarieren, und @default() wird verwendet, um den Standardwert festzulegen. Es folgt die Definition eines Benutzermodells:

model User {
  id          Int         @id @default(autoincrement())
  name        String
  email       String      @unique
  password    String
  createdTime DateTime    @default(now()) @map("created_time")
  updatedTime DateTime    @updatedAt @map("updated_time")

  @@map("user")
}

Folgendes ist zu beachten:

Der Modellname ist standardmäßig der Name der erstellten Datentabelle. Hier ist der Modellname User, und der Tabellenname kann über @@map("user") auf das Kleinbuchstaben user gesetzt werden.
Jedes Modell muss einen Primärschlüssel haben, der mit @id deklariert wird.
Prisma konvertiert die Feldtypen (z. B. Int, String) in die entsprechenden Typen der Datenbank (z. B. int und varchar).
@unique gibt eine eindeutige Wertebeschränkung an, und der Wert des Felds email in der Tabelle user darf nicht wiederholt werden.
Um den Namenskonventionen von JS, TS und der Datenbank zu entsprechen, verwenden Sie @map(), um die Benennung der Erstellungszeit und Aktualisierungszeit zuzuordnen.

Synchronisieren der Datenbank

Bei einem neuen Projekt können Sie den folgenden Befehl verwenden, um das Prisma-Modell mit der Datenbank zu synchronisieren:

npx prisma db push

Wenn das Projekt bereits Daten enthält, sollte prisma migrate für die Migration verwendet werden, was in diesem Artikel nicht behandelt wird.

Der Befehl prisma db push erstellt das Schema der Datenbank, synchronisiert die Datenbank mit dem Prisma-Schema und führt automatisch den Befehl prisma generate aus, um den Prisma-Client zu generieren.

Generieren des Prisma-Clients

Der Befehl prisma generate wurde bei der Synchronisierung der Datenbank ausgeführt. Wenn sich die Prisma-Schemadatei später ändert, z. B. durch Ändern des Modells, muss dieser Befehl erneut ausgeführt werden, um den Prisma-Client neu zu generieren.

CRUD-Operationen

Initialisieren des Prisma-Clients

Mit dem Prisma-Client können CRUD-Operationen ausgeführt werden. Der Initialisierungscode lautet wie folgt:

const { PrismaClient } = require('@prisma/client')

const prisma = new PrismaClient()

Die Prisma-Client-Instanz prisma hat umfangreiche Typen, und die Verwendung ist prisma.model.CRUD-Methode. Zu den häufig verwendeten APIs gehören:

findMany: Mehrere Datensätze abfragen
findUnique: Einen einzelnen Datensatz abfragen
create: Einen Datensatz erstellen
update: Einen Datensatz aktualisieren
delete: Einen Datensatz löschen

Verwenden der API zur Vervollständigung der Schnittstellenentwicklung

Abfragen der Benutzerliste

Wenn keine Parameter an findMany übergeben werden, werden alle Datensätze in der gesamten Tabelle user abgefragt und ein Array von User-Modellinstanzen zurückgegeben:

router.get('/', async ctx => {
  const users = await prisma.user.findMany()

  ctx.body = users
})

Abfragen eines einzelnen Benutzers

Legen Sie die Abfragebedingungen über where in der Methode findUnique fest und fragen Sie einen Benutzerdatensatz anhand der angegebenen ID ab, wobei eine User-Modellinstanz zurückgegeben wird:

// Einen einzelnen Benutzer abfragen
router.get('/:id', async ctx => {
  const id = parseInt(ctx.params.id)
  const user = await prisma.user.findUnique({
    where: { id }
  })

  ctx.body = user
})

Es ist zu beachten, dass die von ctx.params.id abgerufene ID vom Typ String ist und vor der Abfrage in den Integer-Typ konvertiert werden muss.

Erstellen eines Benutzers

Verwenden Sie die Methode create, um Daten einzufügen, und weisen Sie die aus dem Anfragetext geparsten Daten (ein Objekt, das das User-Modell beschreibt) der Eigenschaft data zu:

router.post('/', async ctx => {
  const user = ctx.request.body
  const newUser = await prisma.user.create({
    data: user
  })

  ctx.body = newUser
})

Aktualisieren eines Benutzers

Verwenden Sie die Methode update, legen Sie die Abfragebedingungen über where fest und weisen Sie nach dem Abfragen des Zielbenutzers die zu aktualisierenden Daten data zu:

router.patch('/:id', async ctx => {
  const id = parseInt(ctx.params.id)
  const updateUser = ctx.request.body

  const user = await prisma.user.update({
    where: {
      id
    },
    data: updateUser
  })

  ctx.body = user
})

Löschen eines Benutzers

Verwenden Sie die Methode delete und legen Sie die Abfragebedingungen für die zu löschenden Datensätze über where fest:

router.delete('/:id', async ctx => {
  const id = parseInt(ctx.params.id)
  const user = await prisma.user.delete({
    where: {
      id
    }
  })

  ctx.body = user
})

Bei Verwendung der Methoden update und delete müssen Sie die Bedingung where festlegen. Andernfalls werden alle Datensätze in der Datentabelle aktualisiert oder gelöscht, was riskant ist.

Schlussfolgerung

Dieser Artikel demonstriert die grundlegende Verwendung von Prisma in einem Koa-Projekt anhand eines Beispiels zum Erstellen, Lesen, Aktualisieren und Löschen von Benutzern. Der gesamte Prozess lässt sich wie folgt zusammenfassen: