// client/polling-client.ts

interface Message {
  id: number;
  userId: number;
  text: string;
  timestamp: string;
}

interface NewMessagesResponse {
  messages: Message[];
  lastMessageId: number;
}

class PollingClient {
  private lastMessageId: number = 0;
  private pollingInterval: number = 5000; // 5 секунд
  private timerId: number | null = null;

  constructor(
    private apiUrl: string,
    private onNewMessages: (messages: Message[]) => void
  ) {}

  /**
   * Запускає цикл polling
   */
  start(): void {
    console.log(`[Polling] Запуск з інтервалом ${this.pollingInterval}ms`);
    
    // Відразу виконати перший запит
    this.fetchNewMessages();
    
    // Налаштувати періодичне опитування
    this.timerId = window.setInterval(() => {
      this.fetchNewMessages();
    }, this.pollingInterval);
  }

  /**
   * Зупиняє polling
   */
  stop(): void {
    if (this.timerId !== null) {
      clearInterval(this.timerId);
      this.timerId = null;
      console.log('[Polling] Зупинено');
    }
  }

  /**
   * Виконує HTTP запит для отримання нових повідомлень
   */
  private async fetchNewMessages(): Promise<void> {
    try {
      const response = await fetch(
        `${this.apiUrl}/messages/new?since=${this.lastMessageId}`,
        {
          method: 'GET',
          headers: {
            'Authorization': `Bearer ${this.getAuthToken()}`,
            'Content-Type': 'application/json',
          },
        }
      );

      if (!response.ok) {
        console.error(`[Polling] Помилка ${response.status}: ${response.statusText}`);
        return;
      }

      const data: NewMessagesResponse = await response.json();

      if (data.messages.length > 0) {
        console.log(`[Polling] Отримано ${data.messages.length} нових повідомлень`);
        this.lastMessageId = data.lastMessageId;
        this.onNewMessages(data.messages);
      } else {
        console.log('[Polling] Нових повідомлень немає');
      }
    } catch (error) {
      console.error('[Polling] Помилка мережі:', error);
    }
  }

  /**
   * Отримує JWT токен з localStorage (приклад)
   */
  private getAuthToken(): string {
    return localStorage.getItem('authToken') || '';
  }
}

// Використання
const client = new PollingClient(
  'https://api.example.com',
  (messages) => {
    messages.forEach(msg => {
      console.log(`Нове повідомлення від користувача ${msg.userId}: ${msg.text}`);
      // Додати повідомлення до UI
    });
  }
);

client.start();

// Зупинити polling при закритті сторінки
window.addEventListener('beforeunload', () => {
  client.stop();
});

// server/messages.controller.ts
import { Controller, Get, Query, UseGuards, Req } from '@nestjs/common';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { MessagesService } from './messages.service';

interface RequestWithUser extends Request {
  user: { userId: number };
}

@Controller('messages')
@UseGuards(JwtAuthGuard)
export class MessagesController {
  constructor(private readonly messagesService: MessagesService) {}

  /**
   * Ендпоінт для polling: повертає нові повідомлення після вказаного messageId
   */
  @Get('new')
  async getNewMessages(
    @Query('since') since: string,
    @Req() req: RequestWithUser,
  ) {
    const sinceId = parseInt(since, 10) || 0;
    const userId = req.user.userId;

    // Отримати нові повідомлення з БД
    const messages = await this.messagesService.getMessagesSince(
      userId,
      sinceId,
    );

    const lastMessageId =
      messages.length > 0 ? messages[messages.length - 1].id : sinceId;

    return {
      messages,
      lastMessageId,
      timestamp: new Date().toISOString(),
    };
  }
}

// server/messages.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, MoreThan } from 'typeorm';
import { Message } from './message.entity';

@Injectable()
export class MessagesService {
  constructor(
    @InjectRepository(Message)
    private messagesRepository: Repository<Message>,
  ) {}

  /**
   * Отримує повідомлення, створені після вказаного messageId
   * Повертає до 50 останніх повідомлень
   */
  async getMessagesSince(userId: number, sinceId: number): Promise<Message[]> {
    return this.messagesRepository.find({
      where: {
        id: MoreThan(sinceId),
        // Можна додати фільтр по chatRoomId, якщо потрібно
      },
      order: {
        id: 'ASC', // Від старіших до новіших
      },
      take: 50, // Обмеження для запобігання надмірному навантаженню
    });
  }
}

// client/long-polling-client.ts

interface Message {
  id: number;
  userId: number;
  text: string;
  timestamp: string;
}

interface PollResponse {
  messages: Message[];
  lastMessageId: number;
}

class LongPollingClient {
  private lastMessageId: number = 0;
  private isPolling: boolean = false;
  private abortController: AbortController | null = null;

  constructor(
    private apiUrl: string,
    private onNewMessages: (messages: Message[]) => void,
    private onError: (error: Error) => void
  ) {}

  /**
   * Запускає long-polling цикл
   */
  start(): void {
    if (this.isPolling) {
      console.warn('[Long-Polling] Вже запущено');
      return;
    }

    this.isPolling = true;
    console.log('[Long-Polling] Запуск');
    this.poll();
  }

  /**
   * Зупиняє long-polling
   */
  stop(): void {
    this.isPolling = false;

    // Скасувати поточний запит, якщо він виконується
    if (this.abortController) {
      this.abortController.abort();
      this.abortController = null;
    }

    console.log('[Long-Polling] Зупинено');
  }

  /**
   * Рекурсивна функція для виконання long-polling запиту
   */
  private async poll(): Promise<void> {
    if (!this.isPolling) {
      return; // Вихід з рекурсії при зупинці
    }

    this.abortController = new AbortController();

    try {
      const response = await fetch(
        `${this.apiUrl}/messages/poll?since=${this.lastMessageId}`,
        {
          method: 'GET',
          headers: {
            'Authorization': `Bearer ${this.getAuthToken()}`,
            'Content-Type': 'application/json',
          },
          signal: this.abortController.signal,
        }
      );

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      const data: PollResponse = await response.json();

      if (data.messages.length > 0) {
        console.log(`[Long-Polling] Отримано ${data.messages.length} повідомлень`);
        this.lastMessageId = data.lastMessageId;
        this.onNewMessages(data.messages);
      } else {
        console.log('[Long-Polling] Таймаут, нових даних немає');
      }

      // Негайно запустити наступний long-poll
      this.poll();
    } catch (error) {
      if (error instanceof Error && error.name === 'AbortError') {
        console.log('[Long-Polling] Запит скасовано');
        return;
      }

      console.error('[Long-Polling] Помилка:', error);
      this.onError(error as Error);

      // При помилці чекаємо 5 секунд перед повторною спробою
      if (this.isPolling) {
        setTimeout(() => this.poll(), 5000);
      }
    }
  }

  private getAuthToken(): string {
    return localStorage.getItem('authToken') || '';
  }
}

// Використання
const client = new LongPollingClient(
  'https://api.example.com',
  (messages) => {
    messages.forEach(msg => {
      console.log(`Нове повідомлення: ${msg.text}`);
    });
  },
  (error) => {
    console.error('Критична помилка:', error);
  }
);

client.start();

// server/messages-polling.controller.ts
import { Controller, Get, Query, UseGuards, Req, Res } from '@nestjs/common';
import { Response } from 'express';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { MessagesPollingService } from './messages-polling.service';

interface RequestWithUser extends Request {
  user: { userId: number };
}

@Controller('messages')
@UseGuards(JwtAuthGuard)
export class MessagesPollingController {
  constructor(
    private readonly pollingService: MessagesPollingService,
  ) {}

  /**
   * Long-polling ендпоінт: утримує з'єднання до появи нових даних або таймауту
   */
  @Get('poll')
  async longPoll(
    @Query('since') since: string,
    @Req() req: RequestWithUser,
    @Res() res: Response,
  ) {
    const sinceId = parseInt(since, 10) || 0;
    const userId = req.user.userId;
    const timeout = 30000; // 30 секунд

    try {
      // Очікувати нові повідомлення або таймаут
      const result = await this.pollingService.waitForNewMessages(
        userId,
        sinceId,
        timeout,
      );

      res.json(result);
    } catch (error) {
      console.error('[Long-Polling] Помилка:', error);
      res.status(500).json({ error: 'Internal server error' });
    }
  }
}

// server/messages-polling.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, MoreThan } from 'typeorm';
import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
import { Message } from './message.entity';

interface WaitingClient {
  userId: number;
  sinceId: number;
  resolve: (value: any) => void;
  timeoutId: NodeJS.Timeout;
}

@Injectable()
export class MessagesPollingService {
  private waitingClients: WaitingClient[] = [];

  constructor(
    @InjectRepository(Message)
    private messagesRepository: Repository<Message>,
    private eventEmitter: EventEmitter2,
  ) {}

  /**
   * Асинхронно очікує нові повідомлення або таймаут
   */
  async waitForNewMessages(
    userId: number,
    sinceId: number,
    timeout: number,
  ): Promise<{ messages: Message[]; lastMessageId: number }> {
    // Спочатку перевіряємо, чи є вже нові дані
    const existingMessages = await this.getMessagesSince(userId, sinceId);

    if (existingMessages.length > 0) {
      // Дані вже є — повертаємо одразу
      return {
        messages: existingMessages,
        lastMessageId: existingMessages[existingMessages.length - 1].id,
      };
    }

    // Даних немає — очікуємо нової події або таймауту
    return new Promise((resolve) => {
      const timeoutId = setTimeout(() => {
        // Таймаут спрацював — видаляємо клієнта зі списку очікування
        this.removeWaitingClient(resolve);
        resolve({ messages: [], lastMessageId: sinceId });
      }, timeout);

      // Додаємо клієнта до списку очікування
      this.waitingClients.push({
        userId,
        sinceId,
        resolve,
        timeoutId,
      });
    });
  }

  /**
   * Обробник події нового повідомлення — сповіщає всіх очікуючих клієнтів
   */
  @OnEvent('message.created')
  async handleNewMessage(message: Message): Promise<void> {
    console.log(`[Long-Polling] Нове повідомлення ${message.id}, сповіщення клієнтів`);

    // Знайти всіх клієнтів, які очікують на повідомлення після sinceId < message.id
    const clientsToNotify = this.waitingClients.filter(
      (client) => client.sinceId < message.id,
    );

    for (const client of clientsToNotify) {
      // Отримати всі нові повідомлення для клієнта
      const messages = await this.getMessagesSince(
        client.userId,
        client.sinceId,
      );

      if (messages.length > 0) {
        // Скасувати таймаут
        clearTimeout(client.timeoutId);

        // Відправити відповідь клієнту
        client.resolve({
          messages,
          lastMessageId: messages[messages.length - 1].id,
        });

        // Видалити клієнта зі списку очікування
        this.removeWaitingClient(client.resolve);
      }
    }
  }

  /**
   * Допоміжний метод для видалення клієнта зі списку очікування
   */
  private removeWaitingClient(resolve: (value: any) => void): void {
    const index = this.waitingClients.findIndex((c) => c.resolve === resolve);
    if (index !== -1) {
      this.waitingClients.splice(index, 1);
    }
  }

  /**
   * Отримує повідомлення з БД після вказаного ID
   */
  private async getMessagesSince(
    userId: number,
    sinceId: number,
  ): Promise<Message[]> {
    return this.messagesRepository.find({
      where: { id: MoreThan(sinceId) },
      order: { id: 'ASC' },
      take: 50,
    });
  }
}

// server/messages.service.ts (доповнення)
import { EventEmitter2 } from '@nestjs/event-emitter';

@Injectable()
export class MessagesService {
  constructor(
    @InjectRepository(Message)
    private messagesRepository: Repository<Message>,
    private eventEmitter: EventEmitter2, // Ін'єкція EventEmitter
  ) {}

  /**
   * Створює нове повідомлення та емітує подію для long-polling клієнтів
   */
  async createMessage(
    userId: number,
    text: string,
  ): Promise<Message> {
    const message = this.messagesRepository.create({
      userId,
      text,
      timestamp: new Date(),
    });

    await this.messagesRepository.save(message);

    // Емітувати подію для long-polling сервісу
    this.eventEmitter.emit('message.created', message);

    console.log(`[Messages] Створено повідомлення ${message.id}, подія емітована`);

    return message;
  }
}

// Приклад з Redis Pub/Sub
import { Injectable } from '@nestjs/common';
import { RedisService } from '@liaoliaots/nestjs-redis';
import Redis from 'ioredis';

