Sissejuhatus NestJS-i CQRS-i

Levinud lähenemisviis NestJS-i arendamiseks on luua teenused, millega kontrollerid andmetele juurdepääsuks suhtlevad. Kuid see lähenemisviis pole NestJS-i ainus kehtiv kujundusmuster. On ka teisi kujundusmustreid, näiteks CQRS-i kujundusmuster.

CQRS on disainimuster, mis eraldab rakenduse lugemis- ja kirjutamistoimingud. See eraldamine võib aidata parandada skaleeritavust, jõudlust ja hooldatavust.

Siit saate teada kõike CQRS-i kohta ja selle kohta, kuidas seda NestJS-i API loomisel rakendada.

Mis on CQRS?

CQRS tähistab käsk-päring vastutuse eraldamine. See rakendab kasutamist käske andmete loomiseks, värskendamiseks ja kustutamiseks ning päringuid andmete toomiseks. See aitab kõrvaldada vajaduse rakendada rakenduse andmebaasikõnesid teenustesse.

Samuti võimaldab see selgelt eristada andmebaasist andmete pärimise ja muude toimingute tegemise loogikat rakenduses.

CQRS-i lähenemisviis on kasulik domeenipõhine disain

, mis võimaldab teil rakenduses eraldada domeeniloogika ja infrastruktuuri toimingud. Seda saab kasutada ka keerulise äriloogika juurutamiseks, kuid lihtsamate rakenduste puhul pole see soovitatav.

CQRS-i kasutamine NestJS API-s

Saate kasutada CQRS-i kujundusmustrit API-s, mille loote NestJS-is. Et järgida, peab teil olema Teie arvutisse installitud Node.js ja NestJS-i uusim versioon.

Kasutage järgmisi samme, et luua lihtne ajaveebirakendus, mis rakendab CQRS-i kujundusmustrit.

Looge Nesti projekt

Looge uus Nesti projekt ja looge a postitus ressurss ajaveebirakenduse jaoks. Seda saate teha, käivitades terminalis järgmised käsud:

nest uus nestjs-cqrs
nest g mooduli postitused
nest g kontrolleri postitused
nest g teeninduspostid

Installige sõltuvused

Pärast ülaltoodud sammude täitmist käivitage NestJS CQRS paketi installimiseks see terminalikäsk:

npm install --save @nestjs/cqrs

Looge postiteenus

Lisage omale järgmine kood posts.service.ts faili määratlemiseks Postiteenus klass.

// posts.service.ts
importida { Süstitav } alates„@nestjs/common”;
eksportidaliides Postita {
 pealkiri: string;
 sisu: string;
}
@Süstitav()
eksportidaklass Postiteenus {
privaatne kirjutuskaitstud postitused: Postitus[] = [];
 loo (postitus: Postitus): Postita {
see.posts.push (postitus);
tagasi postitus;
 }
 findById (id: number): Postita {
tagasisee.posts.find(postitus => post.id id);
 }
}

The Postiteenus määratleb luua ja findById meetodid uue postituse loomiseks ja olemasoleva postituse hankimiseks selle ID-st.

Määratlege käsud ja päringud

Järgmine samm on määratleda päringud ja käsud, mis on CQRS-i kujundusmustri tuumaks.

Aastal postitusi kataloogis, looge kaks uut faili: luuaPostCommand.command.ts ja getPostQuery.query.ts. Käsufail peaks välja nägema selline:

// createPostCommand.command.ts
eksportidaklass CreatePostCommand {
konstruktor(avalik kirjutuskaitstud pealkiri: string, avalik kirjutuskaitstud sisu: string) {}
}

Ja päringu definitsioonifail, näiteks selline:

// getPostQuery.query.ts
eksportidaklass GetPostQuery {
konstruktor(avalik kirjutuskaitstud id: number) {}
}

Looge käsu- ja päringukäsitlejaid

Pärast käskude ja päringute edukat määratlemist peate nende jaoks looma töötlejad. Käsitleja on funktsioon, mis käivitab käsu või päringu ja tagastab tulemuse.

Loo käitlejad.ts faili oma postitus kataloogi ja kleepige sinna järgmine kood:

// handlers.ts
importida { CommandHandler, ICommandHandler } alates'@nestjs/cqrs';
importida { CreatePostCommand } alates'./createPostCommand.command.ts';
importida { Postiteenus } alates'./post.service';
@CommandHandler(CreatePostCommand)
eksportidaklass Loo PostHandler rakendab ICommandHandler {
konstruktor(privaatne kirjutuskaitstud postService: PostService) {}
asünkr käivita (käsk: CreatePostCommand) {
konst {nimi, hind} = käsk;
konst postitus = ootamasee.postService.create (pealkiri, sisu);
tagasi postitus;
 }
}

