Utilisez le modèle CQRS avec précaution et vous pourrez créer des applications Nest plus propres et plus évolutives.

Une approche courante du développement NestJS consiste à créer des services avec lesquels les contrôleurs communiquent pour accéder aux données. Mais cette approche n'est pas le seul modèle de conception valide dans NestJS. Il existe d'autres modèles de conception, tels que le modèle de conception CQRS.

CQRS est un modèle de conception qui sépare les opérations de lecture et d'écriture d'une application. Cette séparation peut contribuer à améliorer l'évolutivité, les performances et la maintenabilité.

Découvrez tout sur CQRS et comment vous pouvez l'appliquer lors de la création d'une API NestJS.

Qu'est-ce que le CQRS?

CQRS représente Ségrégation des responsabilités entre commandes et requêtes. Il met en œuvre l'utilisation de commandes pour créer, mettre à jour et supprimer des données et requêtes pour récupérer des données. Cela permet d'éliminer le besoin d'implémenter les appels de base de données d'une application dans les services.

instagram viewer

Il permet également une distinction claire entre la logique d'interrogation de la base de données pour les données et l'exécution d'autres actions dans une application.

L'approche CQRS est utile pour conception axée sur le domaine, qui vous permet de séparer la logique de domaine et les opérations d'infrastructure dans votre application. Vous pouvez également l'utiliser pour implémenter une logique métier complexe, mais cela n'est pas recommandé pour les applications plus simples.

Utiliser CQRS dans une API NestJS

Vous pouvez utiliser le modèle de conception CQRS dans une API que vous créez dans NestJS. Pour suivre, vous devez avoir Node.js installé sur votre ordinateur et une version récente de NestJS.

Utilisez les étapes suivantes pour créer une application de blog simple qui implémente le modèle de conception CQRS.

Créer un projet Nest

Créez un nouveau projet Nest et générez un poste ressource pour une application de blog. Vous pouvez le faire en exécutant les commandes suivantes dans un terminal :

nid nouveau nestjs-cqrs
imbriquer les messages du module g
postes de contrôleur nest g
postes de service nest g

Installer les dépendances

Une fois que vous avez terminé les étapes ci-dessus, exécutez cette commande de terminal pour installer le package NestJS CQRS :

npm install --save @nestjs/cqrs

Créer un service de poste

Ajoutez le code suivant à votre postes.service.ts fichier pour définir le Service Poste classe.

// postes.service.ts
importer { Injectables } depuis'@nestjs/commun';
exporterinterface Poste {
 titre: chaîne;
 contenu: chaîne;
}


@Injectable()
exporterclasse Service Poste {
privé Messages en lecture seule: Post[] = [] ;


 créer (publier: Publier): Publier {
ce.posts.push (poster);
retour poste;
 }
 findById (identifiant: nombre): Poste {
retource.messages.trouver(poste => post.id id);
 }
}

Le Service Poste définit créer et findById méthodes pour créer un nouveau message et obtenir un message existant à partir de son ID.

Définir les commandes et les requêtes

L'étape suivante consiste à définir les requêtes et les commandes qui sont au cœur du modèle de conception CQRS.

Dans le des postes répertoire, créez deux nouveaux fichiers: créerPostCommand.command.ts et getPostQuery.query.ts. Le fichier de commandes devrait ressembler à ceci :

// createPostCommand.command.ts
exporterclasse CreatePostCommand {
constructeur(public titre en lecture seule: chaîne, public contenu en lecture seule: chaîne) {}
}

Et le fichier de définition de requête, comme ceci :

// getPostQuery.query.ts
exporterclasse GetPostQuery {
constructeur(public identifiant en lecture seule: nombre) {}
}

Créer des gestionnaires de commandes et de requêtes

Une fois que vous avez défini avec succès vos commandes et vos requêtes, vous devez créer des gestionnaires pour celles-ci. Un gestionnaire est une fonction qui exécute une commande ou une requête et renvoie le résultat.

Créer un gestionnaires.ts fichier dans votre poste répertoire et collez-y le code suivant :

// gestionnaires.ts
importer { CommandHandler, ICommandHandler } depuis'@nestjs/cqrs';
importer {CreatePostCommand} depuis'./createPostCommand.command.ts';
importer { Service Poste } depuis'./service Poste';
@CommandHandler(CréerPostCommande)
exporterclasse CreatePostHandler met en oeuvre ICommandHandler {
constructeur(privé postService en lecture seule: PostService) {}
asynchrone exécuter (commande: CreatePostCommand) {
constante { nom, prix } = commande ;
constante poste = attendrece.postService.create (titre, contenu) ;
retour poste;
 }
}

