So verwenden Sie SQL-Datenbanken in einer NestJS-Anwendung mit TypeORM

Ein objektrelationaler Mapper (ORM) ist eine Bibliothek, die die objektrelationale Mapping-Technik implementiert. Auf diese Weise können Sie SQL-Datenbankabfragen unter Verwendung des objektorientierten Paradigmas Ihrer bevorzugten Sprache schreiben.

TypeORM ist ein TypeScript-ORM, das die Anbindung an verschiedene Datenbanken sehr einfach macht. Es funktioniert mit SQL-Datenbanken, lässt sich aber auch gut mit NoSQL-Datenbanken wie MongoDB verbinden.

NestJS bietet standardmäßig High-Level-Support für TypeORM. Das dedizierte TypeORM-Paket macht die Integration relativ einfach.

Schritt 1: Installieren von Abhängigkeiten

Bevor Sie TypeORM in einer NestJS-Anwendung verwenden, müssen Sie es mit seinem nativen NestJS-Paket und Ihrer bevorzugten SQL-Datenbank installieren. SQLite ist eine einfache Option ohne Installation.

Führen Sie den folgenden Befehl aus, um TypeORM und sein natives NestJS-Paket zu installieren der npm-Paketmanager:

npm installieren @nestjs/typeorm typeorm

Führen Sie den folgenden Befehl aus, um SQLite zu installieren:

npm Installieren sqlite3

Schritt 2: Erstellen einer Entität

Eine Entität ist eine Sammlung von Feldern, die die in einer Datenbank gespeicherten Daten definieren. TypeORM verwendet die Entitätsdatei, um eine Tabelle in Ihrer Datenbank zu erstellen.

Führen Sie die folgenden Schritte aus, um eine Entität zu erstellen:

1. Erstellen Sie eine Datei in Ihrem Anwendungsmodul und benennen Sie sie gemäß der NestJS-Namenskonvention (.entity.ts).
2. Importieren Sie in Ihrer Entitätsdatei die Einheit, Spalte, und PrimaryGeneratedColumn Dekorateure aus Typform.
3. Erstellen und exportieren Sie in Ihrer Entitätsdatei eine Klasse.
4. Füllen Sie die Klasse mit den Werten, die Sie in Ihrer Datenbank haben möchten, wie z Ich würde, Name, etc.
5. Kommentieren Sie Ihre Entitätsklasse mit dem Entity-Decorator. Dadurch wird Ihre Klasse für TypeORM als Einheit erkennbar.
6. Kommentieren Sie Ihre ID-Eigenschaft mit dem PrimaryGeneratedColumn-Decorator. Dies weist TypeORM an, die zu markieren Ich würde als Primärschlüssel und automatisch inkrementieren.
7. Beschriften Sie die verbleibenden Eigenschaften mit dem Column-Decorator. Dadurch werden sie als Spalten in Ihrer Datenbank hinzugefügt.

Zum Beispiel:

// src/test/test.entity.ts
importieren { Entität, Spalte, PrimaryGeneratedColumn } aus 'Typform';
@Einheit()
ExportKlassePrüfen{
@PrimaryGeneratedColumn()
 ID: Nummer;
@Spalte()
 Eigenschaft_1: Zeichenkette;
@Spalte()
 Eigenschaft_2: Zeichenkette;
@Spalte()
 Eigenschaft_3: Zeichenkette;
}

Die obige Entitätsdatei erstellt diese Tabelle in Ihrer Datenbank:

Das TypORM-Dokumentation deckt Entitäten detaillierter ab.

Schritt 3: Verbinden Sie Ihre Anwendung mit einer Datenbank

Nachdem Ihre Entität eingerichtet ist, müssen Sie Ihre Anwendung mit einer Datenbank verbinden. Dieses Beispiel verwendet SQLite.

Führen Sie die folgenden Schritte aus, um Ihre Anwendung mit einer Datenbank zu verbinden:

1. Im Stammmodul Ihrer Anwendung (normalerweise die app.module.ts Datei), importieren TypeOrmModule aus @nestjs/typeorm.
2. Importieren Sie in derselben Datei alle Ihre Entitäten.
3. In dem Importe Array, nennen Sie die fürRoot Methode auf TypeOrmModule. Die forRoot-Methode teilt die Datenbankverbindung mit allen Modulen in Ihrer Anwendung.
4. Übergeben Sie ein leeres Objekt als Argument an die forRoot-Methode; Dies ist das TypeORM-Konfigurationsobjekt.
5. Eigenschaft hinzufügen, Typ, zum Konfigurationsobjekt und setzen Sie es auf „sqlite“. Die Type-Eigenschaft gibt den Namen der Datenbank an, die Sie verwenden.
6. Fügen Sie eine weitere Eigenschaft hinzu, Datenbank, zum Konfigurationsobjekt und setzen Sie es auf „test.db“. Die Datenbank-Eigenschaft gibt Ihren bevorzugten Namen für Ihre Datenbank an.
7. Fügen Sie eine weitere Eigenschaft hinzu, Entitäten, zum Konfigurationsobjekt und setzen Sie es auf ein leeres Array. Füllen Sie das leere Array mit den zuvor importierten Entitäten.
8. Fügen Sie eine weitere Eigenschaft hinzu, synchronisieren, und stellen Sie es ein Stimmt; Diese Eigenschaft synchronisiert Ihre Entitäten mit Ihrer Datenbank und aktualisiert sie jedes Mal, wenn Sie den Code ausführen. Sie sollten diese Eigenschaft nur auf festlegen Stimmt in Entwicklung. Während der Produktion sollten Sie es auf einstellen FALSCH um Datenverlust zu vermeiden.

