WebSocket gateways மூலம் real-time features-ஐ எப்படி உருவாக்குவீர்கள்?

Question

Accepted Answer

NestJS **WebSocket gateways** மூலம் **real-time, bidirectional communication**-ஐ ஆதரிக்கிறது — `@WebSocketGateway()` மூலம் decorate செய்யப்பட்ட classes, WebSocket connections மற்றும் messages-ஐ கையாளுகின்றன (பொதுவாக Socket.IO மீது). அவை அதே NestJS அமைப்பைப் (DI, decorators) பயன்படுத்தி chat, live notifications, மற்றும் live dashboards போன்ற features-ஐ செயல்படுத்துகின்றன.

## ஒரு 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
  }
}
```

ஒரு gateway வரும் events-ஐ கையாள `@SubscribeMessage("event")`-ஐப் பயன்படுத்துகிறது (HTTP-க்கான `@Post`-க்கு ஒத்தது) மற்றும் clients-க்கு events-ஐ திரும்ப **emit** செய்ய inject செய்யப்பட்ட `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 connecting மற்றும் disconnecting செய்வதற்கு எதிர்வினையாற்ற முடியும் — presence tracking மற்றும் cleanup-க்கு பயனுள்ளது.

## குறிப்பிட்ட clients மற்றும் 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** 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-ஐ scaling செய்தல்

```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-க்கு பதிலளிப்பது மட்டுமல்ல).

நவீன interactive applications-ஐ உருவாக்குவதற்கு அவற்றைப் புரிந்துகொள்வது மதிப்புமிக்க senior-level அறிவாகும்.

முக்கிய பலம் என்னவென்றால் gateways NestJS-இன் பழக்கமான அமைப்புக்கு பொருந்துகின்றன: அவை **dependency injection**-ஐ ஆதரிக்கும் providers ஆகும், மேலும் HTTP controllers போலவே **guards, pipes, interceptors, மற்றும் filters**-ஐப் பயன்படுத்த முடியும், எனவே அதே patterns மற்றும் code organization REST-க்கு போலவே real-time-க்கும் பொருந்துகிறது.

Events-ஐ எப்படி கையாள்வது (`@SubscribeMessage`), clients-க்கு broadcast செய்வது (`server.emit`), broadcasts-ஐ தொடர்புடைய subsets-க்கு (chat rooms, document collaborators) scope செய்ய **rooms**-ஐப் பயன்படுத்துவது, மற்றும் connection lifecycle-ஐ (presence, cleanup) நிர்வகிப்பது என அறிந்திருப்பது நடைமுறை real-time toolkit-ஐ உள்ளடக்குகிறது.

முக்கியமாக **scaling consideration**: WebSocket connections stateful மற்றும் ஒரு single server instance உடன் இணைக்கப்பட்டுள்ளன, எனவே horizontally scaling செய்வதற்கு instances முழுவதும் broadcasts/rooms-ஐ ஒருங்கிணைக்க ஒரு **Redis adapter** தேவைப்படுகிறது (ஒரு பொதுவான pitfall — sessions போல, பல instances இயக்கும்போது real-time state ஒரு process-இன் memory-இல் வாழ முடியாது).

இது நவீன users எதிர்பார்க்கும் real-time, interactive experiences-ஐ உருவாக்குவதற்கான ஒரு முக்கியமான, பெருகிய முறையில் தொடர்புடைய திறனாகும், மேலும் NestJS-இன் சுத்தமான integration அதை அணுகக்கூடியதாக ஆக்கும் அதே நேரத்தில் framework-இன் அமைப்பை மீண்டும் பயன்படுத்துகிறது.