So erstellen Sie eine Nest.js CRUD REST API mit TypeORM und PostgreSQL

Wie andere Node.js-Frameworks bietet Nest.js ein umfassendes Toolkit zum Aufbau robuster und skalierbarer Backend-Dienste. Dennoch ist es wichtig zu verstehen, wie die Funktionen „Erstellen“, „Lesen“, „Aktualisieren“ und „Löschen“ implementiert werden (CRUD)-Vorgänge in Nest.js effizient durchführen – dies sind die grundlegendsten Vorgänge in der Entwicklung von APIs.

Erfahren Sie, wie Sie mit TypeORM und einer PostgreSQL-Datenbank eine Nest.js CRUD REST API erstellen.

Erste Schritte mit Nest.js

Installieren Sie zunächst das Nest.js-Befehlszeilentool:

npm i -g @nestjs/cli

Erstellen Sie als Nächstes ein neues Projekt, indem Sie Folgendes ausführen:

Nest neue Crud-App

Das CLI-Tool fordert Sie auf, einen Paketmanager auszuwählen und die Option auszuwählen, die Ihnen am besten gefällt. Wir werden verwenden npm, der Node-Paketmanager.

Die CLI erstellt ein Gerüst für ein grundlegendes Nest.js-Projekt mit allen erforderlichen Konfigurationsdateien und anfänglichen Abhängigkeiten, die zum Ausführen der Anwendung erforderlich sind.

Navigieren Sie abschließend zum Projektverzeichnis und starten Sie den Entwicklungsserver.

CD Crud-App
NPM-Laufstart

Den Code dieses Projekts finden Sie in seiner GitHub Repository.

Erstellen Sie eine PostgreSQL-Datenbank

Dieses Tutorial verwendet eine Cloud-PostgreSQL-Instanz, Sie können jedoch stattdessen eine lokale PostgreSQL-Datenbank einrichten. Du kannst Installieren Sie PostgreSQL unter Windows, auf macOS, oder unter Linux.

So richten Sie eine Cloud-PostgreSQL-Instanz ein:

1. Geh 'rüber zu ElephantSQL, registrieren Sie sich und melden Sie sich auf der Übersichtsseite Ihres Kontos an.
2. Drücke den Neue Instanz erstellen Klicken Sie oben links auf der Seite auf die Schaltfläche, um eine neue Instanz für Ihre Anwendung zu erstellen.
3. Geben Sie den Namen Ihrer Instanz ein, wählen Sie den kostenlosen Plan und schließlich die Region aus, um den Einrichtungsvorgang abzuschließen.
4. Gehen Sie nach dem Erstellen der Datenbankinstanz zu Einstellungen Seite und kopieren Sie die bereitgestellte Datei Datenbank-URL.

Konfigurieren Sie die Datenbankverbindung

Erstellen Sie im Stammverzeichnis Ihres Projekts eine .env Datei und fügen Sie die Datenbankverbindungs-URL wie folgt ein:

DATABASE_URL=""

Installieren Sie nun diese Pakete:

npm install pg typeorm @nestjs/typeorm @nestjs/config

Als Nächstes erstellen Sie mit dem CLI-Tool ein Datenbankmodul.

Nest G-Moduldatenbank

Öffne das Datenbank/Datenbank.module.ts Datei und fügen Sie den folgenden Datenbankkonfigurationscode hinzu:

importieren { Modul } aus'@nestjs/common';
importieren { ConfigModule, ConfigService } aus'@nestjs/config';
importieren { TypeOrmModule } aus'@nestjs/typeorm';
importieren { Benutzer } aus'../users/models/user.entity'; 
@Modul({
 Importe: [
 TypeOrmModule.forRootAsync({
 Importe: [ConfigModule], 
 inject: [ConfigService],
 useFactory: asynchron (configService: ConfigService) => ({
Typ: 'postgres',
 URL: configService.get('DATABASE_URL'), 
 Entitäten: [Benutzer],
 synchronisieren: WAHR
 }),
 }),
 ],
})
ExportKlasse Datenbankmodul {}

Dieses Datenbankmodul verwaltet die Verbindung, indem es das TypeORM-Modul mit dem erforderlichen Verbindungsparameter, der Datenbank-URL, konfiguriert.

Darüber hinaus definiert es die Benutzerentität als Teil der Konfiguration, die die Struktur und Eigenschaften der in der PostgreSQL-Datenbanktabelle gespeicherten Daten angibt.

Zu diesem Zeitpunkt wird Ihr Code wahrscheinlich einen Fehler auslösen, da Sie die Benutzerentität noch nicht erstellt haben. Dies erledigen Sie in den folgenden Schritten.

Aktualisieren Sie die Datei app.module.ts

Aktualisieren Sie abschließend das Hauptanwendungsmodul, um die Konfiguration für das Datenbankmodul einzuschließen.

importieren { Modul } aus'@nestjs/common';
importieren { ConfigModule } aus'@nestjs/config';
importieren {AppController} aus'./app.controller';
importieren { AppService } aus'./app.service';
importieren { Datenbankmodul } aus'./database/database.module';
@Modul({
 Importe: [
 ConfigModule.forRoot({
 envFilePath: '.env', 
 }),
 Datenbankmodul,
 ],
 Controller: [AppController],
 Anbieter: [AppService],
})
ExportKlasse AppModule {}

Definieren Sie ein Benutzermodul

Das Benutzermodul dient als zentrale Komponente und ist für die Kapselung und Verwaltung der Logik verantwortlich, die zur Implementierung der CRUD-Funktionalität der API erforderlich ist.

Führen Sie diesen Terminalbefehl aus, um das Benutzermodul der API zu erstellen.

Benutzer des Nest-G-Moduls

Das CLI-Tool aktualisiert automatisch die app.module.ts Datei, um zusätzlich zur Erstellung des Benutzermoduls die vorgenommenen Änderungen widerzuspiegeln. Dadurch wird sichergestellt, dass das neu erstellte Modul „Benutzer“ ordnungsgemäß in die Modulkonfiguration der Anwendung integriert wird.

Erstellen Sie eine Benutzerentität

TypeORM ist eine Object-Relational Mapping (ORM)-Bibliothek, die Datenbankinteraktionen in Anwendungen, die TypeScript verwenden, durch die Zuordnung von JavaScript-Objekten zu Datenbanktabellen vereinfacht.

Indem Sie mit TypeORM eine Benutzerentität erstellen, definieren Sie die Struktur und Eigenschaften der Benutzerdaten in der PostgreSQL-Datenbank.

Erstellen Sie im Benutzerverzeichnis ein neues models/user.entity.ts und fügen Sie den folgenden Code hinzu.

importieren { Entität, PrimaryGeneratedColumn, Spalte, } aus„typeorm“;
@Juristische Person()
ExportKlasse Benutzer {
@PrimaryGeneratedColumn()
 Ausweis: Nummer;
@Spalte()
 Name: Zeichenfolge;
@Spalte()
 Email: Zeichenfolge;
}

Der Benutzer Entität definiert die Struktur der in der Datenbank gespeicherten Benutzerdaten. In diesem Fall ist das der Ausweis als Primärschlüsselspalte und die Name Und Email Spalten und ihre entsprechenden Eigenschaften.

Erstellen Sie den CRUD-API-Dienst

Erstellen Sie nun den API-Dienst, der die Logik für die CRUD-Vorgänge verwaltet, indem Sie den folgenden Befehl ausführen:

Benutzer des Nest G-Dienstes

Öffne das user-auth.service.ts Datei und fügen Sie diesen Code hinzu:

importieren {Injizierbar} aus'@nestjs/common';
importieren {InjectRepository} aus'@nestjs/typeorm';
importieren { Repository } aus'typeorm';
importieren {Benutzer} aus'./models/user.entity';
@Injectable()
ExportKlasse UsersService {
Konstrukteur(
@InjectRepository(Benutzer)
Privatgelände userRepository: Repository,
 ) {}
asynchron finde alle(): Versprechen {
zurückkehrenDas.userRepository.find();
 }
asynchron findOne (id: Nummer): Versprechen {
zurückkehrenDas.userRepository.findOne({ where: { id } });
 }
asynchron erstellen (Benutzer: Teilweise): Versprechen {
const neuerBenutzer = Das.userRepository.create (Benutzer);
zurückkehrenDas.userRepository.save (neuer Benutzer);
 }
asynchron Update (ID: Nummer, Benutzer: Teilweise): Versprechen {
erwartenDas.userRepository.update (ID, Benutzer);
zurückkehrenDas.userRepository.findOne({ where: { id } });
 }
asynchronlöschen(Ausweis: Nummer): Versprechen<Leere> {
erwartenDas.userRepository.delete (id);
 }
}

