Hvordan bygger du sanntidsfunksjoner med WebSocket-gateways?

Question

Accepted Answer

NestJS støtter **sanntids, toveis kommunikasjon** via **WebSocket-gateways** — klasser dekorert med `@WebSocketGateway()` som håndterer WebSocket-tilkoblinger og meldinger (typisk over Socket.IO). De muliggjør funksjoner som chat, direktemeldinger og sanntidsdashboards, ved å bruke samme NestJS-struktur (DI, dekoratorer).

## Definere en gateway

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

En gateway bruker `@SubscribeMessage("event")` til å håndtere innkommende events (analogt med `@Post` for HTTP) og den injiserte `server` for å **sende** events tilbake til klienter — `server.emit` kringkaster til alle.

## Tilkoblingssyklus hooks

```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 kan reagere når klienter kobler til og fra — nyttig for tilstede-sporing og opprydding.

## Målrette spesifikke klienter og rom

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

**Rom** grupperer klienter (f.eks. et chatrom, en dokuments samarbeidende brukere), slik at du kan kringkaste til spesifikke delmengder i stedet for alle — essensielt for begrenset sanntidsfunksjonalitet.

## Gateways gjenbruker NestJS-funksjoner

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

## Skalering av WebSockets

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

## Hvorfor det betyr noe

WebSocket-gateways er hvordan NestJS støtter **sanntids, toveis funksjoner** — chat, direktemeldinger, tilstedeværelse, samarbeidende redigering, sanntidsdashboards, flerspillinteraksjoner — som RESTs request-response-modell ikke kan gi (serveren kan skyve til klienter, ikke bare svare på forespørsler).

Å forstå dem er verdifull kunnskap på seniornivå for å bygge moderne interaktive applikasjoner.

Hovedstyrken er at gateways passer inn i NestJS sin kjente struktur: de er providere som støtter **avhengighetsinjeksjon** og kan bruke **guards, pipes, interceptors og filters** akkurat som HTTP-kontrollere, så de samme mønstrene og kodeorganisasjonen gjelder for sanntid som for REST.

Å vite hvordan du håndterer events (`@SubscribeMessage`), kringkaster til klienter (`server.emit`), bruker **rom** for å begrense kringkastinger til relevante delmengder (chatrom, dokumentsamarbeidspartnere) og håndterer tilkoblingssyklusen (tilstedeværelse, opprydding) dekker det praktiske sanntidsverktøyet.

Kritisk viktig er **skaleringsbetraktningen**: WebSocket-tilkoblinger er tilstandsbaserte og knyttet til en enkelt serverinstans, så horisontal skalering krever en **Redis-adapter** for å koordinere kringkastinger/rom på tvers av instanser (en vanlig fallgruve — som sesjoner, kan sanntidstilstand ikke leve i en prosesss minne når flere instanser kjøres).

Dette er en viktig, stadig mer relevant evne for å bygge sanntids, interaktive opplevelser som moderne brukere forventer, og NestJS sin rene integrasjon gjør det tilgjengelig samtidig som det gjenbruker rammeverkets struktur.