// src/app.module.ts
importieren { Modul } aus '@nestjs/common';
importieren { TypeOrmModul } aus '@nestjs/typeorm';
importieren { Prüfen } aus './test/test.entität';
importieren { Entität2 } aus './entität/entität.entität';
importieren { Testmodul } aus './test/test.modul';
@Modul({
 Importe: [
TypeOrmModule.fürRoot({
 Typ: 'sqlite',
 Datenbank: 'test.db',
Entitäten: [Test, Entität2],
 synchronisieren: Stimmt, // nur Entwicklung
 }),
 Testmodul,
 ],
Controller: [],
Anbieter: [],
})
ExportKlasseAppModul{}

Schritt 4: Erstellen eines Repositorys

Ein Repository ist die Zugriffsebene einer Entität, die verwendet wird, um Abfragen (Einfügen, Löschen, Speichern, Suchen usw.) für eine Tabelle durchzuführen, die von der Entität in der Datenbank erstellt wurde. TypeORM unterstützt das Repository-Entwurfsmuster, daher hat jede Entität ihr eigenes Repository.

TypeORM erstellt automatisch ein Repository für Ihre Entität, wenn Sie die folgenden Schritte ausführen:

1. Importieren Sie in der Moduldatei Ihrer Entität TypeOrmModule aus @nestjs/typeorm und importieren Sie Ihre Entität.
2. Erstelle ein Importe Array in der @Modul Dekorateur.
3. Rufen Sie im Array imports die fürFeature Methode auf TypeOrmModule.
4. Übergeben Sie ein Array als Argument an Ihr und füllen Sie das Array mit Ihrer Entität.

// src/test/test.module.ts
importieren { Modul } aus '@nestjs/common';
importieren { TypeOrmModul } aus '@nestjs/typeorm';
importieren {TestController} aus './test.controller';
importieren { TestService } aus './test.service';
importieren { Prüfen } aus './test.entität';
@Modul({
Importe: [TypeOrmModule.forFeature([Test])],
Anbieter: [TestService],
Controller: [TestController],
})

Schritt 5: Einfügen Ihres Repositorys in seinen Dienst mithilfe von Dependency Injection

Dependency Injection ist eine Software-Engineering-Technik, die eine Form der Umkehrung des Kontrollprinzips darstellt. Es verlagert die Last der Abhängigkeitsverwaltung vom Clientcode auf die Bibliothek oder den Dienst, von dem es abhängt.

Führen Sie die folgenden Schritte aus, um Ihr Repository in einen Dienst einzufügen:

1. Importieren Sie in Ihrer Servicedatei Repository aus Typform und die InjectRepository Dekorateur aus @nestjs/typeorm. Importieren Sie auch die Entität, deren Repository Sie injizieren möchten.
2. Erstellen Sie in Ihrer Serviceklasse eine Konstrukteur.
3. Erklären Sie a Privatgelände Variable, Repo, als Parameter im Konstruktor, um ihn zu initialisieren.
4. Weisen Sie dem Repository einen Repository-Typ mit einem generischen Typ Ihrer Entität zu.
5. Kommentieren Sie das Repo mit dem InjectRepository-Decorator und übergeben Sie Ihre Entität als Argument.

// test.service.ts
importieren {Injizierbar} aus '@nestjs/common';
importieren { Repository } aus 'Typform';
importieren { InjectRepository } aus '@nestjs/typeorm';
importieren { Prüfen } aus './test.entität';
@ Injizierbar()
ExportKlasseTestService{
Konstrukteur(
@InjectRepository(Prüfen)
 privates Repository: Repository<Prüfen>,
 ) {}
}

Jetzt, da Ihre Einrichtung abgeschlossen ist, können Sie machen SQL-Abfragen darauf, um Daten abzurufen oder zu ändern.

Erstellen von SQL-Abfragen mit TypeORM

Sie können jede einfache SQL-Abfrage erstellen, indem Sie die Repository-Methoden von TypeORM auf der Repo Variable innerhalb Ihrer Serviceklasse. Sie können auch komplexe SQL-Abfragen erstellen, indem Sie den Abfragegenerator von TypeORM verwenden.