@pushler/js 1.0.0

package/src/PushlerClient.js

@@ -0,0 +1,605 @@
+import Channel from './Channel';
+import { ChannelTypes, ConnectionStates, Events, ErrorCodes } from './constants';
+
+/**
+ * Основной класс для подключения к Pushler.ru WebSocket серверу
+ */
+class PushlerClient {
+  constructor(options = {}) {
+    this.appKey = options.appKey;
+    this.wsUrl = options.wsUrl || 'ws://pushler.ru:8080/ws';
+    this.apiUrl = options.apiUrl;
+    this.authEndpoint = options.authEndpoint || '/pushler/auth'; // Путь для авторизации каналов
+    this.autoConnect = options.autoConnect !== false;
+    this.reconnectDelay = options.reconnectDelay || 1000;
+    this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
+    
+    this.connectionState = ConnectionStates.DISCONNECTED;
+    this.socket = null;
+    this.socketId = null;
+    this.channels = new Map(); // Хранит каналы по полному имени (с appKey)
+    this.channelAliases = new Map(); // Маппинг оригинальное имя -> полное имя
+    this.eventListeners = new Map();
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.authTimeout = null;
+    
+    // Автоматическое подключение
+    if (this.autoConnect) {
+      this.connect();
+    }
+  }
+
+  /**
+   * Формирование полного имени канала с префиксом appKey
+   * Формат: {appKey}:{channelName}
+   * @param {string} channelName - Оригинальное имя канала
+   * @returns {string} Полное имя канала
+   */
+  formatChannelName(channelName) {
+    // Если канал уже содержит appKey, возвращаем как есть
+    if (channelName.startsWith(this.appKey + ':')) {
+      return channelName;
+    }
+    return `${this.appKey}:${channelName}`;
+  }
+
+  /**
+   * Извлечение оригинального имени канала (без appKey)
+   * @param {string} fullChannelName - Полное имя канала
+   * @returns {string} Оригинальное имя канала
+   */
+  extractChannelName(fullChannelName) {
+    const prefix = this.appKey + ':';
+    if (fullChannelName.startsWith(prefix)) {
+      return fullChannelName.substring(prefix.length);
+    }
+    return fullChannelName;
+  }
+
+  /**
+   * Подключение к WebSocket серверу
+   */
+  connect() {
+    if (this.connectionState === ConnectionStates.CONNECTED || 
+        this.connectionState === ConnectionStates.CONNECTING) {
+      return;
+    }
+
+    this.connectionState = ConnectionStates.CONNECTING;
+    this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+
+    try {
+      if (!this.wsUrl) {
+        throw new Error('WebSocket URL is not configured');
+      }
+      
+      console.log(`PushlerClient: Connecting to ${this.wsUrl}`);
+      this.socket = new WebSocket(this.wsUrl);
+      this.setupWebSocketHandlers();
+    } catch (error) {
+      console.error('PushlerClient: Error creating WebSocket connection:', error);
+      this.handleConnectionError(error);
+    }
+  }
+
+  /**
+   * Настройка обработчиков WebSocket
+   */
+  setupWebSocketHandlers() {
+    this.socket.onopen = () => {
+      // Не устанавливаем CONNECTED здесь - ждем pushler:connection_established
+      // Это предотвращает двойные события и проблемы с переподключением
+      this.connectionState = ConnectionStates.CONNECTING;
+      this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+      console.log('WebSocket connection opened, waiting for connection_established...');
+    };
+
+    this.socket.onmessage = (event) => {
+      this.handleMessage(event);
+    };
+
+    this.socket.onclose = (event) => {
+      this.connectionState = ConnectionStates.DISCONNECTED;
+      this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+      this.emit(Events.DISCONNECTED, event);
+      
+      // Логируем причину закрытия для отладки
+      if (event.code !== 1000) { // 1000 = нормальное закрытие
+        console.warn('WebSocket closed unexpectedly:', {
+          code: event.code,
+          reason: event.reason || 'No reason provided',
+          wasClean: event.wasClean,
+          url: this.wsUrl
+        });
+      }
+      
+      // Автоматическое переподключение
+      if (this.reconnectAttempts < this.maxReconnectAttempts) {
+        this.scheduleReconnect();
+      } else {
+        // Если превышено количество попыток, отправляем ошибку
+        this.emit(Events.ERROR, {
+          code: ErrorCodes.CONNECTION_FAILED,
+          message: `Failed to connect after ${this.maxReconnectAttempts} attempts. Please check if the WebSocket server is running at ${this.wsUrl}`,
+          url: this.wsUrl
+        });
+      }
+    };
+
+    this.socket.onerror = (error) => {
+      this.handleConnectionError(error);
+    };
+  }
+
+  /**
+   * Обработка входящих сообщений
+   */
+  handleMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      
+      switch (message.event) {
+        case 'pushler:connection_established':
+          this.handleConnectionEstablished(message.data);
+          break;
+        case 'pushler:subscription_succeeded':
+          this.handleSubscriptionSucceeded(message);
+          break;
+        case 'pushler:auth_success':
+          this.handleAuthSuccess(message);
+          break;
+        case 'pushler:auth_error':
+          this.handleAuthError(message);
+          break;
+        default:
+          this.handleChannelMessage(message);
+      }
+    } catch (error) {
+      console.error('Error parsing WebSocket message:', error);
+    }
+  }
+
+  /**
+   * Обработка установления соединения
+   */
+  handleConnectionEstablished(data) {
+    this.socketId = data.socket_id;
+    this.connectionState = ConnectionStates.CONNECTED;
+    this.reconnectAttempts = 0;
+    
+    console.log('Connection established with socket ID:', this.socketId);
+    
+    // Переподписываемся на все каналы после переподключения
+    this.resubscribeAllChannels();
+    
+    this.emit(Events.CONNECTED, { socketId: this.socketId });
+  }
+  
+  /**
+   * Переподписка на все каналы после переподключения
+   */
+  resubscribeAllChannels() {
+    for (const [channelName, channel] of this.channels.entries()) {
+      // Сбрасываем флаг подписки
+      channel.subscribed = false;
+      // Выполняем подписку заново
+      this.performChannelSubscription(channel);
+    }
+  }
+
+  /**
+   * Обработка успешной подписки на канал
+   */
+  handleSubscriptionSucceeded(message) {
+    const channel = message.channel;
+    const channelInstance = this.channels.get(channel);
+    
+    if (channelInstance) {
+      channelInstance.subscribed = true;
+      channelInstance.emit(Events.CHANNEL_SUBSCRIBED, message.data || {});
+      console.log(`Channel ${channel} subscribed successfully`);
+    }
+  }
+
+  /**
+   * Обработка успешной аутентификации
+   */
+  handleAuthSuccess(message) {
+    const { channel } = message.data;
+    const channelInstance = this.channels.get(channel);
+    
+    if (channelInstance) {
+      // На сервере уже происходит подписка после успешной авторизации,
+      // поэтому просто помечаем канал как подписанный
+      channelInstance.handleAuthSuccess(message.data);
+    }
+    
+    this.emit(Events.CHANNEL_AUTH_SUCCESS, message.data);
+  }
+
+  /**
+   * Обработка ошибки аутентификации
+   */
+  handleAuthError(message) {
+    const { error } = message.data;
+    this.emit(Events.CHANNEL_AUTH_ERROR, error);
+    this.emit(Events.ERROR, {
+      code: ErrorCodes.AUTHENTICATION_FAILED,
+      message: error
+    });
+  }
+
+  /**
+   * Обработка сообщений каналов
+   */
+  handleChannelMessage(message) {
+    const { channel, event, data } = message;
+    const channelInstance = this.channels.get(channel);
+    
+    if (channelInstance) {
+      channelInstance.handleMessage(event, data);
+    }
+    
+    // Для события возвращаем оригинальное имя канала (без appKey)
+    const originalChannelName = this.extractChannelName(channel);
+    this.emit(Events.MESSAGE_RECEIVED, { channel: originalChannelName, event, data });
+  }
+
+  /**
+   * Подписка на канал
+   * @param {string} channelName - Имя канала (без appKey, будет добавлен автоматически)
+   * @param {Object} options - Опции подписки
+   * @returns {Channel} Объект канала
+   */
+  subscribe(channelName, options = {}) {
+    // Формируем полное имя канала с appKey
+    const fullChannelName = this.formatChannelName(channelName);
+    
+    if (this.channels.has(fullChannelName)) {
+      return this.channels.get(fullChannelName);
+    }
+
+    // Создаем канал с полным именем
+    const channel = new Channel(this, fullChannelName, options);
+    // Сохраняем оригинальное имя для удобства
+    channel.originalName = channelName;
+    
+    this.channels.set(fullChannelName, channel);
+    this.channelAliases.set(channelName, fullChannelName);
+    
+    // Если подключены, сразу подписываемся
+    if (this.connectionState === ConnectionStates.CONNECTED) {
+      this.performChannelSubscription(channel);
+    }
+    
+    return channel;
+  }
+
+  /**
+   * Отписка от канала
+   * @param {string} channelName - Имя канала (можно использовать оригинальное или полное)
+   */
+  unsubscribe(channelName) {
+    // Поддерживаем оба формата имени
+    const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+    
+    const channel = this.channels.get(fullChannelName);
+    if (channel) {
+      channel.unsubscribe();
+      this.channels.delete(fullChannelName);
+      this.channelAliases.delete(channel.originalName || channelName);
+    }
+  }
+
+  /**
+   * Выполнение подписки на канал
+   */
+  performChannelSubscription(channel) {
+    if (this.connectionState !== ConnectionStates.CONNECTED) {
+      return;
+    }
+
+    const channelType = this.getChannelType(channel.name);
+    
+    // Для публичных каналов подписываемся сразу
+    if (channelType === ChannelTypes.PUBLIC) {
+      this.sendMessage({
+        event: 'pushler:subscribe',
+        data: { 
+          channel: channel.name,
+          app_key: this.appKey
+        }
+      });
+      return;
+    }
+
+    // Для приватных и presence каналов нужна аутентификация
+    this.authenticateChannel(channel);
+  }
+
+  /**
+   * Аутентификация канала
+   */
+  async authenticateChannel(channel) {
+    try {
+      const authData = await this.getChannelAuthData(channel);
+      
+      this.sendMessage({
+        event: 'pushler:auth',
+        data: authData
+      });
+      
+      // Устанавливаем таймаут аутентификации
+      this.authTimeout = setTimeout(() => {
+        this.emit(Events.ERROR, {
+          code: ErrorCodes.AUTHENTICATION_TIMEOUT,
+          message: 'Authentication timeout'
+        });
+      }, 10000);
+      
+    } catch (error) {
+      this.emit(Events.ERROR, {
+        code: ErrorCodes.AUTHENTICATION_FAILED,
+        message: error.message
+      });
+    }
+  }
+
+  /**
+   * Получение подписи с бэкенда
+   */
+  async getChannelSignature(channelName, socketId, userData = null) {
+    // Формируем URL: если authEndpoint абсолютный — используем его, иначе добавляем к apiUrl
+    const authUrl = this.authEndpoint.startsWith('http') 
+      ? this.authEndpoint 
+      : `${this.apiUrl}${this.authEndpoint}`;
+    
+    const response = await fetch(authUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        channel_name: channelName,
+        socket_id: socketId,
+        app_key: this.appKey,
+        user_data: userData
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || 'Failed to get channel signature');
+    }
+
+    const data = await response.json();
+    return data.signature;
+  }
+
+  /**
+   * Получение данных для аутентификации канала
+   */
+  async getChannelAuthData(channel) {
+    if (!this.socketId) {
+      throw new Error('Socket ID not available. Connection not established.');
+    }
+    
+    const channelType = this.getChannelType(channel.name);
+    
+    const authData = {
+      app_key: this.appKey,
+      channel: channel.name,
+      socket_id: this.socketId
+    };
+
+    // Для приватных и presence каналов нужна подпись
+    if (channelType === ChannelTypes.PRIVATE || channelType === ChannelTypes.PRESENCE) {
+      // Если подпись уже предоставлена, используем её
+      if (channel.options.signature) {
+        authData.signature = channel.options.signature;
+        console.log('Using provided signature:', {
+          channel: channel.name,
+          socketId: this.socketId,
+          signatureLength: channel.options.signature.length,
+          signature: channel.options.signature.substring(0, 20) + '...'
+        });
+      } else {
+        // Иначе получаем подпись с бэкенда
+        try {
+          authData.signature = await this.getChannelSignature(
+            channel.name, 
+            this.socketId, 
+            channel.options.user
+          );
+        } catch (error) {
+          throw new Error(`Failed to get channel signature: ${error.message}`);
+        }
+      }
+    }
+
+    // Для presence каналов нужны данные пользователя
+    if (channelType === ChannelTypes.PRESENCE) {
+      if (!channel.options.user) {
+        throw new Error('User data is required for presence channels');
+      }
+      
+      authData.user = channel.options.user;
+    }
+
+    return authData;
+  }
+
+  /**
+   * Определение типа канала
+   * Формат канала: {appKey}:{type-}channelName
+   */
+  getChannelType(channelName) {
+    // Извлекаем имя канала без appKey
+    const baseName = this.extractChannelName(channelName);
+    
+    if (baseName.startsWith('private-')) {
+      return ChannelTypes.PRIVATE;
+    }
+    if (baseName.startsWith('presence-')) {
+      return ChannelTypes.PRESENCE;
+    }
+    return ChannelTypes.PUBLIC;
+  }
+
+  /**
+   * Отправка сообщения через WebSocket
+   */
+  sendMessage(message) {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+
+  /**
+   * Генерация уникального ID сокета
+   */
+  generateSocketId() {
+    return Math.random().toString(36).substr(2, 9) + '.' + Math.floor(Math.random() * 1000000);
+  }
+
+  /**
+   * Планирование переподключения
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+
+    this.reconnectAttempts++;
+    this.connectionState = ConnectionStates.RECONNECTING;
+    this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, this.reconnectDelay * this.reconnectAttempts);
+  }
+
+  /**
+   * Обработка ошибки подключения
+   */
+  handleConnectionError(error) {
+    this.connectionState = ConnectionStates.FAILED;
+    this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+    
+    // Формируем более информативное сообщение об ошибке
+    let errorMessage = 'Connection failed';
+    if (error && error.message) {
+      errorMessage = error.message;
+    } else if (error && typeof error === 'object') {
+      errorMessage = JSON.stringify(error);
+    } else if (typeof error === 'string') {
+      errorMessage = error;
+    }
+    
+    // Добавляем информацию о URL для отладки
+    const fullErrorMessage = `WebSocket connection to '${this.wsUrl}' failed: ${errorMessage}`;
+    
+    console.error('PushlerClient connection error:', fullErrorMessage);
+    
+    this.emit(Events.ERROR, {
+      code: ErrorCodes.CONNECTION_FAILED,
+      message: fullErrorMessage,
+      url: this.wsUrl,
+      originalError: error
+    });
+  }
+
+  /**
+   * Отключение от WebSocket сервера
+   */
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    
+    if (this.authTimeout) {
+      clearTimeout(this.authTimeout);
+      this.authTimeout = null;
+    }
+
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+
+    // Очищаем каналы и алиасы
+    this.channels.clear();
+    this.channelAliases.clear();
+
+    this.connectionState = ConnectionStates.DISCONNECTED;
+    this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
+  }
+
+  /**
+   * Подписка на событие
+   */
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, []);
+    }
+    this.eventListeners.get(event).push(callback);
+  }
+
+  /**
+   * Отписка от события
+   */
+  off(event, callback) {
+    if (this.eventListeners.has(event)) {
+      const listeners = this.eventListeners.get(event);
+      const index = listeners.indexOf(callback);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Вызов события
+   */
+  emit(event, data) {
+    if (this.eventListeners.has(event)) {
+      this.eventListeners.get(event).forEach(callback => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error('Error in event listener:', error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Получение состояния подключения
+   */
+  getConnectionState() {
+    return this.connectionState;
+  }
+
+  /**
+   * Получение всех каналов (возвращает оригинальные имена без appKey)
+   */
+  getChannels() {
+    return Array.from(this.channels.values()).map(channel => 
+      channel.originalName || this.extractChannelName(channel.name)
+    );
+  }
+
+  /**
+   * Получение канала по имени
+   * @param {string} channelName - Имя канала (можно использовать оригинальное или полное)
+   * @returns {Channel|undefined} Объект канала
+   */
+  channel(channelName) {
+    const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+    return this.channels.get(fullChannelName);
+  }
+}
+
+export default PushlerClient;