@Injectable()
export class MessagesPollingService {
  private subscriber: Redis;
  private publisher: Redis;

  constructor(private redisService: RedisService) {
    this.subscriber = this.redisService.getClient('subscriber');
    this.publisher = this.redisService.getClient('publisher');

    // Підписатися на канал нових повідомлень
    this.subscriber.subscribe('messages:new');
    this.subscriber.on('message', (channel, message) => {
      if (channel === 'messages:new') {
        const messageData = JSON.parse(message);
        this.handleNewMessage(messageData);
      }
    });
  }

  async publishNewMessage(message: Message): Promise<void> {
    // Опублікувати подію у Redis — всі інстанси отримають її
    await this.publisher.publish('messages:new', JSON.stringify(message));
  }
}

@Get('poll')
async longPoll(@Req() req: RequestWithUser, @Res() res: Response) {
  const cleanupId = Math.random(); // Унікальний ідентифікатор для cleanup

  req.on('close', () => {
    console.log('[Long-Polling] Клієнт відключився, cleanup');
    this.pollingService.removeClientByCleanupId(cleanupId);
  });

  const result = await this.pollingService.waitForNewMessages(
    req.user.userId,
    sinceId,
    30000,
    cleanupId,
  );

  res.json(result);
}

event: messageCreated
id: 42
data: {"userId": 10, "text": "Привіт, SSE!"}

event: userJoined
id: 43
data: {"userId": 15, "username": "Andriy"}

// client/sse-client.ts

interface MessageData {
  id: number;
  userId: number;
  text: string;
  timestamp: string;
}

interface UserJoinedData {
  userId: number;
  username: string;
}

class SSEClient {
  private eventSource: EventSource | null = null;

  constructor(
    private apiUrl: string,
    private authToken: string,
    private onMessage: (data: MessageData) => void,
    private onUserJoined: (data: UserJoinedData) => void,
    private onError: (error: Event) => void
  ) {}

  /**
   * Підключається до SSE потоку
   */
  connect(): void {
    // EventSource не підтримує кастомні заголовки (наприклад, Authorization)
    // Передаємо токен через query parameter
    const url = `${this.apiUrl}/events/stream?token=${this.authToken}`;

    this.eventSource = new EventSource(url);

    // Загальний обробник для події типу 'message' (за замовчуванням)
    this.eventSource.addEventListener('message', (event: MessageEvent) => {
      console.log('[SSE] Отримано загальну подію:', event.data);
    });

    // Обробник для події типу 'messageCreated'
    this.eventSource.addEventListener('messageCreated', (event: MessageEvent) => {
      const data: MessageData = JSON.parse(event.data);
      console.log(`[SSE] Нове повідомлення ${data.id}: ${data.text}`);
      this.onMessage(data);
    });

    // Обробник для події типу 'userJoined'
    this.eventSource.addEventListener('userJoined', (event: MessageEvent) => {
      const data: UserJoinedData = JSON.parse(event.data);
      console.log(`[SSE] Користувач приєднався: ${data.username}`);
      this.onUserJoined(data);
    });

    // Обробник помилок та розривів з'єднання
    this.eventSource.addEventListener('error', (event: Event) => {
      console.error('[SSE] Помилка з\'єднання:', event);

      if (this.eventSource?.readyState === EventSource.CLOSED) {
        console.log('[SSE] З\'єднання закрито сервером');
      } else if (this.eventSource?.readyState === EventSource.CONNECTING) {
        console.log('[SSE] Спроба автоматичного reconnect...');
      }

      this.onError(event);
    });

    // Обробник успішного підключення
    this.eventSource.addEventListener('open', () => {
      console.log('[SSE] З\'єднання встановлено');
    });

    console.log('[SSE] Підключення до:', url);
  }

  /**
   * Закриває SSE з'єднання
   */
  disconnect(): void {
    if (this.eventSource) {
      this.eventSource.close();
      this.eventSource = null;
      console.log('[SSE] З\'єднання закрито клієнтом');
    }
  }

  /**
   * Перевіряє статус з'єднання
   */
  getReadyState(): number | null {
    return this.eventSource?.readyState ?? null;
  }
}

