En introduksjon til CQRS i NestJS

En vanlig tilnærming til NestJS-utvikling er å bygge tjenester som kontrollerne kommuniserer med for å få tilgang til data. Men denne tilnærmingen er ikke det eneste gyldige designmønsteret i NestJS. Det finnes andre designmønstre, for eksempel CQRS-designmønsteret.

CQRS er et designmønster som skiller lese- og skriveoperasjonene til en applikasjon. Denne separasjonen kan bidra til å forbedre skalerbarhet, ytelse og vedlikehold.

Finn ut alt om CQRS og hvordan du kan bruke det når du bygger en NestJS API.

Hva er CQRS?

CQRS står for kommando-spørring ansvar segregering. Den implementerer bruken av kommandoer for å opprette, oppdatere og slette data og forespørsler for å hente data. Dette bidrar til å eliminere behovet for å implementere en applikasjons databasekall i tjenester.

Det muliggjør også et klart skille mellom logikken ved å spørre databasen etter data og utføre andre handlinger i en applikasjon.

CQRS-tilnærmingen er nyttig i

domenedrevet design, som lar deg skille domenelogikk og infrastrukturelle operasjoner i applikasjonen din. Du kan også bruke den til å implementere kompleks forretningslogikk, men dette anbefales ikke for enklere applikasjoner.

Bruke CQRS i en NestJS API

Du kan bruke CQRS-designmønsteret i en API som du bygger i NestJS. For å følge med må du ha Node.js installert på datamaskinen din og en nyere versjon av NestJS.

Bruk følgende trinn for å bygge en enkel bloggapplikasjon som implementerer CQRS-designmønsteret.

Opprett et Nest-prosjekt

Opprett et nytt Nest-prosjekt og generer et post ressurs for en bloggapplikasjon. Du kan gjøre dette ved å kjøre følgende kommandoer i en terminal:

nest nye nestjs-cqrs
reir g modul innlegg
reir g kontrollposter
reir g serviceposter

Installer avhengigheter

Etter at du har fullført trinnene ovenfor, kjør denne terminalkommandoen for å installere NestJS CQRS-pakken:

npm install --lagre @nestjs/cqrs

Opprett en posttjeneste

Legg til følgende kode til din posts.service.ts fil for å definere PostService klasse.

// posts.service.ts
import { Injiserbar } fra'@nestjs/common';
eksportgrensesnitt Post {
 tittel: streng;
 innhold: streng;
}
@Injiserbar()
eksportklasse PostService {
privat skrivebeskyttede innlegg: Innlegg[] = [];
 opprette (post: Post): Post {
dette.posts.push (innlegg);
komme tilbake post;
 }
 findById (id: Antall): Post {
komme tilbakedette.posts.find(post => post.id id);
 }
}

De PostService definerer skape og findById metoder for å opprette et nytt innlegg og hente et eksisterende innlegg fra ID-en.

Definer kommandoer og spørringer

Det neste trinnet er å definere spørringene og kommandoene som er kjernen i CQRS-designmønsteret.

I innlegg katalog, lag to nye filer: skapePostCommand.command.ts og getPostQuery.query.ts. Kommandofilen skal se slik ut:

// createPostCommand.command.ts
eksportklasse CreatePostCommand {
konstruktør(offentlig skrivebeskyttet tittel: streng, offentlig skrivebeskyttet innhold: streng) {}
}

Og spørringsdefinisjonsfilen, slik:

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

Opprett kommando- og spørringsbehandlere

Etter at du har definert kommandoene og spørringene dine, må du opprette behandlere for dem. En behandler er en funksjon som kjører en kommando eller spørring og returnerer resultatet.

Lage en handlers.ts fil i din post katalog og lim inn følgende kode i den:

// handlers.ts
import { CommandHandler, ICommandHandler } fra'@nestjs/cqrs';
import { CreatePostCommand } fra'./createPostCommand.command.ts';
import { PostService } fra'./post.service';
@CommandHandler(CreatePostCommand)
eksportklasse CreatePostHandler redskaper ICommandHandler {
konstruktør(privat skrivebeskyttet postService: PostService) {}
asynkron kjør (kommando: CreatePostCommand) {
konst { navn, pris } = kommando;
konst innlegg = avventedette.postService.create (tittel, innhold);
komme tilbake post;
 }
}

