Kako gradite funkcionalnosti u realnom vremenu s WebSocket gateways?

Question

Accepted Answer

NestJS podržava **komunikaciju u realnom vremenu, bidirekcionalnu** putem **WebSocket gateways** — klase dekorisane s `@WebSocketGateway()` koje obrađuju WebSocket konekcije i poruke (obično preko Socket.IO). Omogućuju funkcionalnosti kao što su čat, direktne obavijesti i direktne kontrolne ploče, koristeći istu NestJS strukturu (DI, dekoratore).

## Definiranje gateway-a

```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 koristi `@SubscribeMessage("event")` za obradu dolaznih događaja (analogno `@Post` za HTTP) i injektirani `server` za **slanje** događaja nazad klijentima — `server.emit` emituje svima.

## Kuke životnog ciklusa konekcije

```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-i mogu reagirati na povezivanje i prekidanje klijenta — korisno za praćenje prisutnosti i čišćenje.

## Ciljanje određenih klijenta i soba

```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** grupiraju klijente (npr. čajna soba, suradnici dokumenta), omogućavajući vam emisiju u određene podskupine umjesto svima — neophodno za ograničene funkcionalnosti u realnom vremenu.

## Gateway-i ponovno koriste 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 WebSocketa

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

## Zašto je to važno

WebSocket gateway-i su način na koji NestJS podržava **funkcionalnosti u realnom vremenu, bidirekcijske** — čat, direktne obavijesti, prisutnost, suradničko uređivanje, direktne kontrolne ploče, multiplayer interakcije — koje REST-ov model zahtjev-odgovor ne može pružiti (server može poslati klijentima, ne samo odgovoriti na zahtjeve).

Razumijevanje njih je vrijedna znanja za rukovodeću razinu za izgradnju modernih interaktivnih aplikacija.

Kljačna prednost je što se gateway-i uklapaju u poznatu NestJS strukturu: oni su pružatelji koji podržavaju **dependency injection** i mogu koristiti **guard-e, pipe-ove, interceptore i filtere** baš kao HTTP kontroleri, pa se isti obrasci i organizacija koda primjenjuje na funkcionalnosti u realnom vremenu kao na REST.

Znanje kako rukovati događajima (`@SubscribeMessage`), emitovati klijentima (`server.emit`), koristiti **sobe** za ograničenje emisija na relevantne podskupine (čajne sobe, suradnici dokumenta) i upravljati životnim ciklom konekcije (prisutnost, čišćenje) pokriva praktični alat za rad u realnom vremenu.

Kritično važno je razmatranje **skaliranja**: WebSocket konekcije su stateful i vezane uz jednu instancu servera, pa skaliranje horizontalno zahtijeva **Redis adapter** za koordinaciju emisija/soba između instanci (česta greška — kao i sa sesijama, stanje u realnom vremenu ne može živjeti u memoriji jednog procesa kada se vrte višestruke instance).

Ovo je važna, sve relevantnije potrebna sposobnost za izgradnju iskustava u realnom vremenu, interaktivnih, koja moderni korisnici očekuju, a čista integracija NestJS-a čini je dostupnom dok se ponovno koristi struktura okvira.