როგორ აკეთებთ რეალური დროის ფიჩერებს WebSocket გეიტვეებით?

Question

Accepted Answer

NestJS მხარდაჯერთ **რეალური დროის, ორმხრივი კომუნიკაციას** **WebSocket გეიტვეების** მეშვეობით — კლასები, რომლებიც დეკორირებულია `@WebSocketGateway()`-ით, რომლებიც მართავენ WebSocket კავშირებს და შეტყობინებებს (ჩვეულებრივ Socket.IO-ის მეშვეობით). ისინი ხელმისაწვდომელი ხდის ფიჩერებს, როგორიცაა ჩატი, ცოცხალი შეტყობინებები და ცოცხალი ინფოპანელები, NestJS-ის იგივე სტრუქტურის გამოყენებით (DI, დეკორატორები).

## გეიტვეის განსაზღვრა

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

გეიტვეი იყენებს `@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
  }
}
```

გეიტვეები შეიძლება რეაგირება კლიენტების დაკავშირებაზე და გათიშვაზე — სასარგებლოა საჩვენებელი თვალთვის ფოლოვინგისა და სუფთავების მიზნით.

## კონკრეტული კლიენტებისა და ოთახების მიზანი

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

**ოთახები** აერთებენ კლიენტებს (მაგ. ჩატის ოთახი, დოკუმენტის ხელშემწყობლები), რაც საშუალებას გაძლევთ გაატაროთ კონკრეტულ ქვეჯგუფებამდე და არა ყველას — აუცილებელია სასაზღვრო რეალური დროის ფიჩერებისთვის.

## გეიტვეები ხელახლა იყენებენ 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.
```

## WebSocket მასშტაბირება

```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 გეიტვეები არის, თუ როგორ მხარდაჯერს NestJS **რეალური დროის, ორმხრივი ფიჩერებს** — ჩატი, ცოცხალი შეტყობინებები, საჩვენებელი თვალთვის, თანამშრომლობითი რედაქტირება, ცოცხალი ინფოპანელები, მრავალმოთამაშო ინტერაქციები — რომელთა REST-ის მოთხოვნა-პასუხის მოდელი ვერ უზრუნველყოფს (სერვერი შეიძლება დააკავშიროს კლიენტებს, არა მხოლოდ პასუხი გასცეს მოთხოვნებზე).

ის გაგება ღირებული უფროსი დონის ცოდნაა თანამედროვე ინტერაქტიული აპლიკაციების აგების მიზნით.

მთავარი ძლევა არის ის, რომ გეიტვეები ჯდება NestJS-ის ნაცნობ სტრუქტურაში: ისინი პროვაიდერები, რომლებიც მხარდაჯერთ **დამოკიდებულების ინჯექციას** და შეიძლება გამოიყენოთ **guards, pipes, interceptors, და filters** ისევე როგორც HTTP კონტროლერები, ასე რომ ერთი და იგივე ნიმუშები და კოდის ორგანიზაცია ვრცელდება რეალური დროის და REST-ზე.

ცოდნა იმის შესახებ, თუ როგორ გამავლებით ივენტებს (`@SubscribeMessage`), გაიღებით კლიენტებს (`server.emit`), იყენებთ **ოთახებს** გაატაროთ კონკრეტული ქვეჯგუფებამდე (ჩატის ოთახები, დოკუმენტის ხელშემწყობლები), და მართავთ კავშირის სიცოცხლის ციკლს (საჩვენებელი თვალთვის, სუფთავება) მოიცავს პრაქტიკულ რეალური დროის ხელის ჩანთას.

მკრთალად მნიშვნელოვანია **მასშტაბირების განხილვა**: WebSocket კავშირები სტატუსური და დაკავშირებულია ერთი სერვერის ინსტანციასთან, ასე რომ ჰორიზონტალური მასშტაბირება მოითხოვს **Redis ადაპტერს** გაატაროთ კოორდინაციის მეშვეობით/ოთახების გაწყობა ინსტანციებში (საერთო თხა — სესიების მსგავსად, რეალური დროის სტატე ვერ ცხოვრობს ერთი პროცესის მეხსიერებაში რამდენიმე ინსტანციის გაშვებისას).

ეს არის მნიშვნელოვანი, სულ უფრო ხელმისაწვდომელი ჯამური რეალური დროის, ინტერაქტიული გამოცდილებების აგების მიზნით, რომელთა თანამედროვე მომხმარებლები მოელიან, და NestJS-ის სუფთა ინტეგრაცია მას ხელმისაწვდომელს ხდის დროს ხელახლა იყენებს ჩარჩოს სტრუქტურას.