Jak vytvoříte real-time funkce s WebSocket gateways?

Question

Accepted Answer

NestJS podporuje **real-time, obousměrnou komunikaci** prostřednictvím **WebSocket gatewayů** — tříd dekorovaných `@WebSocketGateway()`, které zpracovávají WebSocket připojení a zprávy (obvykle přes Socket.IO). Umožňují funkce jako chat, živá upozornění a živé dashboardy, přičemž používají stejnou strukturu NestJS (DI, dekorátory).

## Definování gatewaye

```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 používá `@SubscribeMessage("event")` pro zpracování příchozích událostí (analogicky k `@Post` pro HTTP) a injektovaný `server` pro **odesílání** událostí zpět klientům — `server.emit` vysílá všem.

## Háčky životního cyklu připojení

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

Gateways mohou reagovat na připojení a odpojení klientů — užitečné pro sledování přítomnosti a čištění.

## Cílení konkrétních klientů a místností

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

**Místnosti** seskupují klienty (např. chatovací místnost, spolupracovníci na dokumentu), což vám umožní vysílat na konkrétní podmnožiny místo všem — nezbytné pro vymezené real-time funkce.

## Gateways opakují používání funkcí 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.
```

## Škálování WebSocketů

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

## Proč na tom záleží

WebSocket gateways jsou způsob, jak NestJS podporuje **real-time, obousměrné funkce** — chat, živá upozornění, přítomnost, kolaborativní úpravy, živé dashboardy, multiplayer interakce — kterým model request-response v REST nemůže poskytnout (server může klientům posílat data, ne jen reagovat na požadavky).

Rozhlednutí se v nich je cenná znalost na úrovni senior vývojáře pro vytváření moderních interaktivních aplikací.

Hlavní silnou stránkou je, že gateways se vejdou do známé struktury NestJS: jsou to poskytovatelé podporující **dependency injection** a mohou používat **guards, pipes, interceptory a filtry** stejně jako HTTP controllery, takže se stejné vzory a organizace kódu používají na real-time i na REST.

Znalost, jak zpracovávat události (`@SubscribeMessage`), vysílat na klienty (`server.emit`), používat **místnosti** k vymezení vysílání na relevantní podmnožiny (chatovací místnosti, spolupracovníci na dokumentu) a spravovat životní cyklus připojení (přítomnost, čištění) pokrývá praktickou real-time sadu nástrojů.

Kriticky důležité je zvážit **škálování**: WebSocket připojení jsou stavová a vázána na jednu instanci serveru, takže horizontální škálování vyžaduje **Redis adaptér** pro koordinaci vysílání/místností na instancích (časté úskalí — jako relace, real-time stav nemůže žít v paměti jednoho procesu při spuštění více instancí).

Toto je důležitá, stále relevantnější schopnost pro vytváření real-time, interaktivních zkušeností, které moderní uživatelé očekávají, a čisté integrace NestJS ji dělají přístupnou a znovupoužívajícími strukturu frameworku.