// Використання
const client = new SSEClient(
  'https://api.example.com',
  localStorage.getItem('authToken') || '',
  (message) => {
    // Додати повідомлення до UI
    const messageEl = document.createElement('div');
    messageEl.textContent = `[${message.userId}]: ${message.text}`;
    document.getElementById('messages')?.appendChild(messageEl);
  },
  (user) => {
    // Показати нотифікацію про приєднання користувача
    console.log(`${user.username} приєднався до чату`);
  },
  (error) => {
    // Показати користувачу повідомлення про втрату з'єднання
    console.error('Втрачено з\'єднання з сервером');
  }
);

client.connect();

// Закрити при виході зі сторінки
window.addEventListener('beforeunload', () => {
  client.disconnect();
});

// server/events.controller.ts
import { Controller, Sse, Query, UnauthorizedException } from '@nestjs/common';
import { Observable, interval, map, filter } from 'rxjs';
import { EventsService } from './events.service';
import { JwtService } from '@nestjs/jwt';

interface SseEvent {
  event?: string;
  data: any;
  id?: string;
  retry?: number;
}

@Controller('events')
export class EventsController {
  constructor(
    private readonly eventsService: EventsService,
    private readonly jwtService: JwtService,
  ) {}

  /**
   * SSE ендпоінт: повертає Observable потік подій
   */
  @Sse('stream')
  streamEvents(@Query('token') token: string): Observable<SseEvent> {
    // Валідація JWT токена (передається через query parameter)
    let userId: number;

    try {
      const payload = this.jwtService.verify(token);
      userId = payload.sub;
    } catch (error) {
      throw new UnauthorizedException('Invalid token');
    }

    console.log(`[SSE] Клієнт ${userId} підключився до потоку`);

    // Повертаємо Observable, який емітує події
    return this.eventsService.subscribeToEvents(userId);
  }
}

// server/events.service.ts
import { Injectable } from '@nestjs/common';
import { Observable, Subject, merge, interval, map } from 'rxjs';

interface SseEvent {
  event?: string;
  data: any;
  id?: string;
}

@Injectable()
export class EventsService {
  // Subject для емітування подій до всіх підписаних клієнтів
  private eventsSubject = new Subject<SseEvent>();
  private eventIdCounter = 0;

  /**
   * Підписує клієнта на потік подій
   */
  subscribeToEvents(userId: number): Observable<SseEvent> {
    console.log(`[SSE] Користувач ${userId} підписаний на події`);

    // Heartbeat: кожні 15 секунд відправляємо коментар для утримання з'єднання
    const heartbeat$ = interval(15000).pipe(
      map(() => ({
        event: 'heartbeat',
        data: { timestamp: new Date().toISOString() },
      })),
    );

    // Об'єднуємо потік реальних подій з heartbeat
    return merge(this.eventsSubject.asObservable(), heartbeat$);
  }

  /**
   * Емітує подію про створення нового повідомлення
   */
  emitMessageCreated(message: any): void {
    this.eventIdCounter++;

    this.eventsSubject.next({
      event: 'messageCreated',
      data: message,
      id: this.eventIdCounter.toString(),
    });

    console.log(`[SSE] Емітовано подію messageCreated (id: ${this.eventIdCounter})`);
  }

  /**
   * Емітує подію про приєднання користувача
   */
  emitUserJoined(user: { userId: number; username: string }): void {
    this.eventIdCounter++;

    this.eventsSubject.next({
      event: 'userJoined',
      data: user,
      id: this.eventIdCounter.toString(),
    });

    console.log(`[SSE] Емітовано подію userJoined (id: ${this.eventIdCounter})`);
  }
}

// server/messages.service.ts (доповнення)
@Injectable()
export class MessagesService {
  constructor(
    @InjectRepository(Message)
    private messagesRepository: Repository<Message>,
    private eventsService: EventsService, // Ін'єкція SSE сервісу
  ) {}

  async createMessage(userId: number, text: string): Promise<Message> {
    const message = this.messagesRepository.create({
      userId,
      text,
      timestamp: new Date(),
    });

    await this.messagesRepository.save(message);

    // Розіслати SSE подію всім підключеним клієнтам
    this.eventsService.emitMessageCreated({
      id: message.id,
      userId: message.userId,
      text: message.text,
      timestamp: message.timestamp.toISOString(),
    });

    return message;
  }
}

