Eine Einführung in CQRS in NestJS

Ein gängiger Ansatz für die Entwicklung von NestJS besteht darin, Dienste zu erstellen, mit denen Controller kommunizieren, um auf Daten zuzugreifen. Aber dieser Ansatz ist nicht das einzige gültige Entwurfsmuster in NestJS. Es gibt andere Entwurfsmuster, z. B. das CQRS-Entwurfsmuster.

CQRS ist ein Entwurfsmuster, das die Lese- und Schreibvorgänge einer Anwendung trennt. Diese Trennung kann dazu beitragen, die Skalierbarkeit, Leistung und Wartbarkeit zu verbessern.

Erfahren Sie alles über CQRS und wie Sie es beim Erstellen einer NestJS-API anwenden können.

Was ist CQRS?

CQRS steht für Verantwortungstrennung zwischen Befehl und Abfrage. Es implementiert die Verwendung von Befehle zum Erstellen, Aktualisieren und Löschen von Daten und Abfragen Daten zu holen. Dadurch entfällt die Notwendigkeit, die Datenbankaufrufe einer Anwendung in Dienste zu implementieren.

Es ermöglicht auch eine klare Unterscheidung zwischen der Logik des Abfragens der Datenbank nach Daten und der Durchführung anderer Aktionen in einer Anwendung.

Der CQRS-Ansatz ist nützlich in domänengesteuertes Design, wodurch Sie Domänenlogik und Infrastrukturvorgänge in Ihrer Anwendung trennen können. Sie können damit auch komplexe Geschäftslogik implementieren, dies wird jedoch für einfachere Anwendungen nicht empfohlen.

Verwenden von CQRS in einer NestJS-API

Sie können das CQRS-Entwurfsmuster in einer API verwenden, die Sie in NestJS erstellen. Um mitzumachen, müssen Sie haben Node.js auf Ihrem Computer installiert und eine aktuelle Version von NestJS.

Verwenden Sie die folgenden Schritte, um eine einfache Bloganwendung zu erstellen, die das CQRS-Entwurfsmuster implementiert.

Erstellen Sie ein Nest-Projekt

Erstellen Sie ein neues Nest-Projekt und generieren Sie eine Post Ressource für eine Bloganwendung. Sie können dies tun, indem Sie die folgenden Befehle in einem Terminal ausführen:

nest neu nestjs-cqrs
Nest-G-Modul-Beiträge
Nest-G-Controller-Beiträge
Nest g Servicestellen

Abhängigkeiten installieren

Nachdem Sie die obigen Schritte ausgeführt haben, führen Sie diesen Terminalbefehl aus, um das NestJS-CQRS-Paket zu installieren:

npm install --save @nestjs/cqrs

Erstellen Sie einen Postdienst

Fügen Sie den folgenden Code zu Ihrer hinzu posts.service.ts Datei zum Definieren der Post-Service Klasse.

// posts.service.ts
importieren {Injizierbar} aus'@nestjs/common';
ExportSchnittstelle Post {
 Titel: Schnur;
 Inhalt: Schnur;
}
@ Injizierbar()
ExportKlasse Post-Service {
Privatgelände schreibgeschützte Beiträge: Post[] = [];
 erstellen (Beitrag: Beitrag): Beitrag {
Das.posts.push (Beitrag);
zurückkehren Post;
 }
 findById (ID: Nummer): Post {
zurückkehrenDas.posts.find(Post => post.id-ID);
 }
}

Der Post-Service definiert erstellen Und findById Methoden, um einen neuen Beitrag zu erstellen und einen vorhandenen Beitrag von seiner ID abzurufen.

Befehle und Abfragen definieren

Der nächste Schritt besteht darin, die Abfragen und Befehle zu definieren, die den Kern des CQRS-Entwurfsmusters bilden.

Im Beiträge erstellen Sie zwei neue Dateien: erstellenPostCommand.command.ts Und getPostQuery.query.ts. Die Befehlsdatei sollte wie folgt aussehen:

// createPostCommand.command.ts
ExportKlasse CreatePostCommand {
Konstrukteur(öffentlich schreibgeschützter Titel: Schnur, öffentlich schreibgeschützter Inhalt: Schnur) {}
}

Und die Abfragedefinitionsdatei wie folgt:

// getPostQuery.query.ts
ExportKlasse GetPostQuery {
Konstrukteur(öffentlich Nur-Lese-ID: Nummer) {}
}

Erstellen Sie Befehls- und Abfragehandler

Nachdem Sie Ihre Befehle und Abfragen erfolgreich definiert haben, müssen Sie Handler für sie erstellen. Ein Handler ist eine Funktion, die einen Befehl oder eine Abfrage ausführt und das Ergebnis zurückgibt.

Ein... kreieren handlers.ts Datei in Ihrer Post Verzeichnis und fügen Sie den folgenden Code darin ein:

// Handler.ts
importieren { CommandHandler, ICommandHandler } aus'@nestjs/cqrs';
importieren { CreatePostCommand } aus'./createPostCommand.command.ts';
importieren { Post-Service } aus'./Post-Service';
@CommandHandler(CreatePostCommand)
ExportKlasse CreatePostHandler implementiert ICommandHandler {
Konstrukteur(Privatgelände readonly postService: PostService) {}
asynchron ausführen (Befehl: CreatePostCommand) {
konst { Name, Preis } = Befehl;
konst Beitrag = erwartenDas.postService.create (Titel, Inhalt);
zurückkehren Post;
 }
}