I den samme handlers.ts fil, kan du endre importsetningene til å inkludere de nedenfor, for å tillate arbeid med spørringer. Du kan deretter implementere spørringsbehandleren som vist i koden nedenfor:

// handler.ts
import { QueryHandler, IQueryHandler } fra'@nestjs/cqrs';
import { GetPostQuery } fra'./getPostQuery.query';
import { PostService } fra'./post.service';
// spørringsbehandler
@QueryHandler(GetProductQuery)
eksportklasse GetPostHandler redskaper IQueryHandler {
konstruktør(privat skrivebeskyttet postService: PostService) {}
asynkron execute (spørring: GetPostQuery) {
konst { id } = spørring;
konst innlegg = avventedette.postService.findOneById (id);
komme tilbake post;
 }
}

Registrer Behandlere

Det siste trinnet er å registrere kommando- og spørringsbehandlere med NestJS-modulen.

// post.module.ts
import { Modul } fra'@nestjs/common';
import { CommandHandlers, QueryHandlers } fra'handlers.ts';
import { PostService } fra'./post.service';
@Modul({
 leverandører: [
 Postservice,
 ...CommandHandlers,
 ...QueryHandlers,
 ],
})
eksportklasse PostModule {}

Denne koden registrerer PostService, CommandHandlers, og QueryHandlers i tilbydere array. Bruken av en spredningsoperatør (...) er å slå sammen matrisene til spørsmål behandlere og kommando handlere inn i tilbydere array.

Utfør kommandoer og spørringer

De registrerte kommandoene og spørringsbehandlerne er brukbare i kontrollere. Følgende kode er implementeringen av en innlegg kontroller som godtar HTTP-forespørsler og returnerer nødvendige svar.

// posts.controller.ts
import { Body, Controller, Post } fra'@nestjs/common';
import { CommandBus } fra'@nestjs/cqrs';
import { CreatePostCommand } fra'./createPostCommand.command.ts';
// kontroller som implementerer kommando
@Kontroller('innlegg')
eksportklasse PostController {
konstruktør(privat skrivebeskyttet commandBus: CommandBus) {}
@Post()
asynkron opprette Post(@Kropp() body: { title: streng; innhold: streng }) {
konst { tittel, innhold } = brødtekst;
konst kommando = ny CreatePostCommand (tittel, innhold);
konst innlegg = avventedette.commandBus.execute (kommando);
komme tilbake post;
 }
}

I koden ovenfor er det CommandBus utfører CreatePostCommand og oppretter et nytt innlegg.

Denne koden viser hvordan du implementerer en kontroller som bruker en spørring:

// posts.controller.ts
import { Controller, Get, Param } fra'@nestjs/common';
import { QueryBus } fra'@nestjs/cqrs';
import { GetPostQuery } fra'./getPostQuery.query';
@Kontroller('innlegg')
eksportklasse PostController {
konstruktør(privat skrivebeskyttet queryBus: QueryBus) {}
@Få(':id')
asynkron getPost(@Param('id') id: Antall) {
konst spørring = ny GetPostQuery (id);
konst innlegg = avventedette.queryBus.execute (spørring);
komme tilbake post;
 }
}

De queryBus henretter GetPostQuery som får innlegget med den oppgitte IDen og returnerer det.

Etter å ha fullført alle trinnene ovenfor, bør du nå ha en minimalistisk, fungerende applikasjon for å lage og hente blogginnlegg.

Selv om koden her bruker en matrise for å lagre de opprettede innleggene i minnet, er det mer sannsynlig at du bruker en database i produksjonen. Du kan enten bruke en SQL database, eller en NoSQL-database som MongoDB, da NestJS støtter begge alternativene.

Bygge APIer med CQRS-designmønsteret

Å inkludere CQRS-designmønsteret i NestJS-applikasjonen din kan hjelpe med skalerbarhet, ytelse og vedlikehold. CQRS gir mulighet for mer effektive og optimaliserte operasjoner ved å skille lese- og skriveoperasjonene en applikasjon utfører.

@nestjs/cqrs-pakken gir en byggestein for implementering av CQRS i NestJS med kommandoer og spørringsbehandlere. Totalt sett er CQRS et kraftig mønster som kan bidra til å skape mer effektive og skalerbare applikasjoner, og du bør veie opp alternativene dine før du bruker det.