Un'introduzione a CQRS in NestJS

Un approccio comune allo sviluppo di NestJS consiste nel creare servizi con cui i controller comunicano per accedere ai dati. Ma questo approccio non è l'unico modello di progettazione valido in NestJS. Esistono altri modelli di progettazione, come il modello di progettazione CQRS.

CQRS è un modello di progettazione che separa le operazioni di lettura e scrittura di un'applicazione. Questa separazione può contribuire a migliorare la scalabilità, le prestazioni e la manutenibilità.

Scopri tutto su CQRS e su come applicarlo durante la creazione di un'API NestJS.

Che cos'è CQRS?

CQRS sta per segregazione della responsabilità della query di comando. Implementa l'uso di comandi creare, aggiornare e cancellare dati e interrogazioni per recuperare i dati. Ciò consente di eliminare la necessità di implementare le chiamate al database di un'applicazione nei servizi.

Consente inoltre una chiara distinzione tra la logica di interrogare il database per i dati e l'esecuzione di altre azioni in un'applicazione.

L'approccio CQRS è utile in progettazione guidata dal dominio, che consente di separare la logica del dominio e le operazioni infrastrutturali nell'applicazione. Puoi anche usarlo per implementare logiche di business complesse, ma non è consigliato per applicazioni più semplici.

Utilizzo di CQRS in un'API NestJS

Puoi utilizzare il modello di progettazione CQRS in un'API creata in NestJS. Per seguire, devi avere Node.js installato sul tuo computer e una versione recente di NestJS.

Utilizzare i passaggi seguenti per creare una semplice applicazione di blog che implementa il modello di progettazione CQRS.

Crea un progetto Nest

Crea un nuovo progetto Nest e genera un file inviare risorsa per un'applicazione blog. Puoi farlo eseguendo i seguenti comandi in un terminale:

nest new nestjs-cqrs
post del modulo nest g
post del controller nest g
posti di servizio nido g

Installa dipendenze

Dopo aver completato i passaggi precedenti, esegui questo comando da terminale per installare il pacchetto NestJS CQRS:

npm install --save @nestjs/cqrs

Crea un servizio postale

Aggiungi il seguente codice al tuo posts.service.ts file per definire il Servizio Postale classe.

// posts.service.ts
importare { Iniettabile } da'@nestjs/comune';
esportareinterfaccia Inviare {
 titolo: corda;
 contenuto: corda;
}
@Iniettabile()
esportareclasse PostService {
privato post di sola lettura: Post[] = [];
 create (post: Post): Post {
Questo.posts.push (posta);
ritorno inviare;
 }
 findById (id: numero): Inviare {
ritornoQuesto.posts.find(inviare => post.id id);
 }
}

IL Servizio Postale definisce creare E findById metodi per creare un nuovo post e ottenere un post esistente dal suo ID.

Definisci comandi e query

Il passaggio successivo consiste nel definire le query e i comandi fondamentali per il modello di progettazione CQRS.

Nel post directory, creare due nuovi file: creare PostCommand.command.ts E getPostQuery.query.ts. Il file di comando dovrebbe assomigliare a questo:

// createPostCommand.command.ts
esportareclasse CreatePostCommand {
costruttore(pubblico titolo di sola lettura: corda, pubblico contenuto di sola lettura: corda) {}
}

E il file di definizione della query, in questo modo:

// getPostQuery.query.ts
esportareclasse GetPostQuery {
costruttore(pubblico ID di sola lettura: numero) {}
}

Creare gestori di comandi e query

Dopo aver definito correttamente i comandi e le query, è necessario creare i relativi gestori. Un gestore è una funzione che esegue un comando o una query e restituisce il risultato.

Creare un gestori.ts file nel tuo inviare directory e incollare il seguente codice al suo interno:

// gestori.ts
importare {CommandHandler, ICommandHandler} da'@nestjs/cqrs';
importare { CreaPostComando } da'./createPostCommand.command.ts';
importare { Servizio Postale } da'./post.servizio';
@CommandHandler(CreatePostCommand)
esportareclasse CreatePostHandler implementa ICommandHandler {
costruttore(privato sola lettura postService: PostService) {}
asincrono esegui (comando: CreatePostCommand) {
cost { nome, prezzo } = comando;
cost posta = aspettaQuesto.postService.create (titolo, contenuto);
ritorno inviare;
 }
}

