@pushler/js 1.0.3 → 1.2.0

package/dist/pushler-ru.cjs

@@ -24,6 +24,18 @@ const ConnectionStates = {
   FAILED: 'failed'
 };
 
+/**
+ * Состояния подписки на канал
+ */
+const SubscriptionStates = {
+  PENDING: 'pending',
+  PENDING_AUTH: 'pending_auth',
+  SUBSCRIBING: 'subscribing',
+  SUBSCRIBED: 'subscribed',
+  FAILED: 'failed',
+  UNSUBSCRIBED: 'unsubscribed'
+};
+
 /**
  * События WebSocket
  */
@@ -65,6 +77,7 @@ class Channel {
     this.name = name;
     this.options = options;
     this.subscribed = false;
+    this.subscriptionState = SubscriptionStates.PENDING;
     this.eventListeners = new Map();
     this.presenceData = null;
   }
@@ -112,6 +125,7 @@ class Channel {
    */
   handleAuthSuccess(data) {
     this.subscribed = true;
+    this.subscriptionState = SubscriptionStates.SUBSCRIBED;
     this.emit(Events.CHANNEL_SUBSCRIBED, data);
     
     // Для presence каналов сохраняем данные пользователя
@@ -139,6 +153,7 @@ class Channel {
     }
     
     this.subscribed = false;
+    this.subscriptionState = SubscriptionStates.UNSUBSCRIBED;
     this.emit(Events.CHANNEL_UNSUBSCRIBED);
   }
 
@@ -149,6 +164,14 @@ class Channel {
     return this.subscribed;
   }
 
+  /**
+   * Получение состояния подписки
+   * @returns {string} Состояние подписки
+   */
+  getSubscriptionState() {
+    return this.subscriptionState;
+  }
+
   /**
    * Получение данных присутствия (для presence каналов)
    */
@@ -207,6 +230,8 @@ class PushlerClient {
     this.wsUrl = options.wsUrl || `wss://ws.pushler.ru/app/${this.appKey}`;
     this.apiUrl = options.apiUrl;
     this.authEndpoint = options.authEndpoint || '/pushler/auth'; // Путь для авторизации каналов
+    this.authHeaders = options.authHeaders || null; // Кастомные заголовки для авторизации
+    this.getAuthHeaders = options.getAuthHeaders || null; // Функция для динамических заголовков
     this.autoConnect = options.autoConnect !== false;
     this.reconnectDelay = options.reconnectDelay || 1000;
     this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
@@ -217,10 +242,16 @@ class PushlerClient {
     this.channels = new Map(); // Хранит каналы по полному имени (с appKey)
     this.channelAliases = new Map(); // Маппинг оригинальное имя -> полное имя
     this.eventListeners = new Map();
+    this.pendingAuthRequests = new Map(); // Отслеживание pending auth запросов для отмены при unsubscribe
     this.reconnectAttempts = 0;
     this.reconnectTimer = null;
     this.authTimeout = null;
     
+    // Promise для ожидания подключения
+    this.connectionPromise = null;
+    this.connectionResolve = null;
+    this.connectionReject = null;
+    
     // Автоматическое подключение
     if (this.autoConnect) {
       this.connect();
@@ -256,13 +287,25 @@ class PushlerClient {
 
   /**
    * Подключение к WebSocket серверу
+   * @returns {Promise} Promise, который резолвится при успешном подключении
    */
   connect() {
-    if (this.connectionState === ConnectionStates.CONNECTED || 
-        this.connectionState === ConnectionStates.CONNECTING) {
-      return;
+    // Если уже подключены - возвращаем резолвленный Promise
+    if (this.connectionState === ConnectionStates.CONNECTED) {
+      return Promise.resolve({ socketId: this.socketId });
+    }
+    
+    // Если уже идёт подключение - возвращаем существующий Promise
+    if (this.connectionState === ConnectionStates.CONNECTING && this.connectionPromise) {
+      return this.connectionPromise;
     }
 
+    // Создаём новый Promise для ожидания подключения
+    this.connectionPromise = new Promise((resolve, reject) => {
+      this.connectionResolve = resolve;
+      this.connectionReject = reject;
+    });
+
     this.connectionState = ConnectionStates.CONNECTING;
     this.emit(Events.CONNECTION_STATE_CHANGED, this.connectionState);
 
@@ -277,7 +320,66 @@ class PushlerClient {
     } catch (error) {
       console.error('PushlerClient: Error creating WebSocket connection:', error);
       this.handleConnectionError(error);
+      if (this.connectionReject) {
+        this.connectionReject(error);
+        this.connectionPromise = null;
+        this.connectionResolve = null;
+        this.connectionReject = null;
+      }
     }
+    
+    return this.connectionPromise;
+  }
+
+  /**
+   * Ожидание установления соединения
+   * @param {number} timeout - Таймаут в мс (по умолчанию 10000)
+   * @returns {Promise} Promise с socketId
+   */
+  waitForConnection(timeout = 10000) {
+    // Если уже подключены
+    if (this.connectionState === ConnectionStates.CONNECTED && this.socketId) {
+      return Promise.resolve({ socketId: this.socketId });
+    }
+    
+    // Если есть активный Promise подключения
+    if (this.connectionPromise) {
+      return Promise.race([
+        this.connectionPromise,
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Connection timeout')), timeout)
+        )
+      ]);
+    }
+    
+    // Если не подключаемся - начинаем подключение
+    if (this.connectionState === ConnectionStates.DISCONNECTED) {
+      return this.connect();
+    }
+    
+    // Для других состояний создаём Promise, который ждёт connected события
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.off(Events.CONNECTED, onConnected);
+        this.off(Events.ERROR, onError);
+        reject(new Error('Connection timeout'));
+      }, timeout);
+      
+      const onConnected = (data) => {
+        clearTimeout(timeoutId);
+        this.off(Events.ERROR, onError);
+        resolve(data);
+      };
+      
+      const onError = (err) => {
+        clearTimeout(timeoutId);
+        this.off(Events.CONNECTED, onConnected);
+        reject(err);
+      };
+      
+      this.on(Events.CONNECTED, onConnected);
+      this.on(Events.ERROR, onError);
+    });
   }
 
   /**
@@ -329,31 +431,98 @@ class PushlerClient {
     };
   }
 
+  /**
+   * Разбор склеенных JSON из одного WebSocket фрейма
+   * Сервер иногда отправляет несколько JSON объектов подряд в одном фрейме:
+   * {"event":"a",...}{"event":"b",...}
+   * @param {string} str - Строка с одним или несколькими JSON объектами
+   * @returns {string[]} Массив отдельных JSON строк
+   */
+  splitConcatenatedJSON(str) {
+    const results = [];
+    let depth = 0;
+    let start = 0;
+    let inString = false;
+    let escape = false;
+    
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+      
+      // Обработка escape-символов внутри строк
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      
+      if (char === '\\' && inString) {
+        escape = true;
+        continue;
+      }
+      
+      // Отслеживание строковых литералов
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+      
+      // Считаем скобки только вне строк
+      if (!inString) {
+        if (char === '{') {
+          depth++;
+        } else if (char === '}') {
+          depth--;
+          if (depth === 0) {
+            results.push(str.slice(start, i + 1));
+            start = i + 1;
+          }
+        }
+      }
+    }
+    
+    return results;
+  }
+
   /**
    * Обработка входящих сообщений
    */
   handleMessage(event) {
     try {
-      const message = JSON.parse(event.data);
+      // Пытаемся распарсить как один JSON
+      const messages = this.splitConcatenatedJSON(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);
+      // Если несколько JSON объектов, обрабатываем каждый
+      for (const jsonStr of messages) {
+        try {
+          const message = JSON.parse(jsonStr);
+          this.processMessage(message);
+        } catch (parseError) {
+          console.error('Error parsing JSON message:', parseError, 'Raw:', jsonStr);
+        }
       }
     } catch (error) {
-      console.error('Error parsing WebSocket message:', error);
+      console.error('Error handling WebSocket message:', error);
+    }
+  }
+
+  /**
+   * Обработка распарсенного сообщения
+   */
+  processMessage(message) {
+    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);
     }
   }
 