Diese UsersService-Klasse definiert verschiedene API-Methoden für die Verarbeitung von CRUD-Vorgängen. Zu diesen Methoden gehören das Abrufen aller Benutzerdaten, das Suchen eines bestimmten Benutzers anhand seiner ID-Nummer und das Erstellen einen neuen Benutzer, das Aktualisieren eines vorhandenen Benutzers und eine Methode zum Löschen der Daten eines bestimmten Benutzers in der Datenbank.

Definieren Sie einen Controller für die API

Erstellen Sie einen Controller, der die API-Endpunkte für die benutzerbezogenen Vorgänge verwaltet.

Nest-G-Controller-Benutzer

Fügen Sie als Nächstes den folgenden Code hinzu user.controller.ts Datei.

importieren { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } aus'@nestjs/common';
importieren { UsersService } aus'./users.service';
importieren { Benutzer } aus'./models/user.entity';
@Regler('API/Benutzer')
ExportKlasse UsersController {
Konstrukteur(Privatgelände schreibgeschützter UserService: UsersService) {}
@Erhalten()
asynchron finde alle(): Versprechen {
zurückkehrenDas.usersService.findAll();
 }
@Post()
@HttpCode(201) 
asynchron erstellen(@Körper() Benutzer: Benutzer): Versprechen {
const erstelltBenutzer = erwartenDas.usersService.create (Benutzer);
zurückkehren erstelltBenutzer;
 }
@Setzen(':Ausweis')
asynchron aktualisieren (@Param('Ausweis') Ausweis: Nummer, @Körper() Benutzer: Benutzer): Versprechen<beliebig> {
erwartenDas.usersService.update (ID, Benutzer);
zurückkehren { Nachricht: „Benutzer erfolgreich aktualisiert“ };
 }
@Löschen(':Ausweis')
asynchronlöschen(@Param('Ausweis') Ausweis: Nummer): Versprechen<beliebig> {
const Benutzer = erwartenDas.usersService.findOne (id);
Wenn (!Benutzer) {
Wurfneu NotFoundException('Benutzer existiert nicht!');
 }
erwartenDas.usersService.delete (id);
zurückkehren { Nachricht: „Benutzer erfolgreich gelöscht“ };
 }
}

Der Controller verwaltet API-Endpunkte für Benutzervorgänge. Es verarbeitet GET-Anfragen zum Abrufen aller Benutzer, POST-Anfragen zum Erstellen neuer Benutzer, PUT-Anfragen zum Aktualisieren bestehender Benutzer und DELETE-Anfragen zum Löschen von Benutzern.

Durch die Nutzung der BenutzerService und die Interaktion mit dem Benutzer Entität stellt dieser Controller eine vollständige API zur Verwaltung benutzerbezogener Vorgänge für die in der Datenbank gespeicherten Daten bereit.

Aktualisieren Sie die Datei „users.module.ts“.

Aktualisieren Sie abschließend die user.module.ts Datei wie unten gezeigt, um sicherzustellen, dass Sie die integrieren Benutzerentität und das TypeORM-Modul, das die Verbindung zur Datenbank herstellt.

importieren { Modul } aus'@nestjs/common';
importieren { UsersController } aus'./users.controller';
importieren { UsersService } aus'./users.service';
importieren { TypeOrmModule } aus'@nestjs/typeorm';
importieren { Benutzer } aus'./models/user.entity';
@Modul({
 Importe: [TypeOrmModule.forFeature([Benutzer])],
 Controller: [UsersController],
 Anbieter: [UsersService]
})
ExportKlasse UsersModule {}

Fahren Sie abschließend fort und starten Sie den Entwicklungsserver, um die CRUD-Vorgänge mit Postman zu testen.

NPM-Laufstart

Der Server startet auf Port 3000 und Sie können dort API-Anfragen an ihn senden http://localhost: 3000/API/Benutzer.

Backend-Anwendungen mit Nest.js erstellen

Unabhängig davon, ob Sie eine einfache REST-API oder eine komplexe Web-App entwickeln, bietet Nest.js umfassende Funktionen und Fähigkeiten zum Aufbau eines zuverlässigen und robusten Backend-Systems.

Nest.js bietet einen strukturierteren Ansatz für die Projektentwicklung als Express.js. Dadurch wird sichergestellt, dass Sie dank des organisierten und modularen Designmusters komplexe Anwendungen sicher erstellen, skalieren und warten können.