ബൾക്ക് ഓപ്പറേഷനുകൾക്കായി സെർവർ-സൈഡ് ഇവൻ്റുകൾ ഉപയോഗിച്ച് NestJS-ലെ ആയാസരഹിതമായ അറിയിപ്പുകൾ

ബൾക്ക് ഇൻസേർട്ട് ഓപ്പറേഷനുകൾക്കായി സ്ട്രീംലൈൻ ചെയ്ത അറിയിപ്പ് ഡെലിവറി

ഡിപ്പാർട്ട്‌മെൻ്റ്, ഗ്രേഡ് അല്ലെങ്കിൽ അനുഭവം പോലുള്ള വിവിധ മാനദണ്ഡങ്ങളെ അടിസ്ഥാനമാക്കി നൂറുകണക്കിന് ജീവനക്കാർക്ക് വൗച്ചറുകൾ നൽകുന്ന ഒരു സിസ്റ്റം നിങ്ങൾ നിയന്ത്രിക്കുന്നുവെന്ന് സങ്കൽപ്പിക്കുക. സിസ്റ്റത്തിൽ തടസ്സങ്ങൾ സൃഷ്ടിക്കാതെ ഓരോ ജീവനക്കാരനെയും കാര്യക്ഷമമായി അറിയിക്കുക എന്നത് ഒരു വലിയ കടമയാണ്. 🔔 സോക്കറ്റുകളുടെയോ പോളിംഗ് മെക്കാനിസങ്ങളുടെയോ സങ്കീർണ്ണതകൾ ഒഴിവാക്കാൻ നിങ്ങൾ ലക്ഷ്യമിടുന്നുവെങ്കിൽ ഈ വെല്ലുവിളി കൂടുതൽ ഭയാനകമാകും.

അത്തരം സാഹചര്യങ്ങളിൽ, സെർവർ-സൈഡ് ഇവൻ്റുകൾ (എസ്എസ്ഇ) ശക്തവും എന്നാൽ നേരായതുമായ ഒരു പരിഹാരമായി ഉയർന്നുവരുന്നു. നിങ്ങളുടെ NestJS ആപ്ലിക്കേഷനിൽ SSE പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ, ഡൈനാമിക് മാനദണ്ഡങ്ങൾ അടിസ്ഥാനമാക്കി ജീവനക്കാരുടെ പ്രത്യേക ഗ്രൂപ്പുകളെ അറിയിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു തത്സമയ ആശയവിനിമയ ചാനൽ സ്ഥാപിക്കാനാകും. ഉദാഹരണത്തിന്, സെയിൽസ് ഡിപ്പാർട്ട്‌മെൻ്റിന് വൗച്ചറുകൾ അനുവദിക്കുമ്പോൾ, കൃത്യമായതും അർത്ഥവത്തായതുമായ അപ്‌ഡേറ്റുകൾ ഉറപ്പാക്കിക്കൊണ്ട്, ആ ജീവനക്കാർക്ക് മാത്രമേ അറിയിപ്പുകൾ ലഭിക്കൂ.

ഈ ലേഖനത്തിലൂടെ, NestJS ഉപയോഗിച്ച് ഒരു ബൾക്ക് ഇൻസേർഷൻ പ്രോസസിലേക്ക് SSE എങ്ങനെ സംയോജിപ്പിക്കാമെന്ന് കാണിക്കുന്ന ഒരു പ്രായോഗിക ഉദാഹരണത്തിലേക്ക് ഞങ്ങൾ കടക്കും. ബാക്കെൻഡിൽ ഇവൻ്റുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നത് മുതൽ മുൻവശത്തെ അപ്‌ഡേറ്റുകൾ കേൾക്കുന്നത് വരെയുള്ള ജീവിതചക്രത്തിലൂടെ ഞങ്ങൾ സഞ്ചരിക്കും, എല്ലാം തടസ്സമില്ലാത്ത പ്രകടനം നിലനിർത്തിക്കൊണ്ട്. 💼

നിങ്ങൾ ഒരു എച്ച്ആർ ടൂൾ അല്ലെങ്കിൽ ഫിനാൻസ് ആപ്പ് വികസിപ്പിക്കുകയാണെങ്കിലും, ഈ വർക്ക്ഫ്ലോ മനസ്സിലാക്കുന്നത് വ്യക്തിപരമാക്കിയ അറിയിപ്പുകൾ തത്സമയം നൽകുന്നതിന് നിങ്ങളെ പ്രാപ്തരാക്കും. എസ്എസ്ഇയുടെ ലാളിത്യവും അതിന് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ ഉപയോക്തൃ അനുഭവം എങ്ങനെ ഉയർത്താമെന്നും നമുക്ക് വെളിപ്പെടുത്താം.

