Si ndërtoni funksionalitete në kohë reale me WebSocket gateway-et?

Question

Accepted Answer

NestJS suporton **komunikim në kohë reale, bidireksional** përmes **WebSocket gateway-eve** — klasave të dekoruara me `@WebSocketGateway()` që trajtojnë lidhjet dhe mesazhet WebSocket (zakonisht përmes Socket.IO). Ato mundësojnë funksionalitete si chat-i, njoftimet live dhe panelet live të dashbord-it, duke përdorur të njëjtën strukturë NestJS (DI, dekoratorë).

## Përcaktimi i një gateway-i

```ts
import { WebSocketGateway, SubscribeMessage, MessageBody, WebSocketServer } from "@nestjs/websockets";
import { Server } from "socket.io";

@WebSocketGateway({ cors: true })
export class ChatGateway {
  @WebSocketServer()
  server: Server;                        // the Socket.IO server instance

// handle a 'message' event from a client
  @SubscribeMessage("message")
  handleMessage(@MessageBody() data: { text: string }) {
    // BROADCAST to all connected clients
    this.server.emit("message", data);   // everyone receives the message
  }
}
```

Një gateway përdor `@SubscribeMessage("event")` për të trajtuar ngjarjet ardhëse (analoge me `@Post` për HTTP) dhe `server`-in e injektuar për të **emetuar** ngjarje përsëri tek klientët — `server.emit` bën transmetim të gjerë për të gjithë.

## Lidhjet e cikleve të jetës

```ts
export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
  handleConnection(client: Socket) {
    console.log(`Client connected: ${client.id}`);   // a user joined
  }
  handleDisconnect(client: Socket) {
    console.log(`Client disconnected: ${client.id}`); // a user left — clean up
  }
}
```

Gateway-et mund të reagojnë ndaj lidhjeve dhe ndodhjes të prekjes të klientëve — i dobishëm për gjurmimin e pranisë dhe pastrimin.

## Synuar klientë specifik dhe dhoma

```ts
@SubscribeMessage("joinRoom")
handleJoin(@ConnectedSocket() client: Socket, @MessageBody() room: string) {
  client.join(room);                              // add the client to a room
}

@SubscribeMessage("roomMessage")
sendToRoom(@MessageBody() data: { room: string; text: string }) {
  this.server.to(data.room).emit("message", data.text);   // emit only to that room
  // client.emit(...) → just that client; server.emit(...) → everyone
}
```

**Dhomat** grupojnë klientë (p.sh. një dhomë chat, bashkëpunëtorët e një dokumenti), duke ju lejuar të bëni transmetim të gjerë në nëngrupe specifike në vend të të gjithëve — thelbësor për funksionalitetet e real-time me fushëzim.

## Gateway-et ripërdorin funksionalitete NestJS

```text
Gateways are providers → they support dependency injection (inject services),
and can use guards, pipes, interceptors, and filters — just like HTTP controllers.
→ The same structure/patterns apply to real-time as to REST.
```

## Shkallëzimi i WebSocket-eve

```text
⚠️ WebSocket connections are STATEFUL and live on ONE server instance.
To scale across multiple instances, use a Redis adapter (socket.io-redis) so
broadcasts/rooms work across all instances. (Like sessions, don't keep state in
one process's memory when scaling horizontally.)
```

## Pse ka rëndësi

WebSocket gateway-et janë se si NestJS suporton **funksionalitetet në kohë reale, bidireksionale** — chat, njoftimet live, praninë, redaktimin kolaborativ, panelet live të dashbord-it, ndërveprimet multiplayer — që modeli kërkesë-përgjigje i REST-it nuk mund të sigurojë (serveri mund të shtyjë tek klientët, jo thjesht të përgjigjet kërkesave).

Zotërimi i tyre është njohuri me nivel senior e vlefshme për ndërtimin e aplikacioneve interaktive moderne.

Forca kryesore është se gateway-et përputhen me strukturën familjare të NestJS: ato janë furnizues që mbështesin **injektimin e varësisë** dhe mund të përdorin **guard-ë, pipe-ra, interceptor-ë dhe filter-a** ashtu si kontrolluesit HTTP, kështu që të njëjtat modele dhe organizim kodi zbatohen për real-time si për REST.

Zotërimi se si të trajtoni ngjarjet (`@SubscribeMessage`), të bëni transmetim tek klientët (`server.emit`), të përdorni **dhoma** për të fushëzuar transmetimet në nëngrupe relevante (dhomat e chat-it, bashkëpunëtorët e dokumentit) dhe të menaxhoni ciklin e jetës të lidhjes (praninë, pastrimin) mbulon grupin praktik të mjeteve në kohë reale.

Kritikisht i rëndësishëm është **konsiderimi i shkallëzimit**: lidhjet WebSocket janë me gjendje dhe të lidhura me një instancë të vetme serveri, kështu që shkallëzimi në mënyrë horizontale kërkon një **adapter Redis** për koordinimin e transmetimeve/dhomave në instanca (një ndodh e zakonshme — si sesionet, gjendja në kohë reale nuk mund të jetojë në memorien e një procesi të vetëm kur drejtoni instanca të shumëfishta).

Kjo është një aftësi e rëndësishme, në rritje-përkatëse për ndërtimin e përvojave në kohë reale, interaktive që përdoruesit modernë presin, dhe integrimi i pastër i NestJS e bën atë të arritshme ndërsa ripërdor strukturën e framework-ut.