Pira carane nggawe fitur real-time nganggo WebSocket gateways?

Question

Accepted Answer

NestJS ndhukung **real-time, bidirectional communication** via **WebSocket gateways** — kelas sing didekorasi karo `@WebSocketGateway()` sing nangani WebSocket connections lan messages (biasane liwat Socket.IO). Padha ngaktifake fitur kaya chat, live notifications, lan live dashboards, nganggo struktur NestJS sing padha (DI, decorators).

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

Sebuah gateway nganggo `@SubscribeMessage("event")` kanggo nangani incoming events (padha karo `@Post` kanggo HTTP) lan injected `server` kanggo **emit** events balik menyang clients — `server.emit` ndadakake kanggo kabeh.

## Connection lifecycle 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 bisa ngreaksi menyang clients sing konek lan disconnect — migunani kanggo presence tracking lan cleanup.

## Ngatarake specific clients lan rooms

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

**Rooms** ngumpulake clients (contone chat room, collaborators dokumen), ndadakake ngadakake menyang subset spesifik tinimbang kabeh — penting kanggo real-time features sing spesifik.

## Gateways nganggo maneh NestJS features

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

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

## Kenapa iku penting

WebSocket gateways iku carane NestJS ndhukung **real-time, bidirectional features** — chat, live notifications, presence, collaborative editing, live dashboards, multiplayer interactions — sing model request-response REST ora bisa nyediane (server bisa push menyang clients, ora mung ngrembug requests).

Ngerteni gateways iku valuable senior-level knowledge kanggo nggawe aplikasi interactive modern.

Kekuatan kunci iku gateways cocok karo struktur NestJS sing familiar: padha providers sing ndhukung **dependency injection** lan bisa nganggo **guards, pipes, interceptors, lan filters** kaya HTTP controllers, dadi pola lan code organization sing padha nglaku menyang real-time kaya REST.

Ngerteni cara nangani events (`@SubscribeMessage`), broadcast menyang clients (`server.emit`), nganggo **rooms** kanggo scope broadcasts menyang subset relevant (chat rooms, document collaborators), lan manage connection lifecycle (presence, cleanup) ndedel practical real-time toolkit.

Penting tenan iku **scaling consideration**: WebSocket connections iku stateful lan tied menyang single server instance, dadi scaling horizontally mbutuhake **Redis adapter** kanggo koordinate broadcasts/rooms saindhenging instances (pitfall umum — kaya sessions, real-time state ora bisa manggon ing siji process memory nalika running multiple instances).

Iku capability penting, increasingly-relevant kanggo nggawe real-time, interactive experiences sing modern users njaluk, lan NestJS clean integration ndadakake iku accessible nalika nganggo maneh struktur framework.