ਤੁਸੀਂ WebSocket gateways ਨਾਲ ਰੀਅਲ-ਟਾਈਮ ਫੀਚਰ ਕਿਵੇਂ ਬਣਾਉਂਦੇ ਹੋ?

Question

Accepted Answer

NestJS **ਰੀਅਲ-ਟਾਈਮ, ਦੋਵਾਂ ਦਿਸ਼ਾ ਵਾਲੀ ਸੰਚਾਰ** ਨੂੰ **WebSocket gateways** ਰਾਹੀਂ ਸਮਰਥਨ ਕਰਦਾ ਹੈ — ਇਹ `@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` ਸਭ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਦਾ ਹੈ।

## ਕਨੈਕਸ਼ਨ ਲਾਈਫ ਸਾਈਕਲ ਹੁਕਸ

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

**Rooms** ਕਲਾਈਂਟਾਂ ਨੂੰ ਗਰੁੱਪ ਕਰਦੇ ਹਨ (ਉਦਾ. ਇੱਕ ਚੈਟ ਰੂਮ, ਇੱਕ ਡਾਕੂਮੈਂਟ ਦੇ ਸਹਿਯੋਗੀ), ਤੁਹਾਨੂੰ ਸਭ ਦੀ ਬਜਾਏ ਖਾਸ ਉਪ-ਸੰਗ੍ਹ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ — ਫਾਊਂਡ ਕੀਤੀਆਂ ਰੀਅਲ-ਟਾਈਮ ਫੀਚਰਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

## 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 ਦੀ ਜਾਣੀ-ਪਛਾਣੀ ਬਣਤਰ ਵਿੱਚ ਫਿੱਟ ਹੁੰਦੇ ਹਨ: ਇਹ **ਨਿਰਭਰਤਾ ਇੰਜੈਕਸ਼ਨ** ਨੂੰ ਸਮਰਥਨ ਕਰਨ ਵਾਲੇ ਪ੍ਰਦਾਤਾ ਹਨ ਅਤੇ HTTP ਨਿਯੰਤ੍ਰਕਾਂ ਵਾਂਗ **ਗਾਰਡਸ, ਪਾਈਪਸ, ਇੰਟਰਸੈਪਟਰ ਅਤੇ ਫਿਲਟਰ** ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ, ਇਸ ਲਈ ਉਹੀ ਪੈਟਰਨ ਅਤੇ ਕੋਡ ਸੰਗਠਨ REST ਦੇ ਮੁਕਾਬਲੇ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।

ਇਵੈਂਟਾਂ ਨੂੰ ਸੰਭਾਲਣਾ (`@SubscribeMessage`), ਕਲਾਈਂਟਾਂ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨਾ (`server.emit`), **ਕਮਰਿਆਂ** ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪ੍ਰਸਾਰ ਨੂੰ ਸੰਬੰਧਿਤ ਉਪ-ਸੰਗ੍ਹ ਲਈ (ਚੈਟ ਕਮਰੇ, ਡਾਕੂਮੈਂਟ ਸਹਿਯੋਗੀ) ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ, ਅਤੇ ਕਨੈਕਸ਼ਨ ਲਾਈਫ ਸਾਈਕਲ (ਮੌਜੂਦਗੀ, ਸਫ਼ਾਈ) ਵਿਵਹਾਰ ਕਰਨਾ ਪ੍ਰੈਕਟੀਕਲ ਰੀਅਲ-ਟਾਈਮ ਟੂਲਕਿਟ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ।

ਗਰਾਹਕ ਢੁਕਵਾਂ ਹੈ **ਸਕੇਲਿੰਗ ਵਿਚਾਰ**: WebSocket ਕਨੈਕਸ਼ਨ ਸਟੇਟਫੁਲ ਹਨ ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਸਰਵਰ ਇਨਸਟੈਂਸ ਨਾਲ ਬੰਨ੍ਹੇ ਹਨ, ਇਸ ਲਈ ਹਰੀਜ਼ੋਂਟਲ ਰੂਪ ਵਿੱਚ ਸਕੇਲ ਕਰਨ ਲਈ ਇਨਸਟੈਂਸਾਂ ਵਿੱਚ ਪ੍ਰਸਾਰ/ਕਮਰਿਆਂ ਦਾ ਸਮਨੁਸਾਰ ਕਰਨ ਲਈ **Redis ਐਡਾਪਟਰ** ਦੀ ਲੋੜ ਹੈ (ਇੱਕ ਸਾਂਝੀ ਗਲਤੀ — ਸੈਸ਼ਨਾਂ ਵਾਂਗ, ਰੀਅਲ-ਟਾਈਮ ਸਟੇਟ ਕਈ ਕਮਿਆਂ ਦੀ ਮੈਮੋਰੀ ਵਿੱਚ ਨਹੀਂ ਰਹਿ ਸਕਦੀ)।

ਇਹ ਇੱਕ ਮਹੱਤਵਪੂਰਨ, ਵਧਦੀ ਪ্রাসঙ্গਿকਤਾ ਵਾਲੀ ਸਮਰੱਥਾ ਹੈ ਰੀਅਲ-ਟਾਈਮ, ਇੰਟਰੈਕਟਿਵ ਅਨੁਭਵ ਬਣਾਉਣ ਲਈ ਜੋ ਆਧੁਨਿਕ ਵਰਤੋਂਕਾਰ ਦੀ ਅਪੇਖਾ ਕਰਦੇ ਹਨ, ਅਤੇ NestJS ਦਾ ਸਾਫ਼ ਏਕੀਕਰਨ ਇਸ ਨੂੰ ਪਹੁੰਚਯੋਗ ਬਣਾਉਂਦਾ ਹੈ ਜਦਕਿ ਫਰੇਮਵਰਕ ਦੀ ਬਣਤਰ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਦਾ ਹੈ।