Kako gradite real-time funkcionalnosti z WebSocket gateway-ji?

Question

Accepted Answer

NestJS podpira **real-time, dvosmerino komunikacijo** prek **WebSocket gateway-jev** — razredov okrašenih z `@WebSocketGateway()`, ki upravljajo WebSocket povezave in sporočila (običajno preko Socket.IO). Omogočajo funkcionalnosti, kot so pogovori, obvestila v realnem času in živahne nadzorne plošče, z isto NestJS strukturo (DI, dekoratorji).

## Opredelitev gateway-ja

```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
  }
}
```

Gateway uporablja `@SubscribeMessage("event")` za obravnavo vhodnih dogodkov (analogno `@Post` za HTTP) in injiciran `server` za **pošiljanje** dogodkov nazaj odjemalcem — `server.emit` oddaja vsem.

## Kljukice životnega ciklusa povezave

```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-ji se lahko odzovejo na povezovanje in prekinjanje odjemalcev — koristno za sledenje navzočnosti in čiščenje.

## Ciljanje specifičnih odjemalcev in sob

```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
}
```

**Sobe** združujejo odjemalce (npr. sobo za pogovor, sodelavce dokumenta), kar vam omogoča oddajanje specifičnim podmnožicam namesto vsem — bistveno za področje vezane real-time funkcionalnosti.

## Gateway-ji ponovno uporabijo NestJS funkcionalnosti

```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.
```

## Skaliranje WebSocket-ov

```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.)
```

## Zakaj je to pomembno

WebSocket gateway-ji so način, kako NestJS podpira **real-time, dvosmerino funkcionalnosti** — pogovore, obvestila v realnem času, navzočnost, skupinsko urejanje, živahe nadzorne plošče, večigralske interakcije — ki jih model zahtevek-odgovor REST-a ne more zagotoviti (strežnik lahko potisne odjemalcem, ne le odgovori na zahtevke).

Razumevanje njih je dragoceno znanje na višji ravni za gradnjo modernih interaktivnih aplikacij.

Glavna prednost je, da se gateway-ji prilegajo znani NestJS strukturi: so ponudniki, ki podpirajo **vbrizgavanje odvisnosti** in lahko uporabljajo **zaščite, cevi, prestrezalce in filtre** enako kot HTTP krmilniki, zato se isti vzorci in organizacija kode nanašajo na real-time in na REST.

Znanje, kako upravljati dogodke (`@SubscribeMessage`), oddajati odjemalcem (`server.emit`), uporabljati **sobe** za omejitev oddaje na ustrezne podmnožice (sob za pogovore, sodelavce dokumenta) in upravljati s ciklom povezave (navzočnost, čiščenje), pokriva praktičen komplet real-time orodij.

Kritično pomembno je razmisliti o **skaliranju**: WebSocket povezave so statne in vezane na en primerek strežnika, zato horizontalno skaliranje zahteva **adapter Redis-a** za koordiniranje oddaj/sob med primjerki (pogosta napaka — kot seje, real-time stanje ne more živeti v spomin enega procesa, ko se izvajajo večji primjerki).

To je pomembna, vedno bolj relevantna sposobnost za gradnjo real-time, interaktivnih izkušenj, ki jih pričakujejo sodobni uporabniki, in čista integracija NestJS-a to naredi dostopno, medtem ko ponovno uporablja strukturo ogrodja.