Que sont les événements ?

Les événements sont des signaux ou des notifications qui indiquent qu'une action ou un changement d'état s'est produit. Dans le cadre des applications, les événements permettent à différentes parties du système de communiquer de manière asynchrone et découplée. Ceci est particulièrement utile dans les architectures de microservices, où vous avez besoin que les composants fonctionnent de manière indépendante tout en étant capables « d'écouter » et de réagir aux changements qui se produisent ailleurs dans le système.

Événements dans NestJS

Dans NestJS, l'implémentation des événements se fait de manière simple et intuitive à l'aide de la bibliothèque EventEmitter2, qui est une extension du EventEmitter natif Node.js, avec plus de fonctionnalités. Voyons ensuite comment configurer et utiliser les événements dans NestJS.

Configuration des événements dans NestJS

Tout d'abord, vous devez installer le package @nestjs/event-emitter, qui offre une intégration complète d'EventEmitter2 avec NestJS :

npm install @nestjs/event-emitter

Après avoir installé le package, importez le module EventEmitterModule dans le module principal de votre application :

import { Module } from '@nestjs/common';
import { EventEmitterModule } from '@nestjs/event-emitter';

@Module({
  imports: [
    EventEmitterModule.forRoot(), // Importando o EventEmitterModule
    // outros módulos
  ],
})
export class AppModule {}

Une fois le module configuré, vous pouvez commencer à créer et gérer des événements dans votre application.

Création et émission d'événements

Créons un exemple de base dans lequel un événement est émis lorsqu'un nouvel utilisateur est créé.

1. Créer un événement :

Tout d'abord, nous définissons une classe pour représenter notre événement :

export class UserCreatedEvent {
  constructor(
    public readonly userId: string,
    public readonly email: string,
  ) {}
}

2. Émission de l'événement :

Dans le service où la logique de création d'utilisateur est implémentée, vous pouvez émettre l'événement après la création de l'utilisateur :

import { Injectable } from '@nestjs/common';
import { EventEmitter2 } from '@nestjs/event-emitter';
import { UserCreatedEvent } from './events/user-created.event';

@Injectable()
export class UserService {
  constructor(private readonly eventEmitter: EventEmitter2) {}

  async createUser(email: string) {
    // Lógica para criar o usuário
    const userId = '12345'; // Exemplo de ID gerado

    // Emitir o evento
    const event = new UserCreatedEvent(userId, email);
    this.eventEmitter.emit('user.created', event);
  }
}

Ici, l'événement user.created est émis chaque fois qu'un nouvel utilisateur est créé.

Écouter et répondre aux événements

Pour réagir aux événements émis, vous pouvez créer des auditeurs, qui sont des fonctions ou des méthodes qui seront appelées lorsque l'événement correspondant sera déclenché.

1. Création d'un écouteur :

Un auditeur est une classe qui réagit à un événement spécifique :

import { OnEvent } from '@nestjs/event-emitter';
import { Injectable } from '@nestjs/common';
import { UserCreatedEvent } from './events/user-created.event';

@Injectable()
export class UserCreatedListener {
  @OnEvent('user.created')
  handleUserCreatedEvent(event: UserCreatedEvent) {
    console.log('Usuário criado com sucesso:', event.userId, event.email);
    // Lógica adicional, como enviar um e-mail de boas-vindas
  }
}

2. Enregistrement de l'auditeur :

Pour que NestJS reconnaisse l'écouteur, celui-ci doit être enregistré dans le module correspondant :

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserCreatedListener } from './listeners/user-created.listener';

@Module({
  providers: [UserService, UserCreatedListener],
})
export class UserModule {}

Désormais, chaque fois que l'événement user.created est émis, la méthode handleUserCreatedEvent sera appelée.

Applications événementielles avancées

Les événements peuvent être utilisés dans divers scénarios pour améliorer l'architecture des applications :

1. Intégration avec les microservices : les événements sont un moyen efficace de communiquer entre les microservices, leur permettant de rester découplés.
2. Traitement asynchrone : vous pouvez émettre des événements pour effectuer des opérations en arrière-plan, telles que l'envoi d'e-mails ou le traitement de grandes quantités de données.
3. Journalisation et audit : les événements sont idéaux pour capturer les actions des utilisateurs et les événements système à des fins d'audit.

Conclusion

L'utilisation d'événements dans NestJS est un moyen puissant de créer des systèmes modulaires, évolutifs et faciles à entretenir. Grâce à l'intégration avec EventEmitter2, NestJS facilite la création, l'émission et l'écoute d'événements, vous permettant ainsi de mettre en œuvre des architectures basées sur les événements de manière simple et efficace. Que ce soit pour la communication entre microservices ou pour le traitement asynchrone, les événements sont un outil essentiel dans l'arsenal de tout développeur NestJS.