@@ -367,6 +536,14 @@ class PushlerClient {
     
     console.log('Connection established with socket ID:', this.socketId);
     
+    // Резолвим Promise подключения
+    if (this.connectionResolve) {
+      this.connectionResolve({ socketId: this.socketId });
+      this.connectionPromise = null;
+      this.connectionResolve = null;
+      this.connectionReject = null;
+    }
+    
     // Переподписываемся на все каналы после переподключения
     this.resubscribeAllChannels();
     
@@ -406,7 +583,13 @@ class PushlerClient {
     const { channel } = message.data;
     const channelInstance = this.channels.get(channel);
     
+    // Очищаем pending auth запрос
+    this.cancelPendingAuth(channel);
+    
     if (channelInstance) {
+      // Устанавливаем состояние subscribed
+      channelInstance.subscriptionState = SubscriptionStates.SUBSCRIBED;
+      
       // На сервере уже происходит подписка после успешной авторизации,
       // поэтому просто помечаем канал как подписанный
       channelInstance.handleAuthSuccess(message.data);
@@ -419,11 +602,31 @@ class PushlerClient {
    * Обработка ошибки аутентификации
    */
   handleAuthError(message) {
-    const { error } = message.data;
-    this.emit(Events.CHANNEL_AUTH_ERROR, error);
+    const { error, channel } = message.data;
+    const channelName = channel || null;
+    
+    // Очищаем pending auth запрос
+    if (channelName) {
+      this.cancelPendingAuth(channelName);
+      
+      const channelInstance = this.channels.get(channelName);
+      if (channelInstance) {
+        channelInstance.subscriptionState = SubscriptionStates.FAILED;
+      }
+    }
+    
+    const originalChannelName = channelName ? this.extractChannelName(channelName) : null;
+    
+    this.emit(Events.CHANNEL_AUTH_ERROR, {
+      error,
+      channel: originalChannelName,
+      socketId: this.socketId
+    });
     this.emit(Events.ERROR, {
       code: ErrorCodes.AUTHENTICATION_FAILED,
-      message: error
+      message: error,
+      channel: originalChannelName,
+      socketId: this.socketId
     });
   }
 
@@ -481,8 +684,12 @@ class PushlerClient {
     // Поддерживаем оба формата имени
     const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
     
+    // Отменяем pending auth запросы для этого канала (исправление race condition)
+    this.cancelPendingAuth(fullChannelName);
+    
     const channel = this.channels.get(fullChannelName);
     if (channel) {
+      channel.subscriptionState = SubscriptionStates.UNSUBSCRIBED;
       channel.unsubscribe();
       this.channels.delete(fullChannelName);
       this.channelAliases.delete(channel.originalName || channelName);
@@ -517,32 +724,141 @@ class PushlerClient {
 
   /**
    * Аутентификация канала
+   * С поддержкой отмены при unsubscribe
    */
   async authenticateChannel(channel) {
+    // Создаём AbortController для возможности отмены
+    const abortController = new AbortController();
+    const channelName = channel.name;
+    
+    // Сохраняем для возможности отмены при unsubscribe
+    this.pendingAuthRequests.set(channelName, {
+      controller: abortController,
+      timeoutId: null
+    });
+    
+    // Устанавливаем состояние канала
+    channel.subscriptionState = SubscriptionStates.PENDING_AUTH;
+    
     try {
+      // Проверка отмены перед началом
+      if (abortController.signal.aborted) {
+        return;
+      }
+      
       const authData = await this.getChannelAuthData(channel);
       
+      // Проверка отмены после получения данных
+      if (abortController.signal.aborted) {
+        return;
+      }
+      
       this.sendMessage({
         event: 'pushler:auth',
         data: authData
       });
       
       // Устанавливаем таймаут аутентификации
-      this.authTimeout = setTimeout(() => {
+      const timeoutId = setTimeout(() => {
+        // Не отправляем ошибку, если запрос уже отменён
+        if (abortController.signal.aborted) {
+          return;
+        }
+        
+        // Очищаем pending запрос
+        this.pendingAuthRequests.delete(channelName);
+        
+        // Устанавливаем состояние failed
+        channel.subscriptionState = SubscriptionStates.FAILED;
+        
         this.emit(Events.ERROR, {
           code: ErrorCodes.AUTHENTICATION_TIMEOUT,
-          message: 'Authentication timeout'
+          message: 'Authentication timeout',
+          channel: channel.originalName || this.extractChannelName(channelName),
+          socketId: this.socketId
         });
       }, 10000);
       
+      // Сохраняем timeoutId для возможности очистки
+      const pending = this.pendingAuthRequests.get(channelName);
+      if (pending) {
+        pending.timeoutId = timeoutId;
+      }
+      
     } catch (error) {
+      // Не отправляем ошибку, если запрос уже отменён
+      if (abortController.signal.aborted) {
+        return;
+      }
+      
+      // Очищаем pending запрос
+      this.pendingAuthRequests.delete(channelName);
+      
+      // Устанавливаем состояние failed
+      channel.subscriptionState = SubscriptionStates.FAILED;
+      
       this.emit(Events.ERROR, {
         code: ErrorCodes.AUTHENTICATION_FAILED,
-        message: error.message
+        message: error.message,
+        channel: channel.originalName || this.extractChannelName(channelName),
+        socketId: this.socketId
       });
     }
   }
 
+  /**
+   * Отмена pending auth запроса для канала
+   */
+  cancelPendingAuth(channelName) {
+    const pending = this.pendingAuthRequests.get(channelName);
+    if (pending) {
+      // Отменяем запрос
+      pending.controller.abort();
+      
+      // Очищаем таймаут
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      
+      // Удаляем из карты
+      this.pendingAuthRequests.delete(channelName);
+    }
+  }
+
+  /**
+   * Получение заголовков для авторизации
+   * Поддерживает как синхронные, так и асинхронные функции getAuthHeaders
+   * @returns {Promise<Object>} Заголовки для авторизации
+   */
+  async getAuthRequestHeaders() {
+    const headers = { 'Content-Type': 'application/json' };
+    
+    // Динамические заголовки имеют приоритет
+    if (typeof this.getAuthHeaders === 'function') {
+      // Поддержка асинхронных функций (AsyncStorage, SecureStore, Keychain)
+      const dynamicHeaders = await Promise.resolve(this.getAuthHeaders());
+      Object.assign(headers, dynamicHeaders);
+    } else if (this.authHeaders) {
+      // Статические заголовки
+      Object.assign(headers, this.authHeaders);
+    }
+    
+    return headers;
+  }
+
+  /**
+   * Установка токена авторизации
+   * Удобный метод для установки Bearer токена без создания функции
+   * @param {string} token - JWT токен
+   */
+  setAuthToken(token) {
+    if (token) {
+      this.authHeaders = { 'Authorization': `Bearer ${token}` };
+    } else {
+      this.authHeaders = null;
+    }
+  }
+
   /**
    * Получение подписи с бэкенда
    */
@@ -552,11 +868,16 @@ class PushlerClient {
       ? this.authEndpoint 
       : `${this.apiUrl}${this.authEndpoint}`;
     
+    // Асинхронное получение заголовков (поддержка AsyncStorage/SecureStore)
+    const headers = await this.getAuthRequestHeaders();
+    const hasAuthHeaders = this.authHeaders || this.getAuthHeaders;
+    
     const response = await fetch(authUrl, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
+      headers,
+      // Если есть authHeaders, не используем credentials (JWT режим)
+      // Если нет — используем cookies
+      ...(hasAuthHeaders ? {} : { credentials: 'include' }),
       body: JSON.stringify({
         channel_name: channelName,
         socket_id: socketId,
@@ -566,7 +887,7 @@ class PushlerClient {
     });
 
     if (!response.ok) {
-      const error = await response.json();
+      const error = await response.json().catch(() => ({ error: 'Auth request failed' }));
       throw new Error(error.error || 'Failed to get channel signature');
     }
 
@@ -699,6 +1020,14 @@ class PushlerClient {
     
     console.error('PushlerClient connection error:', fullErrorMessage);
     
+    // Реджектим Promise подключения
+    if (this.connectionReject) {
+      this.connectionReject(new Error(fullErrorMessage));
+      this.connectionPromise = null;
+      this.connectionResolve = null;
+      this.connectionReject = null;
+    }
+    
     this.emit(Events.ERROR, {
       code: ErrorCodes.CONNECTION_FAILED,
       message: fullErrorMessage,
@@ -797,6 +1126,69 @@ class PushlerClient {
     const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
     return this.channels.get(fullChannelName);
   }
+
+  /**
+   * Проверка подписки на канал
+   * @param {string} channelName - Имя канала
+   * @returns {boolean} true если подписан
+   */
+  isSubscribed(channelName) {
+    const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+    const channel = this.channels.get(fullChannelName);
+    return channel ? channel.subscribed : false;
+  }
+
+  /**
+   * Получение состояния подписки на канал
+   * @param {string} channelName - Имя канала
+   * @returns {string|null} Состояние подписки или null если канал не найден
+   */
+  getSubscriptionState(channelName) {
+    const fullChannelName = this.channelAliases.get(channelName) || this.formatChannelName(channelName);
+    const channel = this.channels.get(fullChannelName);
+    
+    if (!channel) {
+      return null;
+    }
+    
+    return channel.subscriptionState || (channel.subscribed ? SubscriptionStates.SUBSCRIBED : SubscriptionStates.PENDING);
+  }
+
+  /**
+   * Получение списка подписанных каналов
+   * @returns {string[]} Массив имён подписанных каналов
+   */
+  getSubscribedChannels() {
+    const subscribedChannels = [];
+    
+    for (const [fullName, channel] of this.channels.entries()) {
+      if (channel.subscribed) {
+        subscribedChannels.push(channel.originalName || this.extractChannelName(fullName));
+      }
+    }
+    
+    return subscribedChannels;
+  }
+
+  /**
+   * Получение всех каналов с их состояниями
+   * @returns {Object[]} Массив объектов с информацией о каналах
+   */
+  getAllChannelsInfo() {
+    const channelsInfo = [];
+    
+    for (const [fullName, channel] of this.channels.entries()) {
+      channelsInfo.push({
+        name: channel.originalName || this.extractChannelName(fullName),
+        fullName: fullName,
+        subscribed: channel.subscribed,
+        state: channel.subscriptionState || (channel.subscribed ? SubscriptionStates.SUBSCRIBED : SubscriptionStates.PENDING),
+        type: channel.getType()
+      });
+    }
+    
+    return channelsInfo;
+  }
 }
 
 var PushlerClient$1 = PushlerClient;
@@ -806,11 +1198,12 @@ var PushlerClient$1 = PushlerClient;
  * Используется на сервере Node.js для отправки событий в каналы
  */
 class PushlerServer {
+  static API_URL = 'https://api.pushler.ru';
+
   /**
    * @param {Object} options - Параметры клиента
    * @param {string} options.appKey - Ключ приложения (key_xxx)
    * @param {string} options.appSecret - Секрет приложения (secret_xxx)
-   * @param {string} [options.apiUrl='http://localhost:8000/api'] - URL API сервера
    * @param {number} [options.timeout=10000] - Таймаут запроса в мс
    */
   constructor(options = {}) {
@@ -823,7 +1216,6 @@ class PushlerServer {
 
     this.appKey = options.appKey;
     this.appSecret = options.appSecret;
-    this.apiUrl = (options.apiUrl || 'http://localhost:8000/api').replace(/\/$/, '');
     this.timeout = options.timeout || 10000;
   }
 
@@ -1107,7 +1499,7 @@ class PushlerServer {
    * @returns {Promise<Object>} Результат запроса
    */
   async makeSignedRequest(method, endpoint, data = null) {
-    const url = this.apiUrl + endpoint;
+    const url = PushlerServer.API_URL + endpoint;
     const timestamp = Math.floor(Date.now() / 1000);
     const body = data ? JSON.stringify(data) : '';
     const signature = this.generateApiSignature(body, timestamp);
@@ -1155,7 +1547,7 @@ class PushlerServer {
    * @returns {Promise<Object>} Результат запроса
    */
   async makeHttpRequest(method, endpoint, data = null) {
-    const url = this.apiUrl + endpoint;
+    const url = PushlerServer.API_URL + endpoint;
     
     const headers = {
       'Content-Type': 'application/json',
@@ -1196,7 +1588,7 @@ class PushlerServer {
    * @returns {string}
    */
   getApiUrl() {
-    return this.apiUrl;
+    return PushlerServer.API_URL;
   }
 }
 
@@ -1231,15 +1623,21 @@ const Pushler = {
   Channel: Channel$1,
   ChannelTypes,
   ConnectionStates,
+  SubscriptionStates,
+  ErrorCodes,
+  Events,
   generateSocketId
 };
 
 exports.Channel = Channel$1;
 exports.ChannelTypes = ChannelTypes;
 exports.ConnectionStates = ConnectionStates;
+exports.ErrorCodes = ErrorCodes;
+exports.Events = Events;
 exports.Pushler = Pushler;
 exports.PushlerClient = PushlerClient$1;
 exports.PushlerServer = PushlerServer$1;
+exports.SubscriptionStates = SubscriptionStates;
 exports.default = Pushler;
 exports.generateSocketId = generateSocketId;
 //# sourceMappingURL=pushler-ru.cjs.map