Brug CQRS-mønsteret med omhu, og du kan skabe renere, mere skalerbare Nest-apps.

En almindelig tilgang til NestJS-udvikling er at bygge tjenester, som controllere kommunikerer med for at få adgang til data. Men denne tilgang er ikke det eneste gyldige designmønster i NestJS. Der er andre designmønstre, såsom CQRS designmønsteret.

CQRS er et designmønster, der adskiller en applikations læse- og skriveoperationer. Denne adskillelse kan hjælpe med at forbedre skalerbarhed, ydeevne og vedligeholdelse.

Find ud af alt om CQRS, og hvordan du kan anvende det, når du bygger en NestJS API.

Hvad er CQRS?

CQRS står for kommando-forespørgsel ansvar adskillelse. Det implementerer brugen af kommandoer at oprette, opdatere og slette data og forespørgsler at hente data. Dette hjælper med at eliminere behovet for at implementere en applikations databasekald i tjenester.

Det muliggør også en klar skelnen mellem logikken i at forespørge databasen for data og udføre andre handlinger i en applikation.

CQRS-tilgangen er nyttig i

instagram viewer
domænedrevet design, som giver dig mulighed for at adskille domænelogik og infrastrukturelle operationer i din applikation. Du kan også bruge det til at implementere kompleks forretningslogik, men dette anbefales ikke til enklere applikationer.

Brug af CQRS i en NestJS API

Du kan bruge CQRS-designmønsteret i en API, som du bygger i NestJS. For at følge med, skal du have Node.js installeret på din computer og en nyere version af NestJS.

Brug følgende trin til at bygge en simpel bloggingapplikation, der implementerer CQRS-designmønsteret.

Opret et Nest-projekt

Opret et nyt Nest-projekt og generer et stolpe ressource til en blogapplikation. Du kan gøre dette ved at køre følgende kommandoer i en terminal:

nest new nestjs-cqrs
rede g modul indlæg
rede g controller-poster
rede g serviceposter

Installer afhængigheder

Når du har gennemført ovenstående trin, skal du køre denne terminalkommando for at installere NestJS CQRS-pakken:

npm install --gem @nestjs/cqrs

Opret en posttjeneste

Tilføj følgende kode til din posts.service.ts fil for at definere Postservice klasse.

// posts.service.ts
importere { Injicerbar } fra'@nestjs/common';
eksportinterface Indlæg {
 titel: snor;
 indhold: snor;
}


@Injicerbar()
eksportklasse PostService {
privat skrivebeskyttede indlæg: Indlæg[] = [];


 oprette (post: Post): Post {
det her.posts.push (post);
Vend tilbage stolpe;
 }
 findById (id: nummer): Indlæg {
Vend tilbagedet her.posts.find(stolpe => post.id id);
 }
}

Det Postservice definerer skab og findById metoder til at oprette et nyt indlæg og få et eksisterende indlæg fra dets ID.

Definer kommandoer og forespørgsler

Det næste trin er at definere de forespørgsler og kommandoer, der er kernen i CQRS-designmønsteret.

I den indlæg mappe, opret to nye filer: skabePostCommand.command.ts og getPostQuery.query.ts. Kommandofilen skal se sådan ud:

// createPostCommand.command.ts
eksportklasse CreatePostCommand {
konstruktør(offentlig skrivebeskyttet titel: snor, offentlig skrivebeskyttet indhold: snor) {}
}

Og forespørgselsdefinitionsfilen, som denne:

// getPostQuery.query.ts
eksportklasse GetPostQuery {
konstruktør(offentlig skrivebeskyttet id: nummer) {}
}

Opret kommando- og forespørgselshåndtere

Når du har defineret dine kommandoer og forespørgsler, skal du oprette handlere til dem. En handler er en funktion, der kører en kommando eller forespørgsel og returnerer resultatet.

Lave en handlere.ts fil i din stolpe mappe og indsæt følgende kode i den:

// handlers.ts
importere { CommandHandler, ICommandHandler } fra'@nestjs/cqrs';
importere { CreatePostCommand } fra'./createPostCommand.command.ts';
importere { PostService } fra'./post.service';
@CommandHandler(CreatePostCommand)
eksportklasse Opret PostHandler redskaber ICommandHandler {
konstruktør(privat skrivebeskyttet postService: PostService) {}
asynkron execute (kommando: CreatePostCommand) {
konst { navn, pris } = kommando;
konst indlæg = ventedet her.postService.create (titel, indhold);
Vend tilbage stolpe;
 }
}

