Uma introdução ao CQRS no NestJS

Uma abordagem comum para o desenvolvimento do NestJS é criar serviços com os quais os controladores se comunicam para acessar os dados. Mas essa abordagem não é o único padrão de design válido no NestJS. Existem outros padrões de design, como o padrão de design CQRS.

CQRS é um padrão de design que separa as operações de leitura e gravação de um aplicativo. Essa separação pode ajudar a melhorar a escalabilidade, o desempenho e a capacidade de manutenção.

Descubra tudo sobre o CQRS e como aplicá-lo ao criar uma API NestJS.

O que é CQRS?

CQRS apoia segregação de responsabilidade de consulta de comando. Ele implementa o uso de comandos para criar, atualizar e excluir dados e consultas para buscar dados. Isso ajuda a eliminar a necessidade de implementar chamadas de banco de dados de um aplicativo em serviços.

Ele também permite uma distinção clara entre a lógica de consultar o banco de dados em busca de dados e executar outras ações em um aplicativo.

A abordagem CQRS é útil em design orientado a domínio, que permite separar a lógica de domínio e as operações de infraestrutura em seu aplicativo. Você também pode usá-lo para implementar lógica de negócios complexa, mas isso não é recomendado para aplicativos mais simples.

Usando CQRS em uma API NestJS

Você pode usar o padrão de design CQRS em uma API construída no NestJS. Para acompanhar, você precisa ter Node.js instalado em seu computador e uma versão recente do NestJS.

Use as etapas a seguir para criar um aplicativo de blog simples que implemente o padrão de design CQRS.

Criar um Projeto Nest

Crie um novo projeto Nest e gere um publicar recurso para um aplicativo de blog. Você pode fazer isso executando os seguintes comandos em um terminal:

aninhar novo nestjs-cqrs
postagens do módulo nest g
postagens do controlador ninho g
Postos de serviço Nest G

Instalar dependências

Depois de concluir as etapas acima, execute este comando de terminal para instalar o pacote NestJS CQRS:

npm install --save @nestjs/cqrs

Criar um serviço postal

Adicione o seguinte código ao seu posts.service.ts arquivo para definir o Correios aula.

// posts.service.ts
importar { Injetável } de'@nestjs/common';
exportarinterface Publicar {
 título: corda;
 contente: corda;
}
@Injetável()
exportaraula Correios {
privado postagens somente leitura: Post[] = [];
 criar (postagem: Postar): Postar {
esse.postagens.push (postagem);
retornar publicar;
 }
 encontrarById (id: número): Publicar {
retornaresse.posts.find(publicar => post.id id);
 }
}

O Correios define criar e findById métodos para criar uma nova postagem e obter uma postagem existente de seu ID.

Definir comandos e consultas

A próxima etapa é definir as consultas e comandos que são essenciais para o padrão de design CQRS.

No Postagens diretório, crie dois novos arquivos: criarPostCommand.command.ts e getPostQuery.query.ts. O arquivo de comando deve ficar assim:

// createPostCommand.command.ts
exportaraula CreatePostCommand {
construtor(público título somente leitura: corda, público conteúdo somente leitura: corda) {}
}

E o arquivo de definição de consulta, assim:

// getPostQuery.query.ts
exportaraula GetPostQuery {
construtor(público id somente leitura: número) {}
}

Criar manipuladores de comandos e consultas

Depois de definir com sucesso seus comandos e consultas, você precisa criar manipuladores para eles. Um manipulador é uma função que executa um comando ou consulta e retorna o resultado.

Criar uma handlers.ts arquivo em seu publicar diretório e cole o seguinte código nele:

// handlers.ts
importar { CommandHandler, ICommandHandler } de'@nestjs/cqrs';
importar { CreatePostCommand } de'./createPostCommand.command.ts';
importar { Correios } de'./Correios';
@CommandHandler(CreatePostCommand)
exportaraula CreatePostHandler implementos ICommandHandler {
construtor(privado readonly postService: PostService) {}
assíncrono execute (comando: CreatePostCommand) {
const { nome, preço } = comando;
const postar = aguardamesse.postService.create (título, conteúdo);
retornar publicar;
 }
}

