Next.js 14 - Mehrere Verbindungen innerhalb eines Projekts mit Prisma ORM

In meinen letzten Projekten musste ich eine DB-Verbindung zu mehr als einer Postgres-DB herstellen. Da ich den ORM Prisma verwendete, stand ich vor der Herausforderung, diese mehreren Verbindungen innerhalb des Prisma-Kontextes zu verwalten. In diesem Beitrag zeige ich Ihnen, wie Sie dies mit einigen einfachen Schritten erreichen können.

Prisma NPM Pakete

Der prisma/client und das prisma-Paket sind ausreichend.

    "@prisma/client": "^5.14.0",
    "prisma": "^5.14.0",

Nachdem Sie eine Standardinstallation durchgeführt haben, sollten Sie diesen Befehl ausführen:

npx prisma init

Dadurch wird ein neues prisma-Verzeichnis mit einer schema.prisma-Datei erstellt. Jetzt können Sie Ihre Daten modellieren und Ihre Datenbank mit einigen Tabellen erstellen.

Modellieren Sie Ihr Prisma-Schema für Postegres

Da ich die Postgres-DBs von Neon.tech verwende, kopiere ich den Datenbank-Url von meinem Neon.tech-Backend in meine .env.local.

# .env.local
DATABASE_URL="postgresql://xxxxxxxx/dbname/?sslmode=require"

Jetzt ist es Zeit für die Schemadatei, die Sie unter /projectroot/prisma/ mit dem Namen schema.prisma finden können

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider      = "prisma-client-js"
  binaryTargets = ["native", "debian-openssl-1.1.x"]
  output        = "./generated/client"
}

datasource db {
  provider     = "postgresql"
  url          = env("DATABASE_URL")
  relationMode = "prisma"
}

model logins {
  id        Int      @id @default(autoincrement())
  email     String
  name      String
  logins    Int
  objectId  String?
  lastLogin DateTime @default(now())
}

Binäre Ziele im Generator-Client Abschnitt

Prisma Client JS (prisma-client-js) verwendet mehrere Engines. Die Engines sind in Rust implementiert und werden von Prisma Client in Form von ausführbaren, plattformabhängigen Engine-Dateien verwendet. Je nachdem, auf welcher Plattform Sie Ihren Code ausführen, benötigen Sie die richtige Datei. „Binäre Ziele“ werden verwendet, um zu definieren, welche Dateien für die Zielplattform(n) vorhanden sein sollten. Zum Beispiel debian-openssl-1.1.x, wenn Sie auf Ubuntu 18+ deployen, oder native, wenn Sie lokal arbeiten.

Output

Legt fest, wo der generierte Client in Ihrem Dateisystem gespeichert wird.

Provider (Datenquelle)

Eine Datenquelle bestimmt, wie Prisma ORM Ihre Datenbank verbindet, und wird durch den Datenquellenblock im Prisma-Schema dargestellt. Wir verwenden die Datenquelle - provider postgresql

Relationmode

Die Möglichkeit, den Beziehungsmodus festzulegen, wurde als Teil der referentialIntegrity-Vorschaufunktion in Prisma ORM Version 3.1.1 eingeführt und ist generell in Prisma ORM Versionen 4.8.0 und später verfügbar. Das relationMode-Feld wurde in Prisma ORM Version 4.5.0 umbenannt und hieß vorher referentialIntegrity.

Für relationale Datenbanken sind folgende Optionen verfügbar:

• foreignKeys: Dies behandelt Beziehungen in der Datenbank mit Fremdschlüsseln. Dies ist die Standardoption für alle relationalen Datenbankkonnektoren und ist aktiv, wenn kein relationMode im Datenquellenblock explizit eingestellt ist.

• prisma: emuliert die Beziehungen im Prisma-Client. Sie sollten diese Option auch aktivieren wenn Sie den MySQL-Konnektor mit einer PlanetScale-Datenbank verwenden und in Ihren PlanetScale-Datenbankeinstellungen keine nativen Fremdschlüssel-Beschränkungen aktiviert haben.

Generation Prisma Client

Mit dem folgenden Befehl erzeugen Sie den Prisma-Client und speichern ihn in dem in der Datei schema.prisma angegebenen Ausgabeverzeichnis.

npx prisma generate

Hinzufügen des Pfads zum Schema

npx prisma generate --schema=prisma/schema.prisma

Mehrere Schema Dateien

Wenn wir den Pfad zur Schemadatei hinzufügen, können wir mehrere Prisma-Clients erzeugen. Wenn wir eine zweite Datei „second_schema.prisma“ im Basisverzeichnis /prisma erstellen, können wir mit diesem Befehl einen zweiten Prisma-Client für eine andere DB erstellen.

npx prisma generate --schema=prisma/second_schema.prisma

Definition der Env Variable -> DATABASE_URL_SECOND

# .env.local

DATABASE_URL="postgresql://xxxxxxxx/dbname/?sslmode=require"
DATABASE_URL_SECOND="postgresql://xxxxxxxx/dbname?sslmode=require"generator 

client {
  provider      = "prisma-client-js"
  binaryTargets = ["native", "debian-openssl-1.1.x"]
  output        = "./generated/client_second"
}

datasource db {
  provider     = "postgresql"
  url          = env("DATABASE_URL_SECOND")
  relationMode = "prisma"
}

model roles {
  id      Int      @id @default(autoincrement())
  name    String
  addedOn DateTime @default(now())
}

Verbindungsdatei Prisma.ts und Prisma_second.ts

Der folgende Code richtet eine Singleton-Instanz des Prisma-Clients ein, um Datenbankverbindungen zu verwalten. Lassen Sie uns den Zweck jedes Teils aufschlüsseln:

import { PrismaClient } from "../../prisma/generated/client";

const prismaClientSingleton = () => {
  return new PrismaClient();
};

type PrismaClientSingleton = ReturnType<typeof prismaClientSingleton>;

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClientSingleton | undefined;
};

const prisma = globalForPrisma.prisma ?? prismaClientSingleton();

export default prisma;

if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;

PrismaClient importieren:

import { PrismaClient } from "../../prisma/generated/client";

• Diese Zeile importiert die Klasse PrismaClient aus dem vom Prisma-Client generierten Code. Der Prisma-Client ist ein typsicherer Datenbank-Client, mit dem Sie mit Ihrer Datenbank interagieren können.

Erstellen einer Prisma-Client-Singleton-Funktion:

const prismaClientSingleton = () => {   return new PrismaClient(); };

• Diese Funktion, prismaClientSingleton, ist definiert, um eine neue Instanz von PrismaClient zu erstellen und zurückzugeben.

Definieren eines Typs für das Singleton:

type PrismaClientSingleton = ReturnType<typeof prismaClientSingleton>;

• Diese Zeile definiert einen TypeScript-Typ, PrismaClientSingleton, basierend auf dem Rückgabetyp der Funktion prismaClientSingleton. Dies wird verwendet, um Typsicherheit zu bieten.

Einrichten eines globalen Objekts zum Speichern des Singletons:

const globalForPrisma = globalThis as unknown as {   prisma: PrismaClientSingleton | undefined; };

Hier ist globalForPrisma eine typisierte Version von globalThis, um sicherzustellen, dass es eine Eigenschaft prisma hat, die entweder eine PrismaClientSingleton-Instanz oder undefiniert ist.

Erstellen oder Wiederverwenden der Prisma-Client-Instanz:

const prisma = globalForPrisma.prisma ?? prismaClientSingleton();

Diese Zeile prüft, ob globalForPrisma.prisma bereits eine Instanz von PrismaClient enthält. Wenn ja, wird diese Instanz verwendet; wenn nicht, wird mit prismaClientSingleton() eine neue Instanz erstellt.

Exportieren der Singleton-Instanz:

export default prisma;

Diese Zeile exportiert die prisma-Instanz, damit sie in der gesamten Anwendung verwendet werden kann.

Zuweisung der Instanz im Entwicklungsmodus:

if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;

In Nicht-Produktionsumgebungen (z. B. Entwicklungsumgebungen) weist diese Zeile die Prisma-Instanz der Datei globalForPrisma.prisma zu. Dadurch wird sichergestellt, dass dieselbe Prisma-Client-Instanz bei jedem Neuladen des Moduls wiederverwendet wird, wodurch die Erstellung mehrerer Instanzen vermieden wird, was zu Problemen mit der Datenbankverbindung führen kann. Der Code zielt darauf ab, eine Singleton-Instanz des Prisma-Clients zu erstellen, um Datenbankverbindungen effizient zu verwalten. Er stellt sicher, dass:

• Es wird nur eine Instanz von PrismaClient erstellt und in der gesamten Anwendung verwendet.

• Im Entwicklungsmodus wird die Instanz global gespeichert, um Probleme mit Hot-Reloading zu vermeiden, die zur Erstellung mehrerer Instanzen führen können.

Dieses Muster wird häufig verwendet, um Ressourcen wie Datenbankverbindungen in serverseitigen JavaScript-Anwendungen zu verwalten, insbesondere bei Verwendung von ORM-Tools wie Prisma.

Zweite Verbindungsdatei

Er importiert den zweiten Prisma-Client.

import { PrismaClient } from "../../prisma/generated/client_second";

// Lazy load PrismaClient and reuse the instance to avoid excessive connections
const prismaClientSingleton = () => {
  return new PrismaClient();
};

type PrismaClientSingleton = ReturnType<typeof prismaClientSingleton>;

const globalForPrismaSecond = globalThis as unknown as {
  prismaSecond: PrismaClientSingleton | undefined;
};

const prisma_second =
  globalForPrismaSecond.prismaSecond ??
  prismaClientSingleton();

if (process.env.NODE_ENV !== "production") {
  globalForPrismaSecond.prismaSecond = prisma_second;
}

export default prisma_second;

Import der Verbindungdateien (lib-Verzeichnis)

Wir sind bereit, die für die DB-Verbindung erstellten Dateien in unseren Komponenten oder API-Routen zu verwenden.

import prisma from "@/lib/prisma";

await prisma.logins.create({
      data: {
        email: test@test.it,
        name: testname,
        logins: 1,
        objectId: objectID_String,
      },
    });

or

import prisma_second from "@/lib/prisma_second";

    const Second = await prisma_second.roles.findFirst(
      {
        where: { name },
      }
    );

Ich hoffe, dass diese Geschichte hilfreich war und dass Sie nun mehrere DB-Verbindungen mit Prisma für dasselbe Projekt verwenden können.

Cloudapp-dev und bevor Sie uns verlassen

Danke, dass Sie bis zum Ende gelesen haben. Noch eine Bitte bevor Sie gehen:

Wenn Ihnen gefallen hat was Sie gelesen haben oder wenn es Ihnen sogar geholfen hat, dann würden wir uns über einen "Clap" 👏 oder einen neuen Follower auf unseren Medium Account sehr freuen.

Oder folgen Sie uns auf Twitter -> Cloudapp.dev