Una introducción a CQRS en NestJS

Un enfoque común para el desarrollo de NestJS es crear servicios con los que los controladores se comuniquen para acceder a los datos. Pero este enfoque no es el único patrón de diseño válido en NestJS. Hay otros patrones de diseño, como el patrón de diseño CQRS.

CQRS es un patrón de diseño que separa las operaciones de lectura y escritura de una aplicación. Esta separación puede ayudar a mejorar la escalabilidad, el rendimiento y la capacidad de mantenimiento.

Descubra todo sobre CQRS y cómo puede aplicarlo al crear una API de NestJS.

¿Qué es CQRS?

CQRS representa segregación de responsabilidad de consulta de comando. Implementa el uso de comandos para crear, actualizar y eliminar datos y consultas para obtener datos. Esto ayuda a eliminar la necesidad de implementar las llamadas a la base de datos de una aplicación en los servicios.

También permite una distinción clara entre la lógica de consultar la base de datos en busca de datos y realizar otras acciones en una aplicación.

El enfoque CQRS es útil en diseño dirigido por dominio, que le permite separar la lógica del dominio y las operaciones de infraestructura en su aplicación. También puede usarlo para implementar una lógica empresarial compleja, pero esto no se recomienda para aplicaciones más simples.

Usando CQRS en una API de NestJS

Puede usar el patrón de diseño CQRS en una API que cree en NestJS. Para seguir, necesitas tener Node.js instalado en su computadora y una versión reciente de NestJS.

Utilice los siguientes pasos para crear una aplicación de blog simple que implemente el patrón de diseño CQRS.

Crear un proyecto de nido

Cree un nuevo proyecto de Nest y genere un correo recurso para una aplicación de blog. Puede hacer esto ejecutando los siguientes comandos en una terminal:

anidar nuevo nestjs-cqrs
postes del módulo nest g
Postes del controlador Nest G
nido g puestos de servicio

Instalar dependencias

Una vez que haya completado los pasos anteriores, ejecute este comando de terminal para instalar el paquete NestJS CQRS:

instalación npm --guardar @nestjs/cqrs

Crear un servicio de publicación

Agregue el siguiente código a su puestos.servicio.ts archivo para definir el Servicio Postal clase.

// publicaciones.servicio.ts
importar { Inyectable } de'@nestjs/común';
exportarinterfaz Correo {
 título: cadena;
 contenido: cadena;
}
@Inyectable()
exportarclase Servicio Postal {
privado publicaciones de solo lectura: publicación [] = [];
 crear (publicar: Publicar): Publicar {
este.posts.push (publicación);
devolver correo;
 }
 findById (id: número): Correo {
devolvereste.posts.find(correo => id de post.id);
 }
}

El Servicio Postal define crear y encontrar por Id métodos para crear una nueva publicación y obtener una publicación existente de su ID.

Definir comandos y consultas

El siguiente paso es definir las consultas y los comandos que son fundamentales para el patrón de diseño de CQRS.

En el publicaciones directorio, cree dos nuevos archivos: crearPostCommand.command.ts y getPostQuery.query.ts. El archivo de comando debería verse así:

// crearPostCommand.command.ts
exportarclase CreatePostCommand {
constructor(público título de solo lectura: cadena, público contenido de solo lectura: cadena) {}
}

Y el archivo de definición de consulta, así:

// getPostQuery.query.ts
exportarclase ObtenerPostConsulta {
constructor(público ID de solo lectura: número) {}
}

Crear controladores de comandos y consultas

Una vez que haya definido correctamente sus comandos y consultas, debe crear controladores para ellos. Un controlador es una función que ejecuta un comando o consulta y devuelve el resultado.

Crear un handlers.ts archivo en su correo directorio y pegue el siguiente código en él:

// manejadores.ts
importar { Controlador de comandos, IControlador de comandos } de'@nestjs/cqrs';
importar { CreatePostCommand } de'./createPostCommand.command.ts';
importar { Servicio Postal } de'./servicio Postal';
@CommandHandler(Crear PostComando)
exportarclase CreatePostHandler implementos ICommandHandler {
constructor(privado Servicio de publicación de solo lectura: Servicio de publicación) {}
asíncrono ejecutar (comando: CreatePostCommand) {
constante { nombre, precio } = comando;
constante publicar = esperareste.postService.create (título, contenido);
devolver correo;
 }
}