സെർവർ സൈഡ് ഇവൻ്റുകളും ക്യൂകളും ഉള്ള കാര്യക്ഷമമായ അറിയിപ്പുകൾ

ഡാറ്റാബേസിലേക്ക് വൗച്ചർ രേഖകൾ ബൾക്ക് ഇൻസേർട്ട് ചെയ്തതിന് ശേഷം ജീവനക്കാർക്ക് തത്സമയ അറിയിപ്പുകൾ അയയ്‌ക്കുന്ന ഒരു സിസ്റ്റം നൽകിയ സ്‌ക്രിപ്റ്റുകൾ ചിത്രീകരിക്കുന്നു. പ്രക്രിയ ആരംഭിക്കുന്നത് വൗച്ചർ കൺട്രോളർ അനുവദിക്കുക, ഇത് വൗച്ചർ അലോക്കേഷൻ ടാസ്‌ക്കുകൾ സൃഷ്‌ടിക്കുന്നതിനുള്ള അവസാന പോയിൻ്റ് തുറന്നുകാട്ടുന്നു. ഒരു ടാസ്‌ക് സൃഷ്‌ടിക്കുമ്പോൾ, അത് പേരുള്ള ഒരു ഇവൻ്റ് പുറപ്പെടുവിക്കുന്നു ശേഷം-അലോക്കേറ്റ്-വൗച്ചർ. തുടർന്നുള്ള ഘട്ടങ്ങൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിന് ഈ ഇവൻ്റ് അത്യന്താപേക്ഷിതമാണ്, സിസ്റ്റം ഇവൻ്റ്-ഡ്രൈവുചെയ്ത് മോഡുലാർ ആണെന്ന് ഉറപ്പാക്കുന്നു. ഈ ഡിസൈൻ ആശങ്കകളെ വ്യക്തമായി വേർതിരിക്കാൻ അനുവദിക്കുന്നു, ഇത് സിസ്റ്റത്തെ കൂടുതൽ പരിപാലിക്കാവുന്നതും അളക്കാവുന്നതുമാക്കി മാറ്റുന്നു. 🎯

സേവന പാളിയിൽ, ദി വൗച്ചർ സേവനം അനുവദിക്കുക BullMQ ഉപയോഗിച്ച് ജോലികൾ ക്യൂവുചെയ്യുന്നതിനുള്ള യുക്തി കൈകാര്യം ചെയ്യുന്നു. ലഭിച്ച ശേഷം ശേഷം-അലോക്കേറ്റ്-വൗച്ചർ ഇവൻ്റ്, ഇത് പേരിട്ടിരിക്കുന്ന ക്യൂവിൽ ഒരു ജോലി ചേർക്കുന്നു അലോട്ട് വൗച്ചർ. ഈ ക്യൂ അസിൻക്രണസ് പ്രോസസ്സിംഗ് അനുവദിക്കുന്നു, വലിയ ഡാറ്റാസെറ്റുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ പോലും സിസ്റ്റം പ്രതികരിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾ സെയിൽസ് ഡിപ്പാർട്ട്‌മെൻ്റിലെ 200 ജീവനക്കാർക്ക് വൗച്ചറുകൾ അനുവദിക്കുകയാണെങ്കിൽ, പ്രവർത്തനം മറ്റ് അഭ്യർത്ഥനകളെ തടയുന്നില്ലെന്ന് ക്യൂ ഉറപ്പാക്കുന്നു. ക്യൂവിൻ്റെ കോൺഫിഗറേഷനിൽ ഇതുപോലുള്ള ഓപ്ഷനുകൾ ഉൾപ്പെടുന്നു നീക്കംOnComplete ജോലി പൂർത്തിയാക്കിയ ശേഷം റെഡിസിനെ വൃത്തിയായി സൂക്ഷിക്കാൻ.

