તમે WebSocket gateways સાથે રીયલ-ટાઈમ ફીચર્સ કેવી રીતે બનાવો છો?

Question

Accepted Answer

NestJS **રીયલ-ટાઈમ, બાયડિરેક્શનલ કમ્યુનિકેશન** `@WebSocketGateway()` ડેકોરેટર વાળી ક્લાસ દ્વારા સપોર્ટ કરે છે જે WebSocket કનેક્શન અને મેસેજીસ (સામાન્યતઃ Socket.IO પર) હેન્ડલ કરે છે. તે ચેટ, લાઈવ નોટિફિકેશન અને લાઈવ ડેશબોર્ડ જેવી ફીચર્સ સક્ષમ કરે છે, NestJS જેટલી રચનાનો ઉપયોગ કરીને (DI, ડેકોરેટર્સ).

## 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 `@SubscribeMessage("event")` નો ઉપયોગ કરીને આવતા ઇવેન્ટ્સ હેન્ડલ કરે છે (HTTP માટે `@Post` સમાન) અને ઇંજેક્ટ કરાયેલ `server` ને ક્લાયન્ટ્સને ઇવેન્ટ્સ વળતું આપવા માટે ઉપયોગ કરે છે — `server.emit` બધાને બ્રોડકાસ્ટ કરે છે.

## 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 ક્લાયન્ટ્સ કનેક્ટ અને ડિસ્કનેક્ટ થવા પર પ્રતિક્રિયા આપી શકે છે — પ્રેજન્સ ટ્રેકિંગ અને ક્લીનઅપ માટે ઉપયોગી.

## ચોક્કસ ક્લાયન્ટ્સ અને રૂમ્સને લક્ષ્ય કરવું

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

**રૂમ્સ** ક્લાયન્ટ્સને ગ્રુપ કરે છે (દા.તા. ચેટ રૂમ, ડોક્યુમેન્ટના સહયોગીઓ), જે તમને બધાને બદલે ચોક્કસ સબસેટ્સને બ્રોડકાસ્ટ કરવાનું દેશે — સ્કોપ્ડ રીયલ-ટાઈમ ફીચર્સ માટે આવશ્યક.

## Gateways NestJS ફીચર્સ પુનઃવાપર કરે છે

```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 સ્કેલ કરવું

```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 **રીયલ-ટાઈમ, બાયડિરેક્શનલ ફીચર્સ** સમર્થન આપે છે — ચેટ, લાઈવ નોટિફિકેશન્સ, પ્રેજન્સ, કોલેબોરેટિવ એડિટિંગ, લાઈવ ડેશબોર્ડ્સ, મલ્ટીપ્લેયર ઇન્ટરેક્શન્સ — જે REST ની રીક્વેસ્ટ-રેસ્પોન્સ મોડલ આપી શકે નહીં (સર્વર ક્લાયન્ટ્સને પુશ કરી શકે છે, માત્ર રીક્વેસ્ટ્સને જવાબ આપવાને બદલે).

તેમને સમજવું વરિષ્ઠ-સ્તરના જ્ઞાન છે આધુનિક ઇન્ટરેક્ટિવ એપ્લિકેશન્સ બનાવવા માટે.

મુખ્ય શક્તિ એ છે કે gateways NestJS ની પરિચિત રચનામાં ફિટ કરે છે: તે **dependency injection** સમર્થન કરતા પ્રોવાઇડર્સ છે અને **guards, pipes, interceptors અને filters** HTTP controllers જેવું જ વાપર કરી શકે છે, તેથી REST જેટલી જ પેટર્નો અને કોડ સંગઠન રીયલ-ટાઈમમાં લાગુ થાય છે.

ઇવેન્ટ્સ હેન્ડલ કરવા (`@SubscribeMessage`), ક્લાયન્ટ્સને બ્રોડકાસ્ટ કરવા (`server.emit`), **rooms** વાપર કરીને બ્રોડકાસ્ટ્સને સંબંધિત સબસેટ્સ (ચેટ રૂમ્સ, ડોક્યુમેન્ટ સહયોગીઓ) તક સીમિત કરવા અને connection lifecycle (presence, cleanup) હેન્ડલ કરવું આ વ્યવહારિક રીયલ-ટાઈમ ટૂલકિટ આવરે છે.

ગંભીરપણે મહત્વપૂર્ણ એ છે **સ્કેલિંગ વિચારણા**: WebSocket કનેક્શન્સ સ્ટેટફુલ છે અને એક સર્વર ઇનસ્ટન્સને બાંધવામાં આવ્યા છે, તેથી આડાશીમાં સ્કેલ કરવા માટે **Redis adapter** આવશ્યક છે ઇનસ્ટન્સ્સ પર બ્રોડકાસ્ટ્સ/રૂમ્સ સંકલન કરવા માટે (એક સામાન્ય મુશ્કેલી — સેશન્સની જેમ, રીયલ-ટાઈમ સ્ટેટ એક પ્રક્રિયાની મેમરીમાં જીવી શકે નહીં જ્યારે બહુ ઇનસ્ટન્સ્સ ચલાવો છો).

તે એક મહત્વપૂર્ણ, ક્રમશઃ-પ્રાસંગિક ક્ષમતા છે રીયલ-ટાઈમ, ઇન્ટરેક્ટિવ અનુભવો બનાવવા માટે જે આધુનિક યુઝર્સ અપેક્ષા રાખે છે, અને NestJS ની સ્વચ્છ એકીકરણ તે સુલભ બનાવે છે જ્યારે ફ્રેમવર્કની રચના પુનઃવાપર કરે છે.