En el mismo handlers.ts archivo, puede modificar las declaraciones de importación para incluir las siguientes, para permitir trabajar con consultas. Luego puede implementar el controlador de consultas como se ve en el siguiente código:

// controlador.ts
importar { Controlador de consultas, Controlador de consultas } de'@nestjs/cqrs';
importar { GetPostQuery } de'./getPostQuery.consulta';
importar { Servicio Postal } de'./servicio Postal';
// manejador de consultas
@QueryHandler(Obtener consulta de producto)
exportarclase GetPostHandler implementos IQueryHandler {
constructor(privado Servicio de publicación de solo lectura: Servicio de publicación) {}
asíncrono ejecutar (consulta: GetPostQuery) {
constante { id } = consulta;
constante publicar = esperareste.postService.findOneById (id);
devolver correo;
 }
}

Controladores de registro

El último paso es registrar los controladores de comandos y consultas con el módulo NestJS.

// post.módulo.ts
importar { Módulo } de'@nestjs/común';
importar { Manejadores de comandos, Manejadores de consultas } de'controladores.ts';
importar { Servicio Postal } de'./servicio Postal';
@Módulo({
 proveedores: [
 Servicio Postal,
 ...Manejadores de comandos,
 ...Manejadores de consultas,
 ],
})
exportarclase Módulo posterior {}

Este código registra el Servicio Postal, Controladores de comandos, y Controladores de consulta en el proveedores formación. El uso de un operador de propagación (...) es fusionar las matrices de consulta manipuladores y dominio manipuladores en el proveedores formación.

Ejecutar Comandos y Consultas

Los comandos registrados y los controladores de consultas se pueden usar en los controladores. El siguiente código es la implementación de un publicaciones controlador que aceptará solicitudes HTTP y devolverá las respuestas requeridas.

// publicaciones.controlador.ts
importar { Cuerpo, Controlador, Publicación } de'@nestjs/común';
importar {CommandBus} de'@nestjs/cqrs';
importar { CreatePostCommand } de'./createPostCommand.command.ts';
// controlador que implementa el comando
@Controlador('publicaciones')
exportarclase PostController {
constructor(privado CommandBus de solo lectura: CommandBus) {}
@Correo()
asíncrono crearPublicación(@Cuerpo() cuerpo: {título: cadena; contenido: cadena }) {
constante {título, contenido} = cuerpo;
constante comando = nuevo CreatePostCommand (título, contenido);
constante publicar = esperareste.commandBus.ejecutar (comando);
devolver correo;
 }
}

En el código anterior, el ComandoBus ejecuta el CreatePostCommand y crea una nueva publicación.

Este código muestra cómo implementar un controlador que utiliza una consulta:

// publicaciones.controlador.ts
importar { Controlador, Obtener, Param } de'@nestjs/común';
importar { Bus de consulta } de'@nestjs/cqrs';
importar { GetPostQuery } de'./getPostQuery.consulta';
@Controlador('publicaciones')
exportarclase PostController {
constructor(privado Bus de consulta de solo lectura: Bus de consulta) {}
@Conseguir(':identificación')
asíncrono obtenerPublicación(@Param('identificación') identificación: número) {
constante consulta = nuevo GetPostQuery (id);
constante publicar = esperareste.queryBus.ejecutar (consulta);
devolver correo;
 }
}

El consultaBus ejecuta GetPostQuery que obtiene la publicación con la ID dada y la devuelve.

Después de completar todos los pasos anteriores, ahora debería tener una aplicación funcional y minimalista para crear y obtener publicaciones de blog.

Aunque el código aquí usa una matriz para almacenar las publicaciones creadas en la memoria, es más probable que use una base de datos en producción. Puedes usar un base de datos SQL, o un Base de datos NoSQL como MongoDB, ya que NestJS admite ambas opciones.

Creación de API con el patrón de diseño CQRS

La incorporación del patrón de diseño CQRS en su aplicación NestJS puede ayudar en la escalabilidad, el rendimiento y la capacidad de mantenimiento. CQRS permite operaciones más eficientes y optimizadas al separar las operaciones de lectura y escritura que lleva a cabo una aplicación.

El paquete @nestjs/cqrs proporciona un componente básico para implementar CQRS en NestJS con comandos y controladores de consultas. En general, CQRS es un patrón poderoso que puede ayudar a crear aplicaciones más eficientes y escalables, y debe sopesar sus opciones antes de usarlo.