आप WebSocket gateways के साथ real-time features कैसे बनाते हैं?

Question

Accepted Answer

NestJS **WebSocket gateways** के माध्यम से **real-time, bidirectional communication** का समर्थन करता है — `@WebSocketGateway()` से decorated classes जो WebSocket connections और messages को handle करती हैं (आमतौर पर Socket.IO के ऊपर)। ये chat, live notifications, और live dashboards जैसे features को सक्षम करती हैं, उसी NestJS structure (DI, decorators) का उपयोग करते हुए।

## एक gateway define करना

```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 incoming events को handle करने के लिए `@SubscribeMessage("event")` का उपयोग करता है (HTTP के लिए `@Post` के अनुरूप) और clients को वापस events **emit** करने के लिए injected `server` का उपयोग करता है — `server.emit` सभी को broadcast करता है।

## 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 clients के connect और disconnect होने पर react कर सकती हैं — presence tracking और cleanup के लिए उपयोगी।

## विशिष्ट clients और rooms को target करना

```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** clients को group करती हैं (जैसे एक chat room, एक document के collaborators), जिससे आप सबको नहीं बल्कि विशिष्ट subsets को broadcast कर सकते हैं — scoped real-time features के लिए आवश्यक।

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

## WebSockets को scale करना

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

## यह क्यों महत्वपूर्ण है

WebSocket gateways वह तरीका है जिससे NestJS **real-time, bidirectional features** का समर्थन करता है — chat, live notifications, presence, collaborative editing, live dashboards, multiplayer interactions — जो REST का request-response model प्रदान नहीं कर सकता (server clients को push कर सकता है, केवल requests का जवाब नहीं देता)।

इन्हें समझना modern interactive applications बनाने के लिए मूल्यवान senior-level ज्ञान है।

मुख्य ताकत यह है कि gateways NestJS की परिचित structure में फिट होती हैं: ये providers हैं जो **dependency injection** का समर्थन करती हैं और HTTP controllers की तरह ही **guards, pipes, interceptors, और filters** का उपयोग कर सकती हैं, इसलिए वही patterns और code organization real-time पर भी लागू होते हैं जैसे REST पर।

events को handle करना (`@SubscribeMessage`), clients को broadcast करना (`server.emit`), broadcasts को relevant subsets (chat rooms, document collaborators) तक scope करने के लिए **rooms** का उपयोग करना, और connection lifecycle (presence, cleanup) को manage करना जानना व्यावहारिक real-time toolkit को कवर करता है।

अत्यंत महत्वपूर्ण है **scaling consideration**: WebSocket connections stateful हैं और एक single server instance से बंधी हैं, इसलिए horizontally scale करने के लिए instances के पार broadcasts/rooms को coordinate करने के लिए एक **Redis adapter** की आवश्यकता होती है (एक common pitfall — sessions की तरह, multiple instances चलाते समय real-time state एक process की memory में नहीं रह सकती)।

यह modern users द्वारा अपेक्षित real-time, interactive experiences बनाने के लिए एक महत्वपूर्ण, increasingly-relevant capability है, और NestJS का clean integration इसे framework की structure का पुनः उपयोग करते हुए accessible बनाता है।