Utilizați modelul CQRS cu grijă și puteți crea aplicații Nest mai curate și mai scalabile.

O abordare comună a dezvoltării NestJS este de a construi servicii cu care controlorii comunică pentru a accesa date. Dar această abordare nu este singurul model de design valid în NestJS. Există și alte modele de design, cum ar fi modelul de design CQRS.

CQRS este un model de design care separă operațiunile de citire și scriere ale unei aplicații. Această separare poate ajuta la îmbunătățirea scalabilității, performanței și mentenanței.

Aflați totul despre CQRS și despre cum îl puteți aplica atunci când construiți un API NestJS.

Ce este CQRS?

CQRS reprezintă segregarea răspunderii comandă-interogare. Implementează utilizarea de comenzi pentru a crea, actualiza și șterge date și întrebări pentru a prelua date. Acest lucru ajută la eliminarea necesității de a implementa apelurile de baze de date ale unei aplicații în servicii.

De asemenea, permite o distincție clară între logica interogării bazei de date pentru date și efectuarea altor acțiuni într-o aplicație.

instagram viewer

Abordarea CQRS este utilă în proiectare bazată pe domeniu, care vă permite să separați logica domeniului și operațiunile de infrastructură în aplicația dvs. De asemenea, îl puteți folosi pentru a implementa logica de afaceri complexă, dar acest lucru nu este recomandat pentru aplicații mai simple.

Utilizarea CQRS într-un API NestJS

Puteți utiliza modelul de design CQRS într-un API pe care îl construiți în NestJS. Pentru a urma, trebuie să ai Node.js instalat pe computer și o versiune recentă a NestJS.

Utilizați următorii pași pentru a construi o aplicație simplă de blogging care implementează modelul de design CQRS.

Creați un proiect Nest

Creați un nou proiect Nest și generați a post resursă pentru o aplicație de blog. Puteți face acest lucru rulând următoarele comenzi într-un terminal:

cuib new nestjs-cqrs
nest g module posts
posturi de controler nest g
cuib g posturi de serviciu

Instalați dependențe

După ce ați finalizat pașii de mai sus, rulați această comandă de terminal pentru a instala pachetul NestJS CQRS:

npm install --save @nestjs/cqrs

Creați un serviciu poștal

Adăugați următorul cod la dvs posturi.serviciu.ts fişier pentru a defini PostService clasă.

// posts.service.ts
import { injectabil } din„@nestjs/common”;
exportinterfata Post {
 titlu: şir;
 conţinut: şir;
}


@Injectabil()
exportclasă PostService {
privat postări numai în citire: Post[] = [];


 creați (post: Postare): Postați {
acest.posturi.push (post);
întoarcere post;
 }
 findById (id: număr): Post {
întoarcereacest.posts.find(post => id-ul post.id);
 }
}

The PostService defineste crea și findById metode de a crea o postare nouă și de a obține o postare existentă din ID-ul său.

Definiți comenzi și interogări

Următorul pas este definirea interogărilor și comenzilor care sunt esențiale pentru modelul de proiectare CQRS.

În postări director, creați două fișiere noi: creaPostCommand.command.ts și getPostQuery.query.ts. Fișierul de comandă ar trebui să arate astfel:

// createPostCommand.command.ts
exportclasă CreatePostCommand {
constructor(public titlu numai pentru citire: şir, public conținut numai în citire: şir) {}
}

Și fișierul de definire a interogării, așa:

// getPostQuery.query.ts
exportclasă GetPostQuery {
constructor(public ID numai pentru citire: număr) {}
}

Creați manevre de comandă și interogare

După ce ați definit cu succes comenzile și interogările, trebuie să creați handlere pentru acestea. Un handler este o funcție care rulează o comandă sau o interogare și returnează rezultatul.

Creeaza o manipulatori.ts dosar în dvs post director și inserați următorul cod în el:

// manipulatori.ts
import { CommandHandler, ICommandHandler } din„@nestjs/cqrs”;
import { CreatePostCommand } din„./createPostCommand.command.ts”;
import { PostService } din„./post.service”;
@CommandHandler(CreatePostCommand)
exportclasă Create PostHandler unelte ICommandHandler {
constructor(privat readonly postService: PostService) {}
asincron executa (comandă: CreatePostCommand) {
const { nume, pret } = comanda;
const post = așteaptăacest.postService.create (titlu, conținut);
întoarcere post;
 }
}