Im gleichen handlers.ts -Datei können Sie die Importanweisungen so ändern, dass sie die folgenden enthalten, um das Arbeiten mit Abfragen zu ermöglichen. Sie können dann den Abfragehandler wie im folgenden Code zu sehen implementieren:

// Handler.ts
importieren { QueryHandler, IQueryHandler } aus'@nestjs/cqrs';
importieren {GetPostQuery} aus'./getPostQuery.query';
importieren { Post-Service } aus'./Post-Service';
// Abfragehandler
@QueryHandler(GetProductQuery)
ExportKlasse GetPostHandler implementiert IQueryHandler {
Konstrukteur(Privatgelände readonly postService: PostService) {}
asynchron Ausführen (Abfrage: GetPostQuery) {
konst {id} = Abfrage;
konst Beitrag = erwartenDas.postService.findOneById (ID);
zurückkehren Post;
 }
}

Handler registrieren

Der letzte Schritt besteht darin, die Befehls- und Abfragehandler beim NestJS-Modul zu registrieren.

// post.modul.ts
importieren { Modul } aus'@nestjs/common';
importieren { CommandHandler, QueryHandler } aus'handlers.ts';
importieren { Post-Service } aus'./Post-Service';
@Modul({
 Anbieter: [
 Post-Service,
 ...CommandHandler,
 ...QueryHandler,
 ],
})
ExportKlasse PostModul {}

Dieser Code registriert die Post-Service, CommandHandler, Und QueryHandler im Anbieter Reihe. Die Verwendung eines Spread-Operators (...) besteht darin, die Arrays von zusammenzuführen Anfrage Handler u Befehl Handler in die Anbieter Reihe.

Befehle und Abfragen ausführen

Die registrierten Befehle und Abfragehandler sind in Controllern verwendbar. Der folgende Code ist die Implementierung von a Beiträge Controller, der HTTP-Anforderungen akzeptiert und die erforderlichen Antworten zurückgibt.

// posts.controller.ts
importieren { Körper, Verantwortlicher, Post } aus'@nestjs/common';
importieren { CommandBus } aus'@nestjs/cqrs';
importieren { CreatePostCommand } aus'./createPostCommand.command.ts';
// Controller, der den Befehl implementiert
@Regler('Beiträge')
ExportKlasse PostController {
Konstrukteur(Privatgelände readonly commandBus: CommandBus) {}
@Post()
asynchron createPost(@Körper() Körper: { Titel: Schnur; Inhalt: Schnur }) {
konst { Titel, Inhalt } = Körper;
konst Befehl = neu CreatePostCommand (Titel, Inhalt);
konst Beitrag = erwartenDas.commandBus.execute (Befehl);
zurückkehren Post;
 }
}

Im obigen Code ist die CommandBus führt die aus CreatePostCommand und erstellt einen neuen Beitrag.

Dieser Code zeigt, wie ein Controller implementiert wird, der eine Abfrage verwendet:

// posts.controller.ts
importieren {Controller, Get, Param} aus'@nestjs/common';
importieren { Abfragebus } aus'@nestjs/cqrs';
importieren {GetPostQuery} aus'./getPostQuery.query';
@Regler('Beiträge')
ExportKlasse PostController {
Konstrukteur(Privatgelände Nur-Lese-QueryBus: QueryBus) {}
@Erhalten(':Ausweis')
asynchron getPost(@Param('Ausweis') Ausweis: Nummer) {
konst abfrage = neu GetPostQuery (id);
konst Beitrag = erwartenDas.queryBus.execute (Abfrage);
zurückkehren Post;
 }
}

Der AbfrageBus führt aus GetPostQuery die den Beitrag mit der angegebenen ID erhält und zurücksendet.

Nachdem Sie alle oben genannten Schritte ausgeführt haben, sollten Sie nun über eine minimalistische, funktionierende Anwendung zum Erstellen und Abrufen von Blog-Beiträgen verfügen.

Obwohl der Code hier ein Array verwendet, um die erstellten Posts im Arbeitsspeicher zu speichern, ist es wahrscheinlicher, dass Sie eine Datenbank in der Produktion verwenden. Sie können entweder a verwenden SQL-Datenbank, oder ein NoSQL-Datenbank wie MongoDB, da NestJS beide Optionen unterstützt.

Erstellen von APIs mit dem CQRS-Entwurfsmuster

Die Integration des CQRS-Entwurfsmusters in Ihre NestJS-Anwendung kann die Skalierbarkeit, Leistung und Wartbarkeit verbessern. CQRS ermöglicht effizientere und optimierte Vorgänge, indem es die Lese- und Schreibvorgänge trennt, die eine Anwendung ausführt.

Das @nestjs/cqrs-Paket stellt einen Baustein für die Implementierung von CQRS in NestJS mit Befehlen und Abfrage-Handlern bereit. Insgesamt ist CQRS ein leistungsstarkes Muster, das dabei helfen kann, effizientere und skalierbarere Anwendungen zu erstellen, und Sie sollten Ihre Optionen abwägen, bevor Sie es verwenden.