Dans le même gestionnaires.ts fichier, vous pouvez modifier les instructions d'importation pour inclure celles ci-dessous, pour permettre de travailler avec des requêtes. Vous pouvez ensuite implémenter le gestionnaire de requêtes comme indiqué dans le code ci-dessous :

// gestionnaire.ts
importer { QueryHandler, IQueryHandler } depuis'@nestjs/cqrs';
importer { GetPostQuery} depuis'./getPostQuery.query';
importer { Service Poste } depuis'./service Poste';
// gestionnaire de requêtes
@QueryHandler(GetProductQuery)
exporterclasse GetPostHandler met en oeuvre IQueryHandler {
constructeur(privé postService en lecture seule: PostService) {}
asynchrone exécuter (requête: GetPostQuery) {
constante { id } = requête ;
constante poste = attendrece.postService.findOneById (identifiant) ;
retour poste;
 }
}

Enregistrer les gestionnaires

La dernière étape consiste à enregistrer les gestionnaires de commandes et de requêtes avec le module NestJS.

// post.module.ts
importer { Module } depuis'@nestjs/commun';
importer { CommandHandlers, QueryHandlers } depuis'handlers.ts';
importer { Service Poste } depuis'./service Poste';
@Module({
 fournisseurs: [
 Service Poste,
 ...gestionnaires de commandes,
 ...gestionnaires de requêtes,
 ],
})
exporterclasse PostModule {}

Ce code enregistre le Service Poste, CommandHandlers, et QueryHandlers dans le fournisseurs déployer. L'utilisation d'un opérateur de propagation (...) consiste à fusionner les tableaux de mettre en doute manutentionnaires et commande gestionnaires dans le fournisseurs déployer.

Exécuter des commandes et des requêtes

Les commandes enregistrées et les gestionnaires de requêtes sont utilisables dans les contrôleurs. Le code suivant est l'implémentation d'un des postes contrôleur qui acceptera les requêtes HTTP et renverra les réponses requises.

// postes.contrôleur.ts
importer { Corps, Contrôleur, Message } depuis'@nestjs/commun';
importer { CommandBus } depuis'@nestjs/cqrs';
importer {CreatePostCommand} depuis'./createPostCommand.command.ts';
// contrôleur qui implémente la commande
@Manette('des postes')
exporterclasse PostController {
constructeur(privé bus de commande en lecture seule: bus de commande) {}
@Poste()
asynchrone créerPost(@Corps() corps: { titre: chaîne; contenu: chaîne }) {
constante { titre, contenu } = corps ;
constante commande = nouveau CreatePostCommand (titre, contenu) ;
constante poste = attendrece.commandBus.execute (commande);
retour poste;
 }
}

Dans le code ci-dessus, le CommandBus exécute le CreatePostCommand et crée un nouveau poste.

Ce code montre comment implémenter un contrôleur qui utilise une requête :

// postes.contrôleur.ts
importer { Contrôleur, Obtenir, Paramètre } depuis'@nestjs/commun';
importer { QueryBus } depuis'@nestjs/cqrs';
importer { GetPostQuery} depuis'./getPostQuery.query';
@Manette('des postes')
exporterclasse PostController {
constructeur(privé queryBus en lecture seule: QueryBus) {}
@Obtenir(':identifiant')
asynchrone getPost(@Param('identifiant') identifiant: nombre) {
constante requête = nouveau GetPostQuery (identifiant);
constante poste = attendrece.queryBus.execute (requête);
retour poste;
 }
}

Le queryBus exécute GetPostQuery qui récupère le message avec l'ID donné et le renvoie.

Après avoir terminé toutes les étapes ci-dessus, vous devriez maintenant avoir une application minimaliste et fonctionnelle pour créer et récupérer des articles de blog.

Bien que le code ici utilise un tableau pour stocker les publications créées en mémoire, vous êtes plus susceptible d'utiliser une base de données en production. Vous pouvez soit utiliser un Base de données SQL, ou un Base de données NoSQL comme MongoDB, car NestJS prend en charge les deux options.

Création d'API avec le modèle de conception CQRS

L'intégration du modèle de conception CQRS dans votre application NestJS peut contribuer à l'évolutivité, aux performances et à la maintenabilité. CQRS permet des opérations plus efficaces et optimisées en séparant les opérations de lecture et d'écriture effectuées par une application.

Le package @nestjs/cqrs fournit un bloc de construction pour la mise en œuvre de CQRS dans NestJS avec des commandes et des gestionnaires de requêtes. Dans l'ensemble, CQRS est un modèle puissant qui peut aider à créer des applications plus efficaces et évolutives, et vous devez peser vos options avant de l'utiliser.