No mesmo handlers.ts arquivo, você pode modificar as instruções de importação para incluir as abaixo, para permitir o trabalho com consultas. Você pode então implementar o manipulador de consulta como visto no código abaixo:

// manipulador.ts
importar { QueryHandler, IQueryHandler } de'@nestjs/cqrs';
importar { GetPostQuery } de'./getPostQuery.query';
importar { Correios } de'./Correios';
// manipulador de consultas
@QueryHandler(GetProductQuery)
exportaraula GetPostHandler implementos IQueryHandler {
construtor(privado readonly postService: PostService) {}
assíncrono executar (consulta: GetPostQuery) {
const { id } = consulta;
const postar = aguardamesse.postService.findOneById (id);
retornar publicar;
 }
}

Manipuladores de registro

A última etapa é registrar os manipuladores de comando e consulta com o módulo NestJS.

// post.module.ts
importar { Módulo } de'@nestjs/common';
importar { CommandHandlers, QueryHandlers } de'manipuladores.ts';
importar { Correios } de'./Correios';
@Módulo({
 provedores: [
 Correios,
 ...CommandHandlers,
 ...QueryHandlers,
 ],
})
exportaraula Pós-módulo {}

Este código registra o Correios, CommandHandlers, e QueryHandlers no provedores variedade. O uso de um operador de spread (...) é mesclar as matrizes de consulta manipuladores e comando manipuladores no provedores variedade.

Executar comandos e consultas

Os comandos registrados e manipuladores de consulta podem ser usados ​​em controladores. O código a seguir é a implementação de um Postagens controlador que aceitará solicitações HTTP e retornará as respostas necessárias.

// posts.controller.ts
importar { Corpo, controlador, posto } de'@nestjs/common';
importar { ComandoBus } de'@nestjs/cqrs';
importar { CreatePostCommand } de'./createPostCommand.command.ts';
// controlador que implementa o comando
@Controlador('Postagens')
exportaraula PostController {
construtor(privado commandBus somente leitura: CommandBus) {}
@Publicar()
assíncrono criarPost(@Corpo() corpo: { título: corda; contente: corda }) {
const { título, conteúdo } = corpo;
const comando = novo CreatePostCommand (título, conteúdo);
const postar = aguardamesse.commandBus.execute (comando);
retornar publicar;
 }
}

No código acima, o CommandBus executa o CreatePostCommand e cria uma nova postagem.

Este código mostra como implementar um controlador que usa uma consulta:

// posts.controller.ts
importar { Controlador, Obter, Param } de'@nestjs/common';
importar { ConsultaBus } de'@nestjs/cqrs';
importar { GetPostQuery } de'./getPostQuery.query';
@Controlador('Postagens')
exportaraula PostController {
construtor(privado queryBus somente leitura: QueryBus) {}
@Pegar(':eu ia')
assíncrono getPost(@Param('eu ia') eu ia: número) {
const consulta = novo GetPostQuery (id);
const postar = aguardamesse.queryBus.execute (consulta);
retornar publicar;
 }
}

O queryBus executa GetPostQuery que obtém a postagem com o ID fornecido e a retorna.

Depois de concluir todas as etapas acima, agora você deve ter um aplicativo minimalista e funcional para criar e buscar postagens de blog.

Embora o código aqui use um array para armazenar os posts criados na memória, é mais provável que você use um banco de dados em produção. Você pode usar um banco de dados SQL, ou um Banco de dados NoSQL como MongoDB, pois o NestJS oferece suporte a ambas as opções.

Construindo APIs com o Padrão de Design CQRS

A incorporação do padrão de design CQRS em seu aplicativo NestJS pode ajudar na escalabilidade, desempenho e capacidade de manutenção. O CQRS permite operações mais eficientes e otimizadas, separando as operações de leitura e gravação que um aplicativo realiza.

O pacote @nestjs/cqrs fornece um bloco de construção para implementar o CQRS no NestJS com comandos e manipuladores de consulta. No geral, o CQRS é um padrão poderoso que pode ajudar a criar aplicativos mais eficientes e escaláveis, e você deve avaliar suas opções antes de usá-lo.