Notificações sem esforço no NestJS usando eventos do lado do servidor para operações em massa

Entrega simplificada de notificações para operações de inserção em massa

Imagine que você está gerenciando um sistema onde centenas de funcionários recebem vouchers com base em vários critérios, como departamento, nota ou experiência. É uma tarefa colossal notificar cada funcionário de forma eficiente, sem causar gargalos no sistema. 🔔 Esse desafio se torna ainda mais assustador quando você pretende evitar as complexidades dos soquetes ou mecanismos de votação.

Nesses cenários, os eventos do lado do servidor (SSE) surgem como uma solução poderosa, porém simples. Ao aproveitar o SSE em seu aplicativo NestJS, você pode estabelecer um canal de comunicação em tempo real para notificar grupos específicos de funcionários com base em critérios dinâmicos. Por exemplo, quando os vouchers são atribuídos ao departamento de Vendas, apenas esses funcionários devem receber notificações, garantindo atualizações precisas e significativas.

Neste artigo, mergulharemos em um exemplo prático que demonstra como integrar o SSE em um processo de inserção em massa usando NestJS. Percorreremos todo o ciclo de vida, desde o acionamento de eventos no back-end até a escuta de atualizações no front-end, tudo isso mantendo um desempenho contínuo. 💼

Esteja você desenvolvendo uma ferramenta de RH ou um aplicativo financeiro, compreender esse fluxo de trabalho permitirá que você entregue notificações personalizadas em tempo real. Vamos desvendar a simplicidade do SSE e como ele pode elevar a experiência do usuário do seu aplicativo.

Notificações eficientes com eventos e filas do lado do servidor

Os scripts fornecidos ilustram um sistema onde notificações em tempo real são enviadas aos funcionários após a inserção em massa de registros de vouchers no banco de dados. O processo começa no AlocarVoucherController, que expõe um endpoint para criar tarefas de alocação de vouchers. Quando uma tarefa é criada, ela emite um evento chamado voucher pós-alocação. Este evento é essencial para acionar as etapas subsequentes, garantindo que o sistema seja orientado a eventos e modular. Este design permite uma separação clara de preocupações, tornando o sistema mais sustentável e escalável. 🎯

Na camada de serviço, o AlocarVoucherService lida com a lógica para enfileirar tarefas usando BullMQ. Depois de receber o voucher pós-alocação evento, ele adiciona um trabalho à fila chamada voucher de atribuição. Essa fila permite o processamento assíncrono, garantindo que o sistema permaneça responsivo mesmo ao processar grandes conjuntos de dados. Por exemplo, se você alocar vouchers para 200 funcionários do departamento de Vendas, a fila garante que a operação não bloqueie outras solicitações. A configuração da fila inclui opções como removeOnComplete para manter o Redis limpo após a conclusão do trabalho.

Os trabalhos da fila são processados ​​pelo AllotVoucherConsumidor aula. Aqui é implementada a lógica de identificação dos funcionários relevantes e inserção de registros de vouchers no banco de dados. O comando Prisma criar muitos é usado para inserir registros em lote no funcionárioVoucher tabela, que é otimizada para desempenho. Após a conclusão da operação do banco de dados, outro evento é emitido para notificar os assinantes. Este evento garante que os funcionários só sejam notificados após o processamento bem-sucedido da inserção em massa, agregando confiabilidade ao sistema de notificação. 🌟

No frontend, o componente React escuta os eventos enviados pelo servidor através de um Fonte do Evento. À medida que os funcionários são notificados, seus detalhes são atualizados dinamicamente na IU sem a necessidade de atualização da página. Essa abordagem fornece uma experiência de usuário perfeita, semelhante às atualizações em tempo real vistas em aplicativos da web modernos, como resultados esportivos ao vivo ou notificações de mídia social. Por exemplo, os funcionários do departamento de RH não verão atualizações destinadas a Vendas, pois o back-end filtra eventos com precisão com base em critérios de alocação. Essa especificidade melhora o desempenho e a relevância, criando um sistema focado no usuário. 🖥️

