బల్క్ ఆపరేషన్‌ల కోసం సర్వర్-సైడ్ ఈవెంట్‌లను ఉపయోగించి NestJSలో అప్రయత్నమైన నోటిఫికేషన్‌లు

NestJSలో సర్వర్-సైడ్ ఈవెంట్‌లతో (SSE) బల్క్‌లో నోటిఫికేషన్‌లను పంపుతోంది

ఈ పరిష్కారం బల్క్ ఆపరేషన్ల కోసం ప్రిస్మా మరియు సర్వర్-సైడ్ ఈవెంట్స్ (SSE)తో NestJSని ఉపయోగించేందుకు బ్యాకెండ్ విధానాన్ని ప్రదర్శిస్తుంది. ఇది ఈవెంట్-డ్రైవెన్ ఆర్కిటెక్చర్ మరియు క్యూయింగ్ సిస్టమ్‌ను కలిగి ఉంటుంది.

// 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 })),
    );
  }
}

NestJS మరియు రియాక్ట్‌ని ఉపయోగించి బల్క్ ఇన్‌సర్ట్‌ల కోసం నిజ-సమయ నవీకరణలు

ఈ ఫ్రంటెండ్ ఉదాహరణ సర్వర్-సైడ్ ఈవెంట్‌లను వినడానికి రియాక్ట్‌ని ఉపయోగిస్తుంది మరియు డేటా అందుకున్నప్పుడు UIని డైనమిక్‌గా అప్‌డేట్ చేస్తుంది. ఇది బల్క్ ఇన్‌సర్షన్‌ల తర్వాత ఉద్యోగులకు నిజ సమయంలో తెలియజేయబడుతుందని నిర్ధారిస్తుంది.

// 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;

బల్క్ ఇన్సర్ట్ ఆపరేషన్‌ల కోసం యూనిట్ టెస్టింగ్ నోటిఫికేషన్‌లు

ఈ జెస్ట్ పరీక్ష NestJSలోని సర్వర్-సైడ్ ఈవెంట్‌ల బ్యాకెండ్‌లో ఈవెంట్ ఎమిషన్ మరియు నోటిఫికేషన్ మెకానిజం సరిగ్గా పనిచేస్తుందని నిర్ధారిస్తుంది.

// 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);
  });
});

NestJSలో SSE గురించి తరచుగా అడిగే ప్రశ్నలు