ക്യൂ ജോലികൾ പ്രോസസ്സ് ചെയ്യുന്നത് അലോട്ട്വൗച്ചർ ഉപഭോക്താവ് ക്ലാസ്. ഇവിടെ, പ്രസക്തമായ ജീവനക്കാരെ തിരിച്ചറിയുന്നതിനും വൗച്ചർ രേഖകൾ ഡാറ്റാബേസിലേക്ക് തിരുകുന്നതിനുമുള്ള യുക്തി നടപ്പിലാക്കുന്നു. പ്രിസ്മ കമാൻഡ് പലതും സൃഷ്ടിക്കുക എന്നതിലേക്ക് റെക്കോർഡുകൾ ബാച്ച്-ഇൻസേർട്ട് ചെയ്യാൻ ഉപയോഗിക്കുന്നു ജീവനക്കാരൻ വൗച്ചർ പ്രകടനത്തിനായി ഒപ്റ്റിമൈസ് ചെയ്ത പട്ടിക. ഡാറ്റാബേസ് പ്രവർത്തനം പൂർത്തിയായ ശേഷം, സബ്‌സ്‌ക്രൈബർമാരെ അറിയിക്കാൻ മറ്റൊരു ഇവൻ്റ് പുറപ്പെടുവിക്കുന്നു. ബൾക്ക് ഇൻസേർഷൻ വിജയകരമായി പ്രോസസ്സ് ചെയ്തതിന് ശേഷം മാത്രമേ ജീവനക്കാരെ അറിയിക്കുകയുള്ളൂവെന്ന് ഈ ഇവൻ്റ് ഉറപ്പാക്കുന്നു, ഇത് അറിയിപ്പ് സിസ്റ്റത്തിന് വിശ്വാസ്യത നൽകുന്നു. 🌟

മുൻവശത്ത്, റിയാക്റ്റ് ഘടകം ഒരു വഴി സെർവർ അയച്ച ഇവൻ്റുകൾ ശ്രദ്ധിക്കുന്നു ഇവൻ്റ് സോഴ്സ്. ജീവനക്കാരെ അറിയിക്കുമ്പോൾ, പേജ് പുതുക്കൽ ആവശ്യമില്ലാതെ തന്നെ അവരുടെ വിശദാംശങ്ങൾ യുഐയിൽ ചലനാത്മകമായി അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നു. തത്സമയ സ്‌പോർട്‌സ് സ്‌കോറുകൾ അല്ലെങ്കിൽ സോഷ്യൽ മീഡിയ അറിയിപ്പുകൾ പോലുള്ള ആധുനിക വെബ് ആപ്ലിക്കേഷനുകളിൽ കാണുന്ന തത്സമയ അപ്‌ഡേറ്റുകൾക്ക് സമാനമായി ഈ സമീപനം തടസ്സമില്ലാത്ത ഉപയോക്തൃ അനുഭവം നൽകുന്നു. ഉദാഹരണത്തിന്, എച്ച്ആർ ഡിപ്പാർട്ട്‌മെൻ്റിലെ ജീവനക്കാർക്ക് വിൽപ്പനയ്ക്കായി ഉദ്ദേശിച്ചിട്ടുള്ള അപ്‌ഡേറ്റുകൾ കാണാനാകില്ല, കാരണം ബാക്കെൻഡ് അലോക്കേഷൻ മാനദണ്ഡത്തെ അടിസ്ഥാനമാക്കി ഇവൻ്റുകൾ കൃത്യമായി ഫിൽട്ടർ ചെയ്യുന്നു. ഈ പ്രത്യേകത പ്രകടനവും പ്രസക്തിയും വർദ്ധിപ്പിക്കുന്നു, ഒരു ഉപയോക്തൃ കേന്ദ്രീകൃത സിസ്റ്റം സൃഷ്ടിക്കുന്നു. 🖥️

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

NestJS-ൽ SSE-യോടൊപ്പം തത്സമയ സംവിധാനങ്ങൾ മെച്ചപ്പെടുത്തുന്നു

വൗച്ചർ അലോക്കേഷനുകളെക്കുറിച്ച് ജീവനക്കാരെ അറിയിക്കുന്നതിന് സെർവർ-സൈഡ് ഇവൻ്റുകൾ (എസ്എസ്ഇ) നടപ്പിലാക്കുന്നത് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്‌തിരിക്കുമ്പോൾ, തത്സമയ സിസ്റ്റങ്ങളിൽ എസ്എസ്ഇയ്‌ക്ക് വിപുലമായ ഉപയോഗ സാഹചര്യമുണ്ട്. സ്ഥിരമായി പോളിംഗ് ചെയ്യാതെ സെർവർ ഡാറ്റ ഉപയോഗിച്ച് ക്ലയൻ്റുകൾ അപ്‌ഡേറ്റ് ചെയ്യേണ്ട സാഹചര്യത്തിലാണ് എസ്എസ്ഇ തിളങ്ങുന്നത്. ഉദാഹരണത്തിന്, ഒരു ഫ്ലാഷ് വിൽപ്പന സമയത്ത് തത്സമയ ഇൻവെൻ്ററി അപ്‌ഡേറ്റുകൾ ട്രാക്കുചെയ്യുന്ന ഒരു ഓൺലൈൻ റീട്ടെയിൽ പ്ലാറ്റ്‌ഫോമിനെക്കുറിച്ച് ചിന്തിക്കുക. SSE ഉപയോഗിച്ച്, കണക്റ്റുചെയ്‌ത എല്ലാ ക്ലയൻ്റുകളിലേക്കും നിങ്ങൾക്ക് കാര്യക്ഷമമായി അപ്‌ഡേറ്റുകൾ നൽകാനാകും, അനാവശ്യ സെർവർ ലോഡ് കൂടാതെ ഏറ്റവും പുതിയ സ്റ്റോക്ക് ലെവലുകൾ അവർ കാണുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. ഈ സമീപനം ഉപയോക്തൃ അനുഭവം തടസ്സമില്ലാതെ നിലനിർത്തിക്കൊണ്ട് സ്കേലബിളിറ്റി ഉറപ്പാക്കുന്നു. 🛒