Nello stesso gestori.ts file, è possibile modificare le istruzioni di importazione per includere quelle seguenti, per consentire di lavorare con le query. È quindi possibile implementare il gestore di query come mostrato nel codice seguente:

// gestore.ts
importare {QueryHandler, IQueryHandler} da'@nestjs/cqrs';
importare { GetPostQuery } da'./getPostQuery.query';
importare { Servizio Postale } da'./post.servizio';
// gestore di query
@QueryHandler(OttieniQueryProdotto)
esportareclasse GetPostHandler implementa IQueryHandler {
costruttore(privato sola lettura postService: PostService) {}
asincrono esegui (query: GetPostQuery) {
cost { id } = interrogazione;
cost posta = aspettaQuesto.postService.findOneById (id);
ritorno inviare;
 }
}

Registrati Gestori

L'ultimo passaggio consiste nel registrare i gestori di comandi e query con il modulo NestJS.

// post.modulo.ts
importare { Modulo } da'@nestjs/comune';
importare { CommandHandler, QueryHandler } da'gestori.ts';
importare { Servizio Postale } da'./post.servizio';
@Modulo({
 fornitori: [
 Servizio Postale,
 ...CommandHandler,
 ...QueryHandler,
 ],
})
esportareclasse PostModulo {}

Questo codice registra il Servizio Postale, CommandHandler, E QueryHandler nel fornitori vettore. L'uso di un operatore di diffusione (...) consiste nell'unire gli array di domanda gestori e comando gestori nel fornitori vettore.

Eseguire comandi e query

I comandi registrati e i gestori di query sono utilizzabili nei controller. Il codice seguente è l'implementazione di a post controller che accetterà le richieste HTTP e restituirà le risposte richieste.

// posts.controller.ts
importare { Corpo, Controller, Post } da'@nestjs/comune';
importare { Bus di comando } da'@nestjs/cqrs';
importare { CreaPostComando } da'./createPostCommand.command.ts';
// controller che implementa il comando
@Controller('post')
esportareclasse PostController {
costruttore(privato commandBus di sola lettura: CommandBus) {}
@Inviare()
asincrono crearePost(@Corpo() corpo: { titolo: corda; contenuto: corda }) {
cost { titolo, contenuto } = corpo;
cost comando = nuovo CreatePostCommand (titolo, contenuto);
cost posta = aspettaQuesto.commandBus.execute (comando);
ritorno inviare;
 }
}

Nel codice sopra, il Bus di comando esegue il CreatePostCommand e crea un nuovo post.

Questo codice mostra come implementare un controller che utilizza una query:

// posts.controller.ts
importare { Controller, Get, Param } da'@nestjs/comune';
importare {Bus di query} da'@nestjs/cqrs';
importare { GetPostQuery } da'./getPostQuery.query';
@Controller('post')
esportareclasse PostController {
costruttore(privato sola lettura queryBus: QueryBus) {}
@Ottenere(':id')
asincrono getPost(@Param('id') id: numero) {
cost domanda = nuovo GetPostQuery (id);
cost posta = aspettaQuesto.queryBus.execute (interrogazione);
ritorno inviare;
 }
}

IL queryBus esegue GetPostQuery che ottiene il post con l'ID fornito e lo restituisce.

Dopo aver completato tutti i passaggi precedenti, ora dovresti disporre di un'applicazione funzionante e minimalista per creare e recuperare post di blog.

Sebbene il codice qui utilizzi un array per memorizzare i post creati in memoria, è più probabile che tu utilizzi un database in produzione. Puoi usare a banca dati SQL, o un Database NoSQL come MongoDB, poiché NestJS supporta entrambe le opzioni.

Creazione di API con il modello di progettazione CQRS

L'incorporazione del modello di progettazione CQRS nella tua applicazione NestJS può favorire la scalabilità, le prestazioni e la manutenibilità. CQRS consente operazioni più efficienti e ottimizzate separando le operazioni di lettura e scrittura eseguite da un'applicazione.

Il pacchetto @nestjs/cqrs fornisce un blocco predefinito per l'implementazione di CQRS in NestJS con comandi e gestori di query. Nel complesso, CQRS è un modello potente che può aiutare a creare applicazioni più efficienti e scalabili e dovresti valutare le tue opzioni prima di usarlo.