Hvordan bygger du real-time-funktioner med WebSocket-gateways?

Question

Accepted Answer

NestJS understøtter **real-time, bidirektional kommunikation** via **WebSocket-gateways** — klasser dekoreret med `@WebSocketGateway()`, der håndterer WebSocket-forbindelser og meddelelser (typisk over Socket.IO). De muliggør funktioner som chat, live-notifikationer og live-dashboards ved hjælp af den samme NestJS-struktur (DI, dekoratorer).

## Definition af 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 bruger `@SubscribeMessage("event")` til at håndtere indgående events (analogt med `@Post` for HTTP) og den injicerede `server` til at **udsende** events tilbage til klienter — `server.emit` transmitterer til alle.

## Forbindelses-livscyklus 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 på klienter, der forbinder og afbryder — brugbart til tilstedeværelsessporing og oprydning.

## Målretning af specifikke klienter og rum

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

**Rum** grupperer klienter (f.eks. et chatrum, et dokuments samarbejdspartnere), hvilket giver dig mulighed for at transmittere til specifikke delmængder i stedet for til alle — væsentligt for målrettede real-time-funktioner.

## Gateways genbrug NestJS-funktioner

```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 af 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 betyder noget

WebSocket-gateways er, hvordan NestJS understøtter **real-time, bidirektional funktionalitet** — chat, live-notifikationer, tilstedeværelse, samarbejdsredigering, live-dashboards, multiplayer-interaktioner — som REST's request-response-model ikke kan levere (serveren kan skubbe til klienter, ikke blot svare på anmodninger).

At forstå dem er værdifuld seniorniveau-viden til at bygge moderne interaktive applikationer.

Hovedstyrken er, at gateways passer til NestJS's velkendte struktur: de er providere, der understøtter **afhængighedsinjection** og kan bruge **guards, pipes, interceptors og filters** på samme måde som HTTP-controllere, så de samme mønstre og kodeorganisation gælder for real-time som for REST.

At vide, hvordan man håndterer events (`@SubscribeMessage`), transmitterer til klienter (`server.emit`), bruger **rum** til at målrette transmissioner til relevante delmængder (chatrum, dokumentsamarbejdspartnere) og administrerer forbindelses-livscyklussen (tilstedeværelse, oprydning) dækker det praktiske real-time-værktøjssæt.

Kritisk vigtig er **skalerings-overvejelsen**: WebSocket-forbindelser er statefulde og bundet til en enkelt serverinstans, så horisontalskalering kræver en **Redis-adapter** til at koordinere transmissioner/rum på tværs af instanser (en almindelig fælde — ligesom sessioner kan real-time-tilstand ikke leve i en proces' hukommelse, når man kører flere instanser).

Dette er en vigtig, stadig mere relevant evne til at bygge real-time, interaktive oplevelser, som moderne brugere forventer, og NestJS's rene integration gør det tilgængeligt, mens rammeværkets struktur genbruges.