// Backend: AllocateVoucherController
import { Controller, Post, Body, Sse, OnEvent } from '@nestjs/common';
import { AllocateVoucherService } from './allocate-voucher.service';
import { EventEmitter2 } from '@nestjs/event-emitter';
import { Observable } from 'rxjs';
import { map, fromEvent } from 'rxjs';
@Controller('allocate-voucher')
export class AllocateVoucherController {
  constructor(
    private readonly allocateVoucherService: AllocateVoucherService,
    private readonly eventEmitter: EventEmitter2
  ) {}
  @Post()
  async create(@Body() createDto: any) {
    const result = await this.allocateVoucherService.create(createDto);
    return result;
  }
  @Sse('vouchered-employee')
  updatedEmployeeEvent(): Observable<MessageEvent> {
    return fromEvent(this.eventEmitter, 'after-added-voucher').pipe(
      map((data) => new MessageEvent('after-added-voucher', { data })),
    );
  }
}

// Frontend: React Component for SSE
import React, { useEffect, useState } from 'react';
const EmployeeUpdates = () => {
  const [employees, setEmployees] = useState([]);
  useEffect(() => {
    const eventSource = new EventSource('http://localhost:3000/allocate-voucher/vouchered-employee');
    eventSource.onmessage = (event) => {
      const newEmployee = JSON.parse(event.data);
      setEmployees((prev) => [...prev, newEmployee]);
    };
    return () => eventSource.close();
  }, []);
  return (
    <table>
      <thead>
        <tr><th>Name</th><th>Voucher</th></tr>
      </thead>
      <tbody>
        {employees.map((emp) => (
          <tr key={emp.id}><td>{emp.name}</td><td>{emp.voucher}</td></tr>
        ))}
      </tbody>
    </table>
  );
};
export default EmployeeUpdates;

// Jest Test: AllocateVoucherService
import { Test, TestingModule } from '@nestjs/testing';
import { AllocateVoucherService } from './allocate-voucher.service';
import { EventEmitter2 } from '@nestjs/event-emitter';
describe('AllocateVoucherService', () => {
  let service: AllocateVoucherService;
  let eventEmitter: EventEmitter2;
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [AllocateVoucherService, EventEmitter2],
    }).compile();
    service = module.get(AllocateVoucherService);
    eventEmitter = module.get(EventEmitter2);
  });
  it('should emit after-allocate-voucher event', async () => {
    jest.spyOn(eventEmitter, 'emit');
    const result = await service.create({ someData: 'test' });
    expect(eventEmitter.emit).toHaveBeenCalledWith('after-allocate-voucher', result);
  });
});

Aprimorando sistemas em tempo real com SSE no NestJS

Embora tenhamos explorado a implementação de eventos do lado do servidor (SSE) para notificar os funcionários sobre alocações de vouchers, há um caso de uso mais amplo para SSE em sistemas em tempo real. O SSE se destaca em cenários onde os clientes precisam se manter atualizados com os dados do servidor sem fazer pesquisas constantes. Por exemplo, pense em uma plataforma de varejo on-line que rastreia atualizações de estoque em tempo real durante uma venda relâmpago. Usando o SSE, você pode enviar atualizações com eficiência para todos os clientes conectados, garantindo que eles visualizem os níveis de estoque mais recentes sem carga desnecessária do servidor. Essa abordagem garante escalabilidade enquanto mantém a experiência do usuário perfeita. 🛒

Incorporando sistemas avançados de filas como BullMQ, como fizemos com o voucher de atribuição fila, adiciona robustez às tarefas de processamento de dados em massa. A fila garante que, mesmo que ocorra uma reinicialização do servidor, as tarefas pendentes permaneçam intactas e o processamento seja retomado. Além disso, mecanismos de nova tentativa podem ser configurados, garantindo que trabalhos com falha (por exemplo, devido ao tempo de inatividade temporário do banco de dados) sejam repetidos automaticamente. Por exemplo, se uma alocação para 300 funcionários em vários departamentos encontrar um erro temporário, a resiliência da fila garante que nenhum registro fique sem processamento, adicionando confiabilidade ao seu sistema.

Além das notificações em tempo real, o SSE também pode complementar os serviços de e-mail para tarefas que exigem resumos detalhados. Depois que todas as notificações de vouchers forem enviadas via SSE, o backend pode gerar um relatório de forma assíncrona e enviar um e-mail consolidado aos gerentes. Esta comunicação multicanal garante notificações imediatas e acompanhamentos abrangentes, atendendo a uma ampla gama de preferências do usuário. Essa integração aumenta a flexibilidade do seu sistema, criando uma experiência de usuário completa. 📧