I det samme handlere.ts fil, kan du ændre importerklæringerne til at inkludere dem nedenfor for at tillade arbejde med forespørgsler. Du kan derefter implementere forespørgselshåndteringen som vist i nedenstående kode:

// handler.ts
importere { QueryHandler, IQueryHandler } fra'@nestjs/cqrs';
importere { GetPostQuery } fra'./getPostQuery.query';
importere { PostService } fra'./post.service';
// forespørgselshåndtering
@QueryHandler(GetProductQuery)
eksportklasse GetPostHandler redskaber IQueryHandler {
konstruktør(privat skrivebeskyttet postService: PostService) {}
asynkron execute (forespørgsel: GetPostQuery) {
konst { id } = forespørgsel;
konst indlæg = ventedet her.postService.findOneById (id);
Vend tilbage stolpe;
 }
}

Registrer Behandlere

Det sidste trin er at registrere kommando- og forespørgselshandlerne med NestJS-modulet.

// post.modul.ts
importere { Modul } fra'@nestjs/common';
importere { CommandHandlers, QueryHandlers } fra'handlers.ts';
importere { PostService } fra'./post.service';
@Modul({
 udbydere: [
 Postservice,
 ...CommandHandlers,
 ...QueryHandlers,
 ],
})
eksportklasse PostModule {}

Denne kode registrerer Postservice, CommandHandlers, og QueryHandlers i udbydere array. Brugen af ​​en spredningsoperatør (...) er at flette arrays af forespørgsel handlere og kommando handlere ind i udbydere array.

Udfør kommandoer og forespørgsler

De registrerede kommandoer og forespørgselshandlere er brugbare i controllere. Følgende kode er implementeringen af ​​en indlæg controller, som vil acceptere HTTP-anmodninger og returnere nødvendige svar.

// posts.controller.ts
importere { Body, Controller, Post } fra'@nestjs/common';
importere { CommandBus } fra'@nestjs/cqrs';
importere { CreatePostCommand } fra'./createPostCommand.command.ts';
// controller, der implementerer kommando
@Kontroller('indlæg')
eksportklasse PostController {
konstruktør(privat skrivebeskyttet commandBus: CommandBus) {}
@Stolpe()
asynkron oprette Indlæg(@Legeme() body: { title: snor; indhold: snor }) {
konst { title, content } = body;
konst kommando = ny CreatePostCommand (titel, indhold);
konst indlæg = ventedet her.commandBus.execute (kommando);
Vend tilbage stolpe;
 }
}

I koden ovenfor er CommandBus udfører CreatePostCommand og opretter et nyt indlæg.

Denne kode viser, hvordan man implementerer en controller, der bruger en forespørgsel:

// posts.controller.ts
importere { Controller, Get, Param } fra'@nestjs/common';
importere { QueryBus } fra'@nestjs/cqrs';
importere { GetPostQuery } fra'./getPostQuery.query';
@Kontroller('indlæg')
eksportklasse PostController {
konstruktør(privat skrivebeskyttet queryBus: QueryBus) {}
@Få(':id')
asynkron getPost(@Param('id') id: nummer) {
konst forespørgsel = ny GetPostQuery (id);
konst indlæg = ventedet her.queryBus.execute (forespørgsel);
Vend tilbage stolpe;
 }
}

Det queryBus udfører GetPostQuery som får opslaget med det givne ID og returnerer det.

Efter at have gennemført alle ovenstående trin, skulle du nu have en minimalistisk, fungerende applikation til at oprette og hente blogindlæg.

Selvom koden her bruger et array til at gemme de oprettede indlæg i hukommelsen, er det mere sandsynligt, at du bruger en database i produktionen. Du kan enten bruge en SQL database, eller en NoSQL-database som MongoDB, da NestJS understøtter begge muligheder.

Opbygning af API'er med CQRS-designmønsteret

At inkorporere CQRS-designmønsteret i din NestJS-applikation kan hjælpe med skalerbarhed, ydeevne og vedligeholdelse. CQRS giver mulighed for mere effektive og optimerede operationer ved at adskille de læse- og skriveoperationer, som en applikation udfører.

@nestjs/cqrs-pakken giver en byggeklods til implementering af CQRS i NestJS med kommandoer og forespørgselshandlere. Samlet set er CQRS et kraftfuldt mønster, der kan hjælpe med at skabe mere effektive og skalerbare applikationer, og du bør afveje dine muligheder, før du bruger det.