ਬਲਕ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਸਰਵਰ-ਸਾਈਡ ਇਵੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ 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 ਵਿੱਚ ਪ੍ਰਭਾਵੀ ਰੀਅਲ-ਟਾਈਮ ਸੂਚਨਾਵਾਂ

ਵਰਤਦੇ ਹੋਏ ਰੀਅਲ-ਟਾਈਮ ਸਿਸਟਮ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਐੱਸ.ਐੱਸ.ਈ NestJS ਵਿੱਚ ਸਰਵਰ ਅਤੇ ਗਾਹਕਾਂ ਵਿਚਕਾਰ ਸੰਚਾਰ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਨਿਰੰਤਰ ਪੋਲਿੰਗ ਦੇ ਮੁਕਾਬਲੇ ਸਰਵਰ ਲੋਡ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ ਅਤੇ ਸੂਚਨਾਵਾਂ ਲਈ ਸਟੀਕ ਨਿਸ਼ਾਨਾ ਬਣਾਉਣ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ HR ਟੂਲ ਵਿਕਰੀ ਵਿੱਚ 200 ਕਰਮਚਾਰੀਆਂ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਨਵੇਂ ਵਾਊਚਰ ਬਾਰੇ ਸੂਚਿਤ ਕਰ ਸਕਦਾ ਹੈ। 🎯

BullMQ ਅਤੇ Prisma ਵਰਗੇ ਟੂਲਸ ਦੇ ਨਾਲ, ਇਹ ਸੈੱਟਅੱਪ ਅਸਿੰਕ੍ਰੋਨਸ ਟਾਸਕ ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਕੁਸ਼ਲ ਡਾਟਾਬੇਸ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਇਵੈਂਟ-ਆਧਾਰਿਤ ਆਰਕੀਟੈਕਚਰ ਦੀ ਲਚਕਤਾ ਇਸ ਨੂੰ ਵੱਖ-ਵੱਖ ਰੀਅਲ-ਟਾਈਮ ਲੋੜਾਂ ਲਈ ਇੱਕ ਸਕੇਲੇਬਲ ਹੱਲ ਬਣਾਉਂਦੀ ਹੈ, ਉਪਭੋਗਤਾ ਦੀ ਸ਼ਮੂਲੀਅਤ ਅਤੇ ਸਿਸਟਮ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ।