# Генерація модуля та gateway через NestJS CLI
nest generate module chat
nest generate gateway chat/chat --no-spec
nest generate service chat/chat --no-spec

// src/chat/chat.gateway.ts
import {
  WebSocketGateway,
  WebSocketServer,
  SubscribeMessage,
  MessageBody,
  ConnectedSocket,
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

@WebSocketGateway({
  cors: {
    origin: 'http://localhost:3000', // Дозволити з'єднання з frontend
    credentials: true,
  },
})
export class ChatGateway {
  @WebSocketServer()
  server: Server; // Socket.IO server instance

  /**
   * Обробник події 'message' від клієнта
   */
  @SubscribeMessage('message')
  handleMessage(
    @MessageBody() data: string,
    @ConnectedSocket() client: Socket,
  ): string {
    console.log(`[WebSocket] Отримано повідомлення від ${client.id}: ${data}`);

    // Повертаємо відповідь клієнту
    return `Сервер отримав: ${data}`;
  }

  /**
   * Broadcast: розсилка повідомлення всім підключеним клієнтам
   */
  @SubscribeMessage('broadcast')
  handleBroadcast(@MessageBody() message: string): void {
    console.log(`[WebSocket] Broadcast: ${message}`);

    // Відправити всім клієнтам (включно з відправником)
    this.server.emit('message', {
      text: message,
      timestamp: new Date().toISOString(),
    });
  }
}

// src/chat/chat.module.ts
import { Module } from '@nestjs/common';
import { ChatGateway } from './chat.gateway';
import { ChatService } from './chat.service';

@Module({
  providers: [ChatGateway, ChatService],
  exports: [ChatGateway], // Якщо інші модулі потребують доступу
})
export class ChatModule {}

// src/app.module.ts
import { Module } from '@nestjs/common';
import { ChatModule } from './chat/chat.module';

@Module({
  imports: [ChatModule],
})
export class AppModule {}

npm install socket.io-client

// client/chat-client.ts
import { io, Socket } from 'socket.io-client';

class ChatClient {
  private socket: Socket;

  constructor(serverUrl: string) {
    // Підключення до WebSocket сервера
    this.socket = io(serverUrl, {
      transports: ['websocket', 'polling'], // Пріоритет: WebSocket → fallback на polling
      reconnectionDelayMax: 10000, // Максимальна затримка між reconnect спробами
      reconnectionAttempts: 5, // Кількість спроб reconnect
    });

    this.setupEventListeners();
  }

  /**
   * Налаштування обробників подій
   */
  private setupEventListeners(): void {
    // Успішне підключення
    this.socket.on('connect', () => {
      console.log('[Socket.IO] Підключено, ID:', this.socket.id);
    });

    // Отримання повідомлення від сервера
    this.socket.on('message', (data: { text: string; timestamp: string }) => {
      console.log(`[Socket.IO] Нове повідомлення: ${data.text}`);
      this.displayMessage(data.text, data.timestamp);
    });

    // Відключення
    this.socket.on('disconnect', (reason: string) => {
      console.log('[Socket.IO] Відключено:', reason);
    });

    // Помилка з'єднання
    this.socket.on('connect_error', (error: Error) => {
      console.error('[Socket.IO] Помилка підключення:', error.message);
    });
  }

  /**
   * Відправка повідомлення серверу
   */
  sendMessage(text: string): void {
    this.socket.emit('message', text, (response: string) => {
      // Callback для отримання acknowledgment від сервера
      console.log('[Socket.IO] ACK від сервера:', response);
    });
  }

  /**
   * Broadcast повідомлення всім
   */
  broadcastMessage(text: string): void {
    this.socket.emit('broadcast', text);
  }

  /**
   * Відображення повідомлення у UI (приклад)
   */
  private displayMessage(text: string, timestamp: string): void {
    const messageEl = document.createElement('div');
    messageEl.className = 'message';
    messageEl.innerHTML = `
      <span class="timestamp">${new Date(timestamp).toLocaleTimeString()}</span>
      <span class="text">${text}</span>
    `;
    document.getElementById('messages')?.appendChild(messageEl);
  }

  /**
   * Закриття з'єднання
   */
  disconnect(): void {
    this.socket.disconnect();
  }
}

// Використання
const client = new ChatClient('http://localhost:3001');

// Відправка повідомлення при натисканні кнопки
document.getElementById('sendBtn')?.addEventListener('click', () => {
  const input = document.getElementById('messageInput') as HTMLInputElement;
  client.sendMessage(input.value);
  input.value = '';
});

// Broadcast при натисканні іншої кнопки
document.getElementById('broadcastBtn')?.addEventListener('click', () => {
  const input = document.getElementById('messageInput') as HTMLInputElement;
  client.broadcastMessage(input.value);
  input.value = '';
});

// src/chat/chat.gateway.ts
import {
  WebSocketGateway,
  WebSocketServer,
  SubscribeMessage,
  MessageBody,
  ConnectedSocket,
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

interface ChatMessage {
  roomId: string;
  userId: number;
  username: string;
  text: string;
  timestamp: Date;
}

@WebSocketGateway({ cors: { origin: '*' } })
export class ChatGateway {
  @WebSocketServer()
  server: Server;

  /**
   * Сценарій 1: Персональна відповідь одному клієнту
   * Використання: client.emit()
   */
  @SubscribeMessage('ping')
  handlePing(@ConnectedSocket() client: Socket): void {
    // Відправити відповідь ЛИШЕ клієнту, який відправив ping
    client.emit('pong', {
      message: 'Сервер онлайн',
      serverTime: new Date().toISOString(),
    });

    console.log(`[WebSocket] Ping від ${client.id}, відповідь надіслана`);
  }

  /**
   * Сценарій 2: Сповіщення інших про дію одного користувача
   * Використання: client.broadcast.emit()
   */
  @SubscribeMessage('userTyping')
  handleUserTyping(
    @MessageBody() data: { roomId: string; username: string },
    @ConnectedSocket() client: Socket,
  ): void {
    // Відправити ВСІМ у кімнаті, ОКРІМ того, хто друкує
    client.broadcast.to(data.roomId).emit('userTyping', {
      username: data.username,
      isTyping: true,
    });

    console.log(`[WebSocket] ${data.username} друкує у кімнаті ${data.roomId}`);
  }

  /**
   * Сценарій 3: Глобальне оголошення для всіх
   * Використання: this.server.emit()
   */
  @SubscribeMessage('serverAnnouncement')
  handleServerAnnouncement(@MessageBody() announcement: string): void {
    // Відправити ВСІМ підключеним клієнтам (включно з відправником)
    this.server.emit('announcement', {
      type: 'info',
      message: announcement,
      timestamp: new Date().toISOString(),
    });

    console.log(`[WebSocket] Broadcast оголошення: ${announcement}`);
  }

  /**
   * Сценарій 4: Повідомлення у груповий чат
   * Використання: this.server.to(room).emit()
   */
  @SubscribeMessage('sendMessage')
  handleSendMessage(
    @MessageBody() message: ChatMessage,
    @ConnectedSocket() client: Socket,
  ): void {
    // Відправити всім у кімнаті (включно з відправником)
    this.server.to(message.roomId).emit('newMessage', {
      id: Math.random().toString(36).substr(2, 9),
      ...message,
      timestamp: new Date().toISOString(),
    });

    console.log(`[WebSocket] Повідомлення у кімнаті ${message.roomId}: ${message.text}`);
  }

  /**
   * Сценарій 5: Сповіщення інших у кімнаті про read receipt
   * Використання: client.to(room).emit()
   */
  @SubscribeMessage('markAsRead')
  handleMarkAsRead(
    @MessageBody() data: { roomId: string; messageId: string; userId: number },
    @ConnectedSocket() client: Socket,
  ): void {
    // Відправити всім у кімнаті ОКРІМ того, хто прочитав
    client.to(data.roomId).emit('messageRead', {
      messageId: data.messageId,
      readBy: data.userId,
      timestamp: new Date().toISOString(),
    });

    console.log(`[WebSocket] Повідомлення ${data.messageId} прочитано користувачем ${data.userId}`);
  }
}

// src/chat/chat.gateway.ts
import { UseGuards } from '@nestjs/common';
import { ChatService } from './chat.service';

interface SendMessageDto {
  roomId: string;
  text: string;
}

interface AckResponse {
  success: boolean;
  messageId?: string;
  error?: string;
}

@WebSocketGateway({ cors: { origin: '*' } })
export class ChatGateway {
  constructor(private readonly chatService: ChatService) {}

  @WebSocketServer()
  server: Server;

  /**
   * Обробка відправки повідомлення з ACK
   * Третій параметр — callback функція для acknowledgment
   */
  @SubscribeMessage('sendMessage')
  async handleSendMessage(
    @MessageBody() data: SendMessageDto,
    @ConnectedSocket() client: Socket,
  ): Promise<AckResponse> {
    try {
      // Валідація
      if (!data.text || data.text.trim().length === 0) {
        return {
          success: false,
          error: 'Повідомлення не може бути порожнім',
        };
      }

      if (data.text.length > 1000) {
        return {
          success: false,
          error: 'Повідомлення занадто довге (макс. 1000 символів)',
        };
      }

      // Витягти userId з client.data (встановлюється при автентифікації)
      const userId = (client as any).userId;

      // Зберегти у БД через service
      const message = await this.chatService.createMessage({
        roomId: data.roomId,
        userId,
        text: data.text,
      });

      // Broadcast повідомлення всім у кімнаті
      this.server.to(data.roomId).emit('newMessage', {
        id: message.id,
        userId: message.userId,
        username: message.user.username,
        text: message.text,
        timestamp: message.createdAt,
      });

      // Повернути успішну відповідь з ID повідомлення
      return {
        success: true,
        messageId: message.id,
      };
    } catch (error) {
      console.error('[WebSocket] Помилка створення повідомлення:', error);

      return {
        success: false,
        error: 'Внутрішня помилка сервера',
      };
    }
  }
}

// client/chat-client.ts
interface SendMessageResponse {
  success: boolean;
  messageId?: string;
  error?: string;
}

class ChatClient {
  private socket: Socket;

  /**
   * Відправка повідомлення з очікуванням acknowledgment
   */
  async sendMessage(roomId: string, text: string): Promise<void> {
    // Показати індикатор відправки
    this.showSendingIndicator();

    // Відправити повідомлення та отримати ACK через callback
    this.socket.emit(
      'sendMessage',
      { roomId, text },
      (response: SendMessageResponse) => {
        this.hideSendingIndicator();

        if (response.success) {
          console.log('[Chat] Повідомлення відправлено, ID:', response.messageId);
          this.showSuccessNotification('Повідомлення відправлено');
        } else {
          console.error('[Chat] Помилка відправки:', response.error);
          this.showErrorNotification(response.error || 'Невідома помилка');
        }
      }
    );
  }

  /**
   * Альтернативний підхід: обгортка у Promise для async/await стилю
   */
  sendMessageAsync(roomId: string, text: string): Promise<SendMessageResponse> {
    return new Promise((resolve, reject) => {
      // Timeout для запобігання нескінченного очікування
      const timeout = setTimeout(() => {
        reject(new Error('Timeout: сервер не відповів протягом 10 секунд'));
      }, 10000);

      this.socket.emit(
        'sendMessage',
        { roomId, text },
        (response: SendMessageResponse) => {
          clearTimeout(timeout);
          resolve(response);
        }
      );
    });
  }

  // Використання з async/await
  async handleSendButtonClick(): Promise<void> {
    try {
      const response = await this.sendMessageAsync('room-123', 'Привіт, світ!');

      if (response.success) {
        console.log('Успіх! ID:', response.messageId);
      } else {
        console.error('Помилка:', response.error);
      }
    } catch (error) {
      console.error('Timeout або мережева помилка:', error);
    }
  }
}

// src/chat/entities/message.entity.ts
import {
  Entity,
  PrimaryGeneratedColumn,
  Column,
  ManyToOne,
  CreateDateColumn,
  JoinColumn,
} from 'typeorm';
import { User } from '../../users/entities/user.entity';

@Entity('messages')
export class Message {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column()
  roomId: string;

  @Column()
  userId: number;

  @ManyToOne(() => User, { eager: true }) // Завантажувати user автоматично
  @JoinColumn({ name: 'userId' })
  user: User;

  @Column({ type: 'text' })
  text: string;

  @CreateDateColumn()
  createdAt: Date;

  @Column({ default: false })
  isEdited: boolean;

  @Column({ type: 'timestamp', nullable: true })
  editedAt?: Date;
}

// src/chat/chat.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Message } from './entities/message.entity';

interface CreateMessageDto {
  roomId: string;
  userId: number;
  text: string;
}

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

  /**
   * Створює нове повідомлення у БД
   */
  async createMessage(dto: CreateMessageDto): Promise<Message> {
    const message = this.messageRepository.create({
      roomId: dto.roomId,
      userId: dto.userId,
      text: dto.text,
    });

    return this.messageRepository.save(message);
  }

  /**
   * Отримує останні N повідомлень з кімнати
   */
  async getRecentMessages(roomId: string, limit: number = 50): Promise<Message[]> {
    return this.messageRepository.find({
      where: { roomId },
      order: { createdAt: 'DESC' },
      take: limit,
    });
  }

  /**
   * Редагування повідомлення
   */
  async editMessage(messageId: string, newText: string): Promise<Message> {
    const message = await this.messageRepository.findOneByOrFail({ id: messageId });

    message.text = newText;
    message.isEdited = true;
    message.editedAt = new Date();

    return this.messageRepository.save(message);
  }

  /**
   * Видалення повідомлення
   */
  async deleteMessage(messageId: string): Promise<void> {
    await this.messageRepository.delete({ id: messageId });
  }
}

// src/chat/chat.gateway.ts (оновлений)
import { UseGuards } from '@nestjs/common';
import { ChatService } from './chat.service';

@WebSocketGateway({ cors: { origin: '*' } })
export class ChatGateway {
  constructor(
    private readonly chatService: ChatService, // DI через constructor
  ) {}

  @WebSocketServer()
  server: Server;

  /**
   * Завантаження історії повідомлень при підключенні до кімнати
   */
  @SubscribeMessage('joinRoom')
  async handleJoinRoom(
    @MessageBody() data: { roomId: string },
    @ConnectedSocket() client: Socket,
  ): Promise<void> {
    // Додати клієнта до Socket.IO room
    client.join(data.roomId);

    console.log(`[WebSocket] Клієнт ${client.id} приєднався до кімнати ${data.roomId}`);

    // Завантажити історію повідомлень з БД
    const recentMessages = await this.chatService.getRecentMessages(data.roomId, 50);

    // Відправити історію клієнту
    client.emit('messageHistory', {
      roomId: data.roomId,
      messages: recentMessages.reverse(), // Від старіших до новіших
    });
  }

  /**
   * Створення повідомлення з збереженням у БД
   */
  @SubscribeMessage('sendMessage')
  async handleSendMessage(
    @MessageBody() data: { roomId: string; text: string },
    @ConnectedSocket() client: Socket,
  ): Promise<{ success: boolean; messageId?: string; error?: string }> {
    try {
      const userId = (client as any).userId; // З автентифікації

      // Зберегти у БД через service
      const message = await this.chatService.createMessage({
        roomId: data.roomId,
        userId,
        text: data.text,
      });

      // Broadcast всім у кімнаті
      this.server.to(data.roomId).emit('newMessage', {
        id: message.id,
        userId: message.userId,
        username: message.user.username,
        text: message.text,
        createdAt: message.createdAt,
        isEdited: false,
      });

      return { success: true, messageId: message.id };
    } catch (error) {
      console.error('[WebSocket] Помилка створення повідомлення:', error);
      return { success: false, error: 'Внутрішня помилка сервера' };
    }
  }

  /**
   * Редагування повідомлення
   */
  @SubscribeMessage('editMessage')
  async handleEditMessage(
    @MessageBody() data: { messageId: string; newText: string },
    @ConnectedSocket() client: Socket,
  ): Promise<{ success: boolean; error?: string }> {
    try {
      const updatedMessage = await this.chatService.editMessage(
        data.messageId,
        data.newText,
      );

      // Broadcast оновлення всім у кімнаті
      this.server.to(updatedMessage.roomId).emit('messageEdited', {
        messageId: updatedMessage.id,
        newText: updatedMessage.text,
        editedAt: updatedMessage.editedAt,
      });

      return { success: true };
    } catch (error) {
      console.error('[WebSocket] Помилка редагування:', error);
      return { success: false, error: 'Повідомлення не знайдено' };
    }
  }
}

// src/chat/chat.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ChatGateway } from './chat.gateway';
import { ChatService } from './chat.service';
import { Message } from './entities/message.entity';
import { UsersModule } from '../users/users.module';

@Module({
  imports: [
    TypeOrmModule.forFeature([Message]), // Реєстрація Entity
    UsersModule, // Якщо потрібен доступ до User entity
  ],
  providers: [ChatGateway, ChatService],
  exports: [ChatService],
})
export class ChatModule {}

// src/chat/guards/ws-jwt.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Socket } from 'socket.io';

@Injectable()
export class WsJwtGuard implements CanActivate {
  constructor(private jwtService: JwtService) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    try {
      const client: Socket = context.switchToWs().getClient();

      // Витягти токен з handshake auth
      const token = client.handshake.auth?.token || client.handshake.headers?.authorization?.split(' ')[1];

      if (!token) {
        console.error('[WsJwtGuard] Токен відсутній');
        client.disconnect(); // Примусово відключити клієнта
        return false;
      }

      // Валідувати JWT токен
      const payload = await this.jwtService.verifyAsync(token, {
        secret: process.env.JWT_SECRET,
      });

      // Зберегти userId та інші дані у client.data для подальшого використання
      (client as any).userId = payload.sub;
      (client as any).username = payload.username;
      (client as any).roles = payload.roles || [];

      console.log(`[WsJwtGuard] Автентифіковано користувача ${payload.username} (ID: ${payload.sub})`);

      return true;
    } catch (error) {
      console.error('[WsJwtGuard] Помилка валідації токена:', error.message);
      context.switchToWs().getClient().disconnect();
      return false;
    }
  }
}

// src/chat/chat.gateway.ts
import { UseGuards } from '@nestjs/common';
import { WsJwtGuard } from './guards/ws-jwt.guard';

@WebSocketGateway({
  cors: {
    origin: 'http://localhost:3000',
    credentials: true,
  },
})
@UseGuards(WsJwtGuard) // Застосувати Guard до всього Gateway
export class ChatGateway {
  constructor(
    private readonly chatService: ChatService,
    private readonly jwtService: JwtService, // Для інших потреб
  ) {}

  @WebSocketServer()
  server: Server;

  /**
   * Використання userId з автентифікації
   */
  @SubscribeMessage('sendMessage')
  async handleSendMessage(
    @MessageBody() data: { roomId: string; text: string },
    @ConnectedSocket() client: Socket,
  ) {
    // Отримати userId, що був встановлений у Guard
    const userId = (client as any).userId;
    const username = (client as any).username;

    const message = await this.chatService.createMessage({
      roomId: data.roomId,
      userId,
      text: data.text,
    });

    this.server.to(data.roomId).emit('newMessage', {
      id: message.id,
      userId,
      username,
      text: message.text,
      createdAt: message.createdAt,
    });

    return { success: true, messageId: message.id };
  }

  /**
   * Альтернативний підхід: Guard на рівні окремого handler
   */
  @SubscribeMessage('adminBroadcast')
  @UseGuards(WsJwtGuard) // Guard лише для цього методу
  handleAdminBroadcast(
    @MessageBody() message: string,
    @ConnectedSocket() client: Socket,
  ) {
    const roles = (client as any).roles;

    if (!roles.includes('admin')) {
      client.emit('error', { message: 'Insufficient permissions' });
      return;
    }

    this.server.emit('announcement', {
      message,
      from: 'Admin',
      timestamp: new Date(),
    });
  }
}

// client/chat-client.ts
import { io, Socket } from 'socket.io-client';

class AuthenticatedChatClient {
  private socket: Socket;

  constructor(serverUrl: string, jwtToken: string) {
    // Передати JWT токен через auth опцію
    this.socket = io(serverUrl, {
      auth: {
        token: jwtToken, // Токен буде доступний у server через client.handshake.auth.token
      },
      transports: ['websocket', 'polling'],
    });

    this.setupEventListeners();
  }

  private setupEventListeners(): void {
    this.socket.on('connect', () => {
      console.log('[Socket.IO] Підключено з автентифікацією');
    });

    this.socket.on('connect_error', (error: Error) => {
      console.error('[Socket.IO] Помилка підключення:', error.message);
      
      // Якщо токен невалідний — запросити повторний логін
      if (error.message.includes('jwt')) {
        alert('Сесія закінчилася, будь ласка, увійдіть знову');
        window.location.href = '/login';
      }
    });

    this.socket.on('error', (data: { message: string }) => {
      console.error('[Socket.IO] Помилка від сервера:', data.message);
    });
  }

  sendMessage(roomId: string, text: string): void {
    this.socket.emit('sendMessage', { roomId, text }, (response: any) => {
      if (response.success) {
        console.log('Повідомлення відправлено:', response.messageId);
      }
    });
  }
}

// Використання
const token = localStorage.getItem('accessToken');
if (!token) {
  window.location.href = '/login';
} else {
  const client = new AuthenticatedChatClient('http://localhost:3001', token);
}

// src/chat/middleware/ws-auth.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Socket } from 'socket.io';

@Injectable()
export class WsAuthMiddleware implements NestMiddleware {
  constructor(private jwtService: JwtService) {}

  use(client: Socket, next: () => void) {
    try {
      const token = client.handshake.auth?.token;

      if (!token) {
        throw new Error('No token provided');
      }

      const payload = this.jwtService.verify(token, {
        secret: process.env.JWT_SECRET,
      });

      // Перевірка закінчення токена
      const currentTime = Math.floor(Date.now() / 1000);
      if (payload.exp < currentTime) {
        throw new Error('Token expired');
      }

      (client as any).userId = payload.sub;
      (client as any).username = payload.username;

      next();
    } catch (error) {
      console.error('[WsAuthMiddleware] Помилка автентифікації:', error.message);
      client.emit('authError', { message: error.message });
      client.disconnect();
    }
  }
}

// src/chat/chat.gateway.ts
@WebSocketGateway({
  cors: {
    origin: 'http://localhost:3000', // Дозволити з'єднання з frontend
    credentials: true, // Дозволити передачу cookies
  },
})
export class ChatGateway {
  // ...
}

@WebSocketGateway({
  cors: {
    origin: (origin, callback) => {
      const allowedOrigins = [
        'http://localhost:3000',
        'https://app.example.com',
        'https://admin.example.com',
      ];

      if (!origin || allowedOrigins.includes(origin)) {
        callback(null, true); // Дозволити
      } else {
        callback(new Error('Not allowed by CORS')); // Заблокувати
      }
    },
    credentials: true,
  },
})
export class ChatGateway {
  // ...
}

// src/chat/chat.gateway.ts
@WebSocketGateway({
  cors: {
    origin: process.env.FRONTEND_URL || 'http://localhost:3000',
    credentials: true,
    methods: ['GET', 'POST'], // Дозволені HTTP методи для handshake
  },
})
export class ChatGateway {
  // ...
}

# .env
FRONTEND_URL=https://app.example.com

@WebSocketGateway({
  cors: {
    origin: '*', // Дозволити з будь-якого домену (⚠️ НЕБЕЗПЕЧНО)
    credentials: false, // При * не можна використовувати credentials: true
  },
})
export class ChatGateway {
  // ...
}

Access to XMLHttpRequest at 'http://localhost:3001/socket.io/?EIO=4&transport=polling'
from origin 'http://localhost:3000' has been blocked by CORS policy

# Відкрити Chrome DevTools → Network → фільтр "WS" (WebSocket)
# Переглянути Headers для socket.io запитів:
Request Headers:
  Origin: http://localhost:3000

Response Headers:
  Access-Control-Allow-Origin: http://localhost:3000
  Access-Control-Allow-Credentials: true

// src/chat/chat.gateway.ts
@WebSocketGateway({
  namespace: '/chat', // Клієнти підключаються до ws://localhost:3001/chat
  cors: { origin: '*' },
})
export class ChatGateway {
  // Обробляє події лише у namespace /chat
}

// src/notifications/notifications.gateway.ts
@WebSocketGateway({
  namespace: '/notifications', // ws://localhost:3001/notifications
  cors: { origin: '*' },
})
export class NotificationsGateway {
  // Незалежний від ChatGateway канал
}

// client/chat-client.ts
const chatSocket = io('http://localhost:3001/chat'); // Підключення до /chat
const notifSocket = io('http://localhost:3001/notifications'); // Підключення до /notifications

chatSocket.emit('sendMessage', { text: 'Привіт' });
notifSocket.on('newNotification', (data) => {
  console.log('Нова нотифікація:', data);
});

@WebSocketGateway({
  port: 3002, // WebSocket працює на порту 3002
  cors: { origin: '*' },
})
export class ChatGateway {
  // HTTP сервер: http://localhost:3001
  // WebSocket сервер: ws://localhost:3002
}

@WebSocketGateway({
  path: '/my-custom-path/', // ws://localhost:3001/my-custom-path/
  cors: { origin: '*' },
})
export class ChatGateway {
  // ...
}

const socket = io('http://localhost:3001', {
  path: '/my-custom-path/',
});

// client/hooks/useChat.ts
import { useEffect, useState, useCallback } from 'react';
import { io, Socket } from 'socket.io-client';

interface Message {
  id: string;
  userId: number;
  username: string;
  text: string;
  createdAt: string;
}

export const useChat = (roomId: string, jwtToken: string) => {
  const [socket, setSocket] = useState<Socket | null>(null);
  const [messages, setMessages] = useState<Message[]>([]);
  const [isConnected, setIsConnected] = useState(false);

  useEffect(() => {
    const newSocket = io('http://localhost:3001', {
      auth: { token: jwtToken },
    });

    newSocket.on('connect', () => {
      setIsConnected(true);
      newSocket.emit('joinRoom', { roomId });
    });

    newSocket.on('messageHistory', (data: { messages: Message[] }) => {
      setMessages(data.messages);
    });

    newSocket.on('newMessage', (message: Message) => {
      setMessages((prev) => [...prev, message]);
    });

    newSocket.on('disconnect', () => setIsConnected(false));

    setSocket(newSocket);

    return () => {
      newSocket.disconnect();
    };
  }, [roomId, jwtToken]);

  const sendMessage = useCallback(
    (text: string) => {
      if (socket) {
        socket.emit('sendMessage', { roomId, text });
      }
    },
    [socket, roomId]
  );

  return { messages, sendMessage, isConnected };
};

// src/chat/filters/ws-exception.filter.ts
import { Catch, ArgumentsHost } from '@nestjs/common';
import { BaseWsExceptionFilter, WsException } from '@nestjs/websockets';
import { Socket } from 'socket.io';

@Catch(WsException)
export class WsExceptionFilter extends BaseWsExceptionFilter {
  catch(exception: WsException, host: ArgumentsHost) {
    const client: Socket = host.switchToWs().getClient();

    // Отримати деталі помилки
    const error = exception.getError();
    const details = typeof error === 'string' ? { message: error } : error;

    // Відправити структуровану помилку клієнту
    client.emit('exception', {
      status: 'error',
      message: details['message'] || 'Internal server error',
      timestamp: new Date().toISOString(),
    });

    console.error('[WebSocket Exception]:', details);
  }
}

// src/chat/chat.gateway.ts
import { UseFilters } from '@nestjs/common';
import { WsException } from '@nestjs/websockets';
import { WsExceptionFilter } from './filters/ws-exception.filter';

@WebSocketGateway({ cors: { origin: '*' } })
@UseFilters(WsExceptionFilter) // Застосувати до всього Gateway
export class ChatGateway {
  @SubscribeMessage('sendMessage')
  async handleSendMessage(
    @MessageBody() data: { roomId: string; text: string },
    @ConnectedSocket() client: Socket,
  ) {
    // Валідація
    if (!data.text || data.text.trim().length === 0) {
      throw new WsException('Повідомлення не може бути порожнім');
    }

    if (data.text.length > 1000) {
      throw new WsException('Повідомлення занадто довге (макс. 1000 символів)');
    }

    try {
      const userId = (client as any).userId;
      const message = await this.chatService.createMessage({
        roomId: data.roomId,
        userId,
        text: data.text,
      });

      this.server.to(data.roomId).emit('newMessage', message);

      return { success: true, messageId: message.id };
    } catch (error) {
      console.error('[WebSocket] Помилка створення повідомлення:', error);
      throw new WsException('Не вдалося створити повідомлення');
    }
  }
}

// client/chat-client.ts
socket.on('exception', (error: { status: string; message: string }) => {
  console.error('[Socket.IO] Помилка від сервера:', error.message);

  // Показати toast notification користувачу
  showErrorToast(error.message);
});

// Надсилання повідомлення з обробкою помилок
function sendMessage(text: string) {
  socket.emit('sendMessage', { roomId: 'room-123', text }, (response: any) => {
    if (response?.success) {
      console.log('Повідомлення відправлено');
    } else {
      console.error('Помилка:', response?.error || 'Unknown error');
    }
  });

  // Timeout для випадку, коли сервер не відповідає
  setTimeout(() => {
    showErrorToast('Сервер не відповідає, спробуйте пізніше');
  }, 10000);
}

npm install class-validator class-transformer

// src/chat/dto/send-message.dto.ts
import { IsString, IsNotEmpty, MaxLength, IsUUID } from 'class-validator';

export class SendMessageDto {
  @IsUUID()
  @IsNotEmpty({ message: 'Room ID є обов\'язковим' })
  roomId: string;

  @IsString({ message: 'Текст повідомлення має бути рядком' })
  @IsNotEmpty({ message: 'Повідомлення не може бути порожнім' })
  @MaxLength(1000, { message: 'Повідомлення занадто довге (макс. 1000 символів)' })
  text: string;
}

// src/chat/chat.gateway.ts
import { UsePipes, ValidationPipe } from '@nestjs/common';
import { SendMessageDto } from './dto/send-message.dto';

@WebSocketGateway({ cors: { origin: '*' } })
@UsePipes(new ValidationPipe({ transform: true })) // Глобальна валідація
export class ChatGateway {
  @SubscribeMessage('sendMessage')
  async handleSendMessage(
    @MessageBody() dto: SendMessageDto, // Автоматична валідація
    @ConnectedSocket() client: Socket,
  ) {
    // Якщо валідація не пройшла — автоматично викидається WsException
    const userId = (client as any).userId;

    const message = await this.chatService.createMessage({
      roomId: dto.roomId,
      userId,
      text: dto.text,
    });

    this.server.to(dto.roomId).emit('newMessage', message);

    return { success: true, messageId: message.id };
  }
}

// src/chat/types/chat-events.interface.ts
export interface ServerToClientEvents {
  newMessage: (message: {
    id: string;
    userId: number;
    username: string;
    text: string;
    createdAt: string;
  }) => void;
  
  userJoined: (data: { username: string; timestamp: Date }) => void;
  
  messageHistory: (data: {
    roomId: string;
    messages: Message[];
  }) => void;
  
  exception: (error: { status: string; message: string }) => void;
}

export interface ClientToServerEvents {
  sendMessage: (
    data: { roomId: string; text: string },
    callback: (response: { success: boolean; messageId?: string; error?: string }) => void
  ) => void;
  
  joinRoom: (data: { roomId: string }) => void;
  
  leaveRoom: (data: { roomId: string }) => void;
}

// Використання у Gateway
@WebSocketGateway({ cors: { origin: '*' } })
export class ChatGateway {
  @WebSocketServer()
  server: Server<ClientToServerEvents, ServerToClientEvents>;
  
  // Тепер TypeScript перевірить назви подій та їх payload
}

// src/chat/interceptors/ws-logging.interceptor.ts
import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class WsLoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const client = context.switchToWs().getClient();
    const event = context.switchToWs().getPattern();
    const data = context.switchToWs().getData();

    console.log(`[WebSocket IN] ${client.id} → ${event}:`, JSON.stringify(data));

    return next.handle().pipe(
      tap((response) => {
        console.log(`[WebSocket OUT] ${client.id} ← ${event}:`, JSON.stringify(response));
      }),
    );
  }
}

// src/chat/guards/ws-throttler.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Socket } from 'socket.io';

@Injectable()
export class WsThrottlerGuard implements CanActivate {
  private readonly requests = new Map<string, number[]>();
  private readonly maxRequests = 10; // Макс. 10 запитів
  private readonly windowMs = 60000; // За 60 секунд

  canActivate(context: ExecutionContext): boolean {
    const client: Socket = context.switchToWs().getClient();
    const clientId = client.id;

    const now = Date.now();
    const clientRequests = this.requests.get(clientId) || [];

    // Видалити старі запити поза часовим вікном
    const recentRequests = clientRequests.filter((time) => now - time < this.windowMs);

    if (recentRequests.length >= this.maxRequests) {
      client.emit('exception', {
        status: 'error',
        message: 'Занадто багато запитів, спробуйте пізніше',
      });

      console.warn(`[WsThrottler] ${clientId} перевищив rate limit`);
      return false;
    }

    recentRequests.push(now);
    this.requests.set(clientId, recentRequests);

    return true;
  }
}

// Застосування до конкретного handler
@SubscribeMessage('sendMessage')
@UseGuards(WsThrottlerGuard)
async handleSendMessage(/* ... */) {
  // ...
}

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Увімкнути graceful shutdown
  app.enableShutdownHooks();

  await app.listen(3001);

  // Обробка SIGTERM (наприклад, від Docker stop)
  process.on('SIGTERM', async () => {
    console.log('[Server] SIGTERM отримано, graceful shutdown...');
    await app.close();
    process.exit(0);
  });
}

bootstrap();

// src/chat/chat.gateway.ts
import { OnGatewayConnection, OnGatewayDisconnect } from '@nestjs/websockets';

@WebSocketGateway({ cors: { origin: '*' } })
export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
  private activeConnections = 0;

  handleConnection(client: Socket) {
    this.activeConnections++;
    console.log(`[WebSocket] Нове з'єднання. Активних: ${this.activeConnections}`);
  }

  handleDisconnect(client: Socket) {
    this.activeConnections--;
    console.log(`[WebSocket] Відключення. Активних: ${this.activeConnections}`);
  }

  /**
   * Метод для моніторингу (можна викликати через HTTP ендпоінт)
   */
  getActiveConnectionsCount(): number {
    return this.activeConnections;
  }
}

// src/chat/chat.controller.ts (HTTP ендпоінт для метрик)
import { Controller, Get } from '@nestjs/common';
import { ChatGateway } from './chat.gateway';

@Controller('chat')
export class ChatController {
  constructor(private readonly chatGateway: ChatGateway) {}

  @Get('metrics')
  getMetrics() {
    return {
      activeConnections: this.chatGateway.getActiveConnectionsCount(),
      timestamp: new Date(),
    };
  }
}