Samas käitlejad.ts faili, saate päringutega töötamise võimaldamiseks muuta impordilauseid, et need hõlmaksid allolevaid. Seejärel saate rakendada päringukäsitleja, nagu on näha allolevas koodis:

// handler.ts
importida { QueryHandler, IQueryHandler } alates'@nestjs/cqrs';
importida { GetPostQuery } alates'./getPostQuery.query';
importida { Postiteenus } alates'./post.service';
// päringu töötleja
@QueryHandler(GetProductQuery)
eksportidaklass GetPostHandler rakendab IQueryHandler {
konstruktor(privaatne kirjutuskaitstud postService: PostService) {}
asünkr käivita (päring: GetPostQuery) {
konst { id } = päring;
konst postitus = ootamasee.postService.findOneById (id);
tagasi postitus;
 }
}

Registrihaldurid

Viimane samm on käskude ja päringute töötlejate registreerimine NestJS-i mooduliga.

// post.module.ts
importida { Moodul } alates„@nestjs/common”;
importida { CommandHandlers, QueryHandlers } alates"handlers.ts";
importida { Postiteenus } alates'./post.service';
@Moodul({
 pakkujad: [
 Postiteenus,
 ...käsuhaldurid,
 ...QueryHandlers,
 ],
})
eksportidaklass Postimoodul {}

See kood registreerib Postiteenus, Käsukäsitlejadja Päringukäsitlejad aastal pakkujad massiivi. leviku operaatori kasutamine (...) on ühendada massiive päring käitlejad ja käsk käitlejad sisse pakkujad massiivi.

Käivita käsud ja päringud

Registreeritud käsud ja päringukäsitlejad on kontrollerites kasutatavad. Järgmine kood on a rakendamine postitusi kontroller, mis aktsepteerib HTTP-päringuid ja tagastab nõutavad vastused.

// posts.controller.ts
importida { Body, Controller, Post } alates„@nestjs/common”;
importida { CommandBus } alates'@nestjs/cqrs';
importida { CreatePostCommand } alates'./createPostCommand.command.ts';
// kontroller, mis rakendab käsku
@Controller('postitused')
eksportidaklass PostController {
konstruktor(privaatne kirjutuskaitstud käsubuss: CommandBus) {}
@Postitus()
asünkr createPost(@Keha() body: { title: string; sisu: string }) {
konst { pealkiri, sisu } = keha;
konst käsk = uus CreatePostCommand (pealkiri, sisu);
konst postitus = ootamasee.commandBus.execute (käsk);
tagasi postitus;
 }
}

Ülaltoodud koodis on CommandBus hukkab Loo PostCommand ja loob uue postituse.

See kood näitab, kuidas juurutada kontrollerit, mis kasutab päringut:

// posts.controller.ts
importida { Kontroller, hanki, parameeter } alates„@nestjs/common”;
importida { QueryBus } alates'@nestjs/cqrs';
importida { GetPostQuery } alates'./getPostQuery.query';
@Controller('postitused')
eksportidaklass PostController {
konstruktor(privaatne kirjutuskaitstud queryBus: QueryBus) {}
@Hangi(':id')
asünkr getPost(@Param('id') id: number) {
konst päring = uus GetPostQuery (id);
konst postitus = ootamasee.queryBus.execute (päring);
tagasi postitus;
 }
}

The queryBus hukkab GetPostQuery mis saab antud ID-ga postituse ja tagastab selle.

Pärast kõigi ülaltoodud sammude täitmist peaks teil nüüd olema minimalistlik töötav rakendus ajaveebipostituste loomiseks ja toomiseks.

Kuigi siinne kood kasutab loodud postituste mällu salvestamiseks massiivi, kasutate tõenäolisemalt tootmises andmebaasi. Võite kasutada kas a SQL andmebaasvõi a NoSQL-i andmebaas nagu MongoDB, kuna NestJS toetab mõlemat valikut.

API-de loomine CQRS-i disainimustri abil

CQRS-i kujundusmustri lisamine oma NestJS-i rakendusse võib aidata suurendada skaleeritavust, jõudlust ja hooldatavust. CQRS võimaldab tõhusamaid ja optimeeritud toiminguid, eraldades rakenduses tehtavad lugemis- ja kirjutamistoimingud.

Pakett @nestjs/cqrs on ehitusplokk CQRS-i juurutamiseks NestJS-is koos käskude ja päringukäsitlejatega. Üldiselt on CQRS võimas muster, mis aitab luua tõhusamaid ja skaleeritumaid rakendusi ning enne selle kasutamist peaksite oma võimalusi kaaluma.