1. WebSockets ద్వారా సర్వర్-సైడ్ ఈవెంట్‌లను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు ఏమిటి?
2. SSE అమలు చేయడం సులభం మరియు HTTPని ఉపయోగిస్తుంది, ఇది ఫైర్‌వాల్-స్నేహపూర్వకంగా చేస్తుంది. WebSockets వలె కాకుండా, దీనికి ఒకే ఏకదిశాత్మక కనెక్షన్ మాత్రమే అవసరం, ఇది నిజ-సమయ నవీకరణల కోసం సమర్థవంతమైనది.
3. నేను ఉపయోగించవచ్చా @Sse కంట్రోలర్‌లో బహుళ ముగింపు బిందువులతో ఉందా?
4. అవును, మీరు బహుళ నిర్వచించవచ్చు @Sse నిర్దిష్ట అవసరాల ఆధారంగా క్లయింట్‌లకు వేర్వేరు డేటా స్ట్రీమ్‌లను అందించడానికి ఒకే కంట్రోలర్‌లోని ఎండ్ పాయింట్‌లు.
5. క్యూ ప్రాసెసింగ్ సమయంలో నేను లోపాలను ఎలా పరిష్కరించగలను?
6. BullMQతో, మీరు మళ్లీ ప్రయత్నించే ఎంపికలను నిర్వచించవచ్చు మరియు ఈవెంట్ శ్రోతలను ఉపయోగించవచ్చు @OnWorkerEvent('failed') లోపాలను లాగ్ చేయడానికి మరియు అవసరమైతే ఉద్యోగాలను మళ్లీ ప్రాసెస్ చేయడానికి.
7. ప్రిస్మా చేస్తుంది createMany పద్ధతి మద్దతు లావాదేవీ రోల్‌బ్యాక్‌లు?
8. అవును, ప్రిస్మా createMany లావాదేవీలో చుట్టవచ్చు. లావాదేవీలో ఏదైనా ఆపరేషన్ విఫలమైతే, అన్ని కార్యకలాపాలు స్థిరత్వం కోసం వెనక్కి తీసుకోబడతాయి.
9. SSE స్ట్రీమ్ సమయంలో క్లయింట్ డిస్‌కనెక్ట్ అయితే ఏమి జరుగుతుంది?
10. డిస్‌కనెక్ట్‌ను గుర్తించిన తర్వాత సర్వర్ నవీకరణలను పంపడం ఆపివేస్తుంది. మీరు ఉపయోగించి క్లయింట్‌పై రీకనెక్ట్ లాజిక్‌ని అమలు చేయవచ్చు EventSource API.
11. రెండు-మార్గం కమ్యూనికేషన్ కోసం SSEని ఉపయోగించవచ్చా?
12. లేదు, SSE ఏకదిశాత్మకమైనది (సర్వర్-టు-క్లయింట్). ద్వి దిశాత్మక కమ్యూనికేషన్ కోసం, WebSockets లేదా HTTP2 స్ట్రీమ్‌లను ఉపయోగించండి.
13. నేను NestJSలో SSE ఎండ్‌పాయింట్‌లను ఎలా భద్రపరచగలను?
14. గార్డ్‌లు లేదా మిడిల్‌వేర్‌లను ఉపయోగించండి @UseGuards, మీ SSE ముగింపు పాయింట్‌ల కోసం ప్రమాణీకరణ మరియు అధికారాన్ని అమలు చేయడానికి.
15. SSE బ్రౌజర్ కాని క్లయింట్‌లతో పని చేయగలదా?
16. అవును, HTTP మరియు ఈవెంట్ స్ట్రీమింగ్‌కు (ఉదా., Node.js, cURL) మద్దతు ఇచ్చే ఏ క్లయింట్ అయినా SSE స్ట్రీమ్‌లను వినియోగించుకోవచ్చు.
17. SSE ముగింపు పాయింట్‌కి కనెక్ట్ చేయగల గరిష్ట సంఖ్యలో క్లయింట్లు ఎంత?
18. ఇది మీ సర్వర్ కాన్ఫిగరేషన్ మరియు వనరుల పరిమితులపై ఆధారపడి ఉంటుంది. లోడ్ బ్యాలెన్సింగ్ మరియు క్లస్టరింగ్ మరింత మంది క్లయింట్‌లకు మద్దతు ఇవ్వడానికి స్కేల్ చేయడంలో సహాయపడతాయి.
19. SSE ద్వారా JSON డేటాను పంపడం సాధ్యమేనా?
20. అవును, మీరు వస్తువులను JSON స్ట్రింగ్‌లకు సీరియలైజ్ చేయవచ్చు మరియు వాటిని ఉపయోగించి పంపవచ్చు new MessageEvent NestJSలో.

NestJSలో ప్రభావవంతమైన నిజ-సమయ నోటిఫికేషన్‌లు

ఉపయోగించి నిజ-సమయ వ్యవస్థలను అమలు చేయడం SSE NestJSలో సర్వర్ మరియు క్లయింట్‌ల మధ్య కమ్యూనికేషన్‌ను సులభతరం చేస్తుంది. ఈ పద్ధతి స్థిరమైన పోలింగ్‌తో పోలిస్తే సర్వర్ లోడ్‌ను తగ్గిస్తుంది మరియు నోటిఫికేషన్‌ల కోసం ఖచ్చితమైన లక్ష్యాన్ని అనుమతిస్తుంది. ఉదాహరణకు, HR సాధనం ఇతరులకు అంతరాయం కలిగించకుండా కొత్త వోచర్‌ల గురించి సేల్స్‌లోని 200 మంది ఉద్యోగులకు తెలియజేయగలదు. 🎯

BullMQ మరియు Prisma వంటి సాధనాలతో, ఈ సెటప్ అసమకాలిక టాస్క్ ప్రాసెసింగ్ మరియు సమర్థవంతమైన డేటాబేస్ కార్యకలాపాలను నిర్ధారిస్తుంది. ఈవెంట్-ఆధారిత ఆర్కిటెక్చర్ యొక్క సౌలభ్యం వివిధ నిజ-సమయ అవసరాలకు స్కేలబుల్ పరిష్కారంగా చేస్తుంది, వినియోగదారు నిశ్చితార్థం మరియు సిస్టమ్ విశ్వసనీయతను పెంచుతుంది.