BullMQ പോലെയുള്ള വിപുലമായ ക്യൂയിംഗ് സംവിധാനങ്ങൾ സംയോജിപ്പിക്കുന്നു, ഞങ്ങൾ ചെയ്തതുപോലെ അലോട്ട് വൗച്ചർ ക്യൂ, ബൾക്ക് ഡാറ്റ പ്രോസസ്സിംഗ് ജോലികൾക്ക് കരുത്ത് നൽകുന്നു. ഒരു സെർവർ പുനരാരംഭിക്കുകയാണെങ്കിൽപ്പോലും, തീർപ്പാക്കാത്ത ജോലികൾ അതേപടി നിലനിൽക്കുമെന്നും പ്രോസസ്സിംഗ് പുനരാരംഭിക്കുമെന്നും ക്യൂ ഉറപ്പാക്കുന്നു. കൂടാതെ, പരാജയപ്പെട്ട ജോലികൾ (ഉദാ. താൽകാലിക ഡാറ്റാബേസ് പ്രവർത്തനരഹിതമായതിനാൽ) സ്വയമേവ വീണ്ടും ശ്രമിക്കുമെന്ന് ഉറപ്പാക്കിക്കൊണ്ട്, വീണ്ടും ശ്രമിക്കുന്നതിനുള്ള മെക്കാനിസങ്ങൾ കോൺഫിഗർ ചെയ്യാവുന്നതാണ്. ഉദാഹരണത്തിന്, വകുപ്പുകളിലുടനീളമുള്ള 300 ജീവനക്കാർക്കുള്ള അലോക്കേഷൻ ഒരു താൽക്കാലിക പിശക് നേരിട്ടാൽ, ക്യൂവിൻ്റെ പ്രതിരോധം, നിങ്ങളുടെ സിസ്റ്റത്തിന് വിശ്വാസ്യത കൂട്ടിക്കൊണ്ട്, റെക്കോർഡുകളൊന്നും പ്രോസസ്സ് ചെയ്യപ്പെടാതെ അവശേഷിക്കുന്നു എന്ന് ഉറപ്പാക്കുന്നു.

തത്സമയ അറിയിപ്പുകൾക്കപ്പുറം, വിശദമായ സംഗ്രഹങ്ങൾ ആവശ്യമുള്ള ടാസ്‌ക്കുകൾക്കായി ഇമെയിൽ സേവനങ്ങൾ പൂർത്തീകരിക്കാനും SSE-ക്ക് കഴിയും. എല്ലാ വൗച്ചർ അറിയിപ്പുകളും SSE വഴി അയച്ചതിന് ശേഷം, ബാക്കെൻഡിന് അസമന്വിതമായി ഒരു റിപ്പോർട്ട് സൃഷ്ടിക്കാനും മാനേജർമാർക്ക് ഒരു ഏകീകൃത ഇമെയിൽ അയയ്ക്കാനും കഴിയും. ഈ മൾട്ടി-ചാനൽ കമ്മ്യൂണിക്കേഷൻ ഉടനടി അറിയിപ്പുകളും സമഗ്രമായ ഫോളോ-അപ്പുകളും ഉറപ്പാക്കുന്നു, ഉപയോക്തൃ മുൻഗണനകളുടെ വിശാലമായ ശ്രേണി നൽകുന്നു. അത്തരം സംയോജനം നിങ്ങളുടെ സിസ്റ്റത്തിൻ്റെ വഴക്കം വർദ്ധിപ്പിക്കുകയും മികച്ച ഉപയോക്തൃ അനുഭവം സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. 📧