În același manipulatori.ts fișier, puteți modifica instrucțiunile de import pentru a le include pe cele de mai jos, pentru a permite lucrul cu interogări. Apoi, puteți implementa handlerul de interogare, așa cum se vede în codul de mai jos:

// handler.ts
import { QueryHandler, IQueryHandler } din„@nestjs/cqrs”;
import { GetPostQuery } din„./getPostQuery.query”;
import { PostService } din„./post.service”;
// handler de interogări
@QueryHandler(GetProductQuery)
exportclasă GetPostHandler unelte IQueryHandler {
constructor(privat readonly postService: PostService) {}
asincron executa (interogare: GetPostQuery) {
const { id } = interogare;
const post = așteaptăacest.postService.findOneById (id);
întoarcere post;
 }
}

Înregistrați manipulatorii

Ultimul pas este să înregistrați gestionatorii de comenzi și interogări cu modulul NestJS.

// post.module.ts
import { Modulul } din„@nestjs/common”;
import { CommandHandlers, QueryHandlers } din„handlers.ts”;
import { PostService } din„./post.service”;
@Modul({
 furnizori: [
 PostService,
 ...Manager de comandă,
 ...QueryHandlers,
 ],
})
exportclasă PostModule {}

Acest cod înregistrează PostService, CommandHandlers, și QueryHandlers în furnizorii matrice. Utilizarea unui operator de împrăștiere (...) este de a îmbina matricele de interogare manipulanţi şi comanda manipulatorii în furnizorii matrice.

Executați comenzi și interogări

Comenzile înregistrate și manevrele de interogare sunt utilizabile în controlere. Următorul cod este implementarea a postări controler care va accepta cereri HTTP și va returna răspunsurile necesare.

// posts.controller.ts
import { Body, Controller, Post } din„@nestjs/common”;
import { CommandBus } din„@nestjs/cqrs”;
import { CreatePostCommand } din„./createPostCommand.command.ts”;
// controler care implementează comanda
@Controlor(„postări”)
exportclasă PostController {
constructor(privat readonly commandBus: CommandBus) {}
@Post()
asincron createPost(@Corp() body: { title: şir; conţinut: şir }) {
const { title, content } = corp;
const comanda = nou CreatePostCommand (titlu, conținut);
const post = așteaptăacest.commandBus.execute (comandă);
întoarcere post;
 }
}

În codul de mai sus, CommandBus execută CreatePostCommand și creează o nouă postare.

Acest cod arată cum să implementați un controler care utilizează o interogare:

// posts.controller.ts
import { Controller, Get, Param } din„@nestjs/common”;
import { QueryBus } din„@nestjs/cqrs”;
import { GetPostQuery } din„./getPostQuery.query”;
@Controlor(„postări”)
exportclasă PostController {
constructor(privat readonly queryBus: QueryBus) {}
@Obține(':id')
asincron getPost(@Param('id') id: număr) {
const interogare = nou GetPostQuery (id);
const post = așteaptăacest.queryBus.execute (interogare);
întoarcere post;
 }
}

The queryBus execută GetPostQuery care primește postarea cu ID-ul dat și o returnează.

După ce ați finalizat toți pașii de mai sus, ar trebui să aveți acum o aplicație minimalistă, funcțională, pentru a crea și a prelua postări de blog.

Deși codul de aici folosește o matrice pentru a stoca postările create în memorie, este mai probabil să utilizați o bază de date în producție. Puteți folosi fie a baza de date SQL, sau a Baza de date NoSQL precum MongoDB, deoarece NestJS acceptă ambele opțiuni.

Construirea de API-uri cu modelul de proiectare CQRS

Încorporarea modelului de design CQRS în aplicația dvs. NestJS poate ajuta la scalabilitate, performanță și întreținere. CQRS permite operațiuni mai eficiente și optimizate prin separarea operațiunilor de citire și scriere pe care le efectuează o aplicație.

Pachetul @nestjs/cqrs oferă un bloc pentru implementarea CQRS în NestJS cu comenzi și handlere de interogări. În general, CQRS este un model puternic care poate ajuta la crearea unor aplicații mai eficiente și mai scalabile și ar trebui să vă cântăriți opțiunile înainte de a-l utiliza.