Шаблони подій у NestJS

npm install @nestjs/event-emitter eventemitter2

// app.module.ts
import { Module } from '@nestjs/common';
import { EventEmitterModule } from '@nestjs/event-emitter';
import { OrdersModule } from './orders/orders.module';

@Module({
  imports: [
    EventEmitterModule.forRoot(),
    OrdersModule,
  ],
})
export class AppModule {}

import { EventEmitter2 } from '@nestjs/event-emitter';

constructor(private readonly eventEmitter: EventEmitter2) {}

// orders/events/order-created.event.ts
export class OrderCreatedEvent {
  constructor(
    public readonly orderId: string,
    public readonly userId: string,
    public readonly total: number,
  ) {}
}

this.eventEmitter.emit(
  'order.created',
  new OrderCreatedEvent(order.id, order.userId, order.total),
);

resource.action

order.created
user.registered
payment.completed

order.created       // факт
send.order.email    // команда

// orders/listeners/order-created.listener.ts
import { Injectable } from '@nestjs/common';
import { OnEvent } from '@nestjs/event-emitter';
import { OrderCreatedEvent } from '../events/order-created.event';

@Injectable()
export class OrderCreatedListener {
  @OnEvent('order.created')
  async handleOrderCreated(event: OrderCreatedEvent): Promise<void> {
    await this.sendConfirmationEmail(event.userId, event.orderId);
  }

  private async sendConfirmationEmail(
    userId: string,
    orderId: string,
  ): Promise<void> {
    // Імітація асинхронної операції надсилання листа
    await new Promise((resolve) => setTimeout(resolve, 500));

    console.log(
      `Confirmation email sent to user ${userId} for order ${orderId}`,
    );
  }
}

// orders/orders.module.ts
import { Module } from '@nestjs/common';
import { OrderCreatedListener } from './listeners/order-created.listener';
import { OrdersService } from './orders.service';

@Module({
  providers: [
    OrdersService,
    OrderCreatedListener,
  ],
  exports: [OrdersService],
})
export class OrdersModule {}

// orders/orders.service.ts
import { Injectable } from '@nestjs/common';
import { EventEmitter2 } from '@nestjs/event-emitter';
import { randomUUID } from 'node:crypto';
import { OrderCreatedEvent } from './events/order-created.event';

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

  async createOrder(userId: string, total: number) {
    const order = {
      id: randomUUID(),
      userId,
      total,
    };

    // Подія запускає додаткові обробники,
    // але сервіс не очікує завершення їхньої роботи.
    this.eventEmitter.emit(
      'order.created',
      new OrderCreatedEvent(order.id, order.userId, order.total),
    );

    return order;
  }
}

await this.eventEmitter.emit('order.created', event);

// orders/orders.controller.ts
import { Body, Controller, Post } from '@nestjs/common';
import { OrdersService } from './orders.service';

@Controller('orders')
export class OrdersController {
  constructor(
    private readonly ordersService: OrdersService,
  ) {}

  @Post()
  createOrder(
    @Body() body: { userId: string; total: number },
  ) {
    return this.ordersService.createOrder(body.userId, body.total);
  }
}

// orders/listeners/order-audit.listener.ts
import { Injectable } from '@nestjs/common';
import { OnEvent } from '@nestjs/event-emitter';
import { OrderCreatedEvent } from '../events/order-created.event';

@Injectable()
export class OrderAuditListener {
  @OnEvent('order.created')
  handleOrderCreated(event: OrderCreatedEvent): void {
    console.log(
      `Audit: order ${event.orderId} was created by user ${event.userId}`,
    );
  }
}

@Module({
  providers: [
    OrdersService,
    OrderCreatedListener,
    OrderAuditListener,
  ],
  exports: [OrdersService],
})
export class OrdersModule {}

import { Injectable, Logger } from '@nestjs/common';
import { OnEvent } from '@nestjs/event-emitter';
import { OrderCreatedEvent } from '../events/order-created.event';

@Injectable()
export class OrderCreatedListener {
  private readonly logger = new Logger(OrderCreatedListener.name);

  @OnEvent('order.created')
  async handleOrderCreated(event: OrderCreatedEvent): Promise<void> {
    try {
      await this.sendConfirmationEmail(event.userId, event.orderId);
    } catch (error) {
      this.logger.error(
        `Failed to send email for order ${event.orderId}`,
        error instanceof Error ? error.stack : undefined,
      );
    }
  }

  private async sendConfirmationEmail(
    userId: string,
    orderId: string,
  ): Promise<void> {
    // Тут могла б бути інтеграція із сервісом email
    console.log(`Sending email to user ${userId} for order ${orderId}`);
  }
}

constructor(
  private readonly emailService: EmailService,
  private readonly auditService: AuditService,
  private readonly statisticsService: StatisticsService,
) {}

constructor(
  private readonly eventEmitter: EventEmitter2,
) {}

@Module({
  providers: [OrderCreatedListener],
})
export class OrdersModule {}

this.eventEmitter.emit('order.created', event);

@OnEvent('order.created')

new OrderCreatedEvent(order.id, order.userId, order.total)