: heartbeat

: heartbeat

Last-Event-ID: 42

@Sse('stream')
streamEvents(
  @Query('token') token: string,
  @Headers('last-event-id') lastEventId?: string,
): Observable<SseEvent> {
  const userId = this.validateToken(token);
  const sinceEventId = parseInt(lastEventId || '0', 10);

  console.log(`[SSE] Reconnect від ${userId}, lastEventId: ${sinceEventId}`);

  // Відправити пропущені події з кешу або БД
  return this.eventsService.subscribeToEvents(userId, sinceEventId);
}

@Injectable()
export class EventsService {
  private eventHistory: SseEvent[] = []; // Останні 100 подій
  private readonly MAX_HISTORY = 100;

  emitEvent(event: SseEvent): void {
    this.eventsSubject.next(event);

    // Зберегти у історії
    this.eventHistory.push(event);
    if (this.eventHistory.length > this.MAX_HISTORY) {
      this.eventHistory.shift(); // Видалити найстарішу
    }
  }

  subscribeToEvents(userId: number, sinceEventId: number): Observable<SseEvent> {
    // Відправити пропущені події
    const missedEvents = this.eventHistory.filter(
      (e) => parseInt(e.id || '0', 10) > sinceEventId,
    );

    return concat(
      from(missedEvents), // Спочатку пропущені події
      this.eventsSubject.asObservable(), // Потім live події
    );
  }
}

// client/websocket-client.ts (базовий приклад без Socket.IO)

class WebSocketClient {
  private ws: WebSocket | null = null;
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 5;

  constructor(
    private url: string,
    private onMessage: (data: any) => void,
    private onError: (error: Event) => void
  ) {}

  connect(): void {
    // Передаємо JWT токен через query parameter
    const token = localStorage.getItem('authToken');
    this.ws = new WebSocket(`${this.url}?token=${token}`);

    this.ws.addEventListener('open', () => {
      console.log('[WebSocket] З\'єднання встановлено');
      this.reconnectAttempts = 0;
    });

    this.ws.addEventListener('message', (event: MessageEvent) => {
      const data = JSON.parse(event.data);
      console.log('[WebSocket] Отримано:', data);
      this.onMessage(data);
    });

    this.ws.addEventListener('close', (event: CloseEvent) => {
      console.log(`[WebSocket] З\'єднання закрито: ${event.code} ${event.reason}`);
      this.attemptReconnect();
    });

    this.ws.addEventListener('error', (error: Event) => {
      console.error('[WebSocket] Помилка:', error);
      this.onError(error);
    });
  }

  send(data: any): void {
    if (this.ws?.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify(data));
    } else {
      console.error('[WebSocket] З\'єднання не відкрито');
    }
  }

  disconnect(): void {
    this.ws?.close(1000, 'Client disconnect');
  }

  private attemptReconnect(): void {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
      const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
      console.log(`[WebSocket] Reconnect через ${delay}ms (спроба ${this.reconnectAttempts})`);
      setTimeout(() => this.connect(), delay);
    } else {
      console.error('[WebSocket] Перевищено ліміт спроб reconnect');
    }
  }
}

// Socket.IO автоматично обирає найкращий транспорт
const socket = io('https://api.example.com', {
  transports: ['websocket', 'polling'], // Пріоритет: WebSocket → Long-Polling
});

// server/polling.controller.ts
import { Throttle } from '@nestjs/throttler';

@Controller('messages')
export class MessagesController {
  @Get('new')
  @Throttle({ default: { limit: 20, ttl: 60000 } }) // Максимум 20 запитів за хвилину
  async getNewMessages(@Query('since') since: string) {
    // ...
  }
}

// Приклад метрики для Prometheus
import { Counter, Gauge } from 'prom-client';

const activeConnections = new Gauge({
  name: 'websocket_active_connections',
  help: 'Кількість активних WebSocket з\'єднань',
});

const messagesTotal = new Counter({
  name: 'websocket_messages_total',
  help: 'Загальна кількість відправлених повідомлень',
  labelNames: ['type'],
});

// При підключенні клієнта
activeConnections.inc();

// При відправці повідомлення
messagesTotal.inc({ type: 'messageCreated' });