@pushler/js 1.0.0

package/src/PushlerServer.js

@@ -0,0 +1,403 @@
+import { createHmac } from 'crypto';
+
+/**
+ * Серверный SDK для отправки сообщений через Pushler.ru API
+ * Используется на сервере Node.js для отправки событий в каналы
+ */
+class PushlerServer {
+  /**
+   * @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=30000] - Таймаут запроса в мс
+   */
+  constructor(options = {}) {
+    if (!options.appKey) {
+      throw new Error('appKey is required');
+    }
+    if (!options.appSecret) {
+      throw new Error('appSecret is required');
+    }
+
+    this.appKey = options.appKey;
+    this.appSecret = options.appSecret;
+    this.apiUrl = (options.apiUrl || 'http://localhost:8000/api').replace(/\/$/, '');
+    this.timeout = options.timeout || 30000;
+  }
+
+  /**
+   * Формирование полного имени канала с префиксом 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;
+  }
+
+  /**
+   * Генерация подписи для API запроса
+   * 
+   * @param {string} body - JSON тело запроса
+   * @param {number} timestamp - Unix timestamp
+   * @returns {string} HMAC-SHA256 подпись
+   */
+  generateApiSignature(body, timestamp) {
+    const signatureString = body + timestamp;
+    return createHmac('sha256', this.appSecret)
+      .update(signatureString)
+      .digest('hex');
+  }
+
+  /**
+   * Генерация подписи для авторизации канала
+   * 
+   * @param {string} channelName - Название канала (полное с appKey)
+   * @param {string} socketId - ID сокета
+   * @returns {string} HMAC-SHA256 подпись
+   */
+  generateChannelSignature(channelName, socketId) {
+    // Подпись генерируется для полного имени канала
+    const fullChannelName = this.formatChannelName(channelName);
+    const signatureString = socketId + ':' + fullChannelName;
+    return createHmac('sha256', this.appSecret)
+      .update(signatureString)
+      .digest('hex');
+  }
+
+  /**
+   * Авторизация приватного канала
+   * 
+   * @param {string} channelName - Название канала (appKey будет добавлен автоматически)
+   * @param {string} socketId - ID сокета
+   * @returns {Object} Результат авторизации с полным именем канала
+   */
+  authorizeChannel(channelName, socketId) {
+    const fullChannelName = this.formatChannelName(channelName);
+    const signature = this.generateChannelSignature(fullChannelName, socketId);
+    return {
+      auth: this.appKey + ':' + signature,
+      channel: fullChannelName
+    };
+  }
+
+  /**
+   * Авторизация presence канала
+   * 
+   * @param {string} channelName - Название канала (appKey будет добавлен автоматически)
+   * @param {string} socketId - ID сокета
+   * @param {Object} userData - Данные пользователя
+   * @param {string|number} userData.user_id - ID пользователя (обязательно)
+   * @param {Object} [userData.user_info] - Дополнительная информация о пользователе
+   * @returns {Object} Результат авторизации с полным именем канала
+   */
+  authorizePresenceChannel(channelName, socketId, userData) {
+    if (!userData || !userData.user_id) {
+      throw new Error('user_id is required for presence channels');
+    }
+
+    const fullChannelName = this.formatChannelName(channelName);
+    const signature = this.generateChannelSignature(fullChannelName, socketId);
+    
+    return {
+      auth: this.appKey + ':' + signature,
+      channel: fullChannelName,
+      channel_data: JSON.stringify({
+        user_id: userData.user_id,
+        user_info: userData.user_info || {}
+      })
+    };
+  }
+
+  /**
+   * Аутентификация пользователя для WebSocket соединения
+   * 
+   * @param {string} socketId - ID сокета
+   * @param {Object} userData - Данные пользователя
+   * @returns {Object} Результат аутентификации
+   */
+  authenticateUser(socketId, userData) {
+    if (!userData || !userData.user_id) {
+      throw new Error('user_id is required for user authentication');
+    }
+
+    const signature = this.generateChannelSignature('user-' + userData.user_id, socketId);
+    
+    return {
+      auth: this.appKey + ':' + signature,
+      user_data: JSON.stringify(userData)
+    };
+  }
+
+  /**
+   * Отправка события в канал
+   * 
+   * @param {string|string[]} channels - Канал или массив каналов (appKey будет добавлен автоматически)
+   * @param {string} event - Название события
+   * @param {Object} data - Данные события
+   * @param {string} [socketId] - ID сокета (для исключения отправителя)
+   * @returns {Promise<Object>} Результат отправки
+   */
+  async trigger(channels, event, data, socketId = null) {
+    const channelList = Array.isArray(channels) ? channels : [channels];
+    
+    // Добавляем appKey ко всем каналам
+    const formattedChannels = channelList.map(ch => this.formatChannelName(ch));
+    
+    // Для одного канала используем /messages/send
+    if (formattedChannels.length === 1) {
+      const payload = {
+        channel: formattedChannels[0],
+        event,
+        data
+      };
+
+      if (socketId) {
+        payload.socket_id = socketId;
+      }
+
+      return this.makeSignedRequest('POST', '/messages/send', payload);
+    }
+    
+    // Для нескольких каналов используем /messages/broadcast
+    const payload = {
+      channels: formattedChannels,
+      event,
+      data
+    };
+
+    if (socketId) {
+      payload.socket_id = socketId;
+    }
+
+    return this.makeSignedRequest('POST', '/messages/broadcast', payload);
+  }
+
+  /**
+   * Отправка события в несколько каналов одновременно
+   * 
+   * @param {string[]} channels - Массив каналов
+   * @param {string} event - Название события
+   * @param {Object} data - Данные события
+   * @param {string} [socketId] - ID сокета (для исключения отправителя)
+   * @returns {Promise<Object>} Результат отправки
+   */
+  async triggerBatch(channels, event, data, socketId = null) {
+    return this.trigger(channels, event, data, socketId);
+  }
+
+  /**
+   * Получение статуса сообщения
+   * 
+   * @param {string|number} messageId - ID сообщения
+   * @returns {Promise<Object>} Статус сообщения
+   */
+  async getMessageStatus(messageId) {
+    return this.makeSignedRequest('GET', `/messages/${messageId}/status`);
+  }
+
+  /**
+   * Получение списка сообщений
+   * 
+   * @param {Object} [params] - Параметры запроса
+   * @param {string} [params.status] - Фильтр по статусу
+   * @param {number} [params.per_page] - Количество на страницу
+   * @returns {Promise<Object>} Список сообщений
+   */
+  async getMessages(params = {}) {
+    const query = new URLSearchParams(params).toString();
+    const endpoint = '/messages' + (query ? '?' + query : '');
+    return this.makeSignedRequest('GET', endpoint);
+  }
+
+  /**
+   * Проверка валидности приложения
+   * 
+   * @returns {Promise<Object>} Информация о приложении
+   */
+  async validateApplication() {
+    const response = await this.makeHttpRequest('GET', `/applications/validate/${this.appKey}`);
+    
+    if (!response.id) {
+      throw new Error(response.error || 'Application validation failed');
+    }
+
+    return response;
+  }
+
+  /**
+   * Получение информации о приложении
+   * 
+   * @returns {Promise<Object>} Информация о приложении
+   */
+  async getApplicationInfo() {
+    return this.validateApplication();
+  }
+
+  /**
+   * Валидация вебхука
+   * 
+   * @param {Object} headers - Заголовки запроса
+   * @param {string} body - Тело запроса
+   * @returns {Object} Данные вебхука
+   * @throws {Error} При невалидной подписи
+   */
+  verifyWebhook(headers, body) {
+    const signature = headers['X-Pushler-Signature'] || headers['x-pushler-signature'] || '';
+    
+    if (!signature) {
+      throw new Error('Missing X-Pushler-Signature header');
+    }
+
+    const expectedSignature = 'sha256=' + createHmac('sha256', this.appSecret)
+      .update(body)
+      .digest('hex');
+    
+    // Timing-safe сравнение
+    if (!this.timingSafeEqual(expectedSignature, signature)) {
+      throw new Error('Invalid webhook signature');
+    }
+
+    const data = JSON.parse(body);
+    return data;
+  }
+
+  /**
+   * Timing-safe сравнение строк
+   * @private
+   */
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
+  }
+
+  /**
+   * Выполнение подписанного HTTP запроса
+   * 
+   * @private
+   * @param {string} method - HTTP метод
+   * @param {string} endpoint - API endpoint
+   * @param {Object} [data] - Данные запроса
+   * @returns {Promise<Object>} Результат запроса
+   */
+  async makeSignedRequest(method, endpoint, data = null) {
+    const url = this.apiUrl + endpoint;
+    const timestamp = Math.floor(Date.now() / 1000);
+    const body = data ? JSON.stringify(data) : '';
+    const signature = this.generateApiSignature(body, timestamp);
+    
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'User-Agent': 'PushlerRu-JS-SDK/1.0.0',
+      'X-Pushler-Key': this.appKey,
+      'X-Pushler-Signature': signature,
+      'X-Pushler-Timestamp': String(timestamp)
+    };
+
+    const options = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout)
+    };
+
+    if (method === 'POST' && body) {
+      options.body = body;
+    }
+
+    const response = await fetch(url, options);
+    const result = await response.json();
+
+    if (!response.ok) {
+      const message = result.message || `HTTP request failed with status: ${response.status}`;
+      const error = new Error(message);
+      error.statusCode = response.status;
+      error.response = result;
+      throw error;
+    }
+
+    return result;
+  }
+
+  /**
+   * Выполнение обычного HTTP запроса (без подписи)
+   * 
+   * @private
+   * @param {string} method - HTTP метод
+   * @param {string} endpoint - API endpoint
+   * @param {Object} [data] - Данные запроса
+   * @returns {Promise<Object>} Результат запроса
+   */
+  async makeHttpRequest(method, endpoint, data = null) {
+    const url = this.apiUrl + endpoint;
+    
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'User-Agent': 'PushlerRu-JS-SDK/1.0.0'
+    };
+
+    const options = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout)
+    };
+
+    if (method === 'POST' && data) {
+      options.body = JSON.stringify(data);
+    }
+
+    const response = await fetch(url, options);
+    const result = await response.json();
+
+    if (!response.ok) {
+      throw new Error(`HTTP request failed with status: ${response.status}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Получение App Key
+   * @returns {string}
+   */
+  getAppKey() {
+    return this.appKey;
+  }
+
+  /**
+   * Получение API URL
+   * @returns {string}
+   */
+  getApiUrl() {
+    return this.apiUrl;
+  }
+}
+
+export default PushlerServer;
+

package/src/constants.js

@@ -0,0 +1,51 @@
+/**
+ * Типы каналов
+ */
+export const ChannelTypes = {
+  PUBLIC: 'public',
+  PRIVATE: 'private',
+  PRESENCE: 'presence'
+};
+
+/**
+ * Состояния подключения
+ */
+export const ConnectionStates = {
+  CONNECTING: 'connecting',
+  CONNECTED: 'connected',
+  DISCONNECTED: 'disconnected',
+  RECONNECTING: 'reconnecting',
+  FAILED: 'failed'
+};
+
+/**
+ * События WebSocket
+ */
+export const Events = {
+  // События подключения
+  CONNECTION_STATE_CHANGED: 'connection_state_changed',
+  CONNECTED: 'connected',
+  DISCONNECTED: 'disconnected',
+  ERROR: 'error',
+  
+  // События каналов
+  CHANNEL_SUBSCRIBED: 'channel_subscribed',
+  CHANNEL_UNSUBSCRIBED: 'channel_unsubscribed',
+  CHANNEL_AUTH_SUCCESS: 'pushler:auth_success',
+  CHANNEL_AUTH_ERROR: 'pushler:auth_error',
+  
+  // События сообщений
+  MESSAGE_RECEIVED: 'message_received'
+};
+
+/**
+ * Коды ошибок
+ */
+export const ErrorCodes = {
+  INVALID_APP_KEY: 'INVALID_APP_KEY',
+  INVALID_SIGNATURE: 'INVALID_SIGNATURE',
+  AUTHENTICATION_FAILED: 'AUTHENTICATION_FAILED',
+  CHANNEL_ACCESS_DENIED: 'CHANNEL_ACCESS_DENIED',
+  CONNECTION_FAILED: 'CONNECTION_FAILED',
+  AUTHENTICATION_TIMEOUT: 'AUTHENTICATION_TIMEOUT'
+};

package/src/index.js

@@ -0,0 +1,24 @@
+import PushlerClient from './PushlerClient';
+import PushlerServer from './PushlerServer';
+import Channel from './Channel';
+import { ChannelTypes, ConnectionStates } from './constants';
+import { generateSocketId } from './utils';
+
+// Создаем объект с методами для удобного API
+const Pushler = {
+  // Клиентский SDK для браузера (WebSocket)
+  CreateClient: (options) => new PushlerClient(options),
+  Create: (options) => new PushlerClient(options), // Алиас для краткости
+  
+  // Серверный SDK для Node.js (отправка сообщений через API)
+  CreateServer: (options) => new PushlerServer(options),
+  Server: (options) => new PushlerServer(options), // Алиас для краткости
+  
+  Channel,
+  ChannelTypes,
+  ConnectionStates,
+  generateSocketId
+};
+
+export { PushlerClient, PushlerServer, Channel, ChannelTypes, ConnectionStates, generateSocketId, Pushler };
+export default Pushler;

package/src/utils.js

@@ -0,0 +1,74 @@
+/**
+ * Валидация данных канала
+ * @param {string} channelName - Название канала
+ * @param {string} channelType - Тип канала
+ * @param {Object} options - Опции канала
+ * @returns {Object} - Результат валидации
+ */
+export function validateChannelOptions(channelName, channelType, options) {
+  const errors = [];
+
+  if (!channelName) {
+    errors.push('Channel name is required');
+  }
+
+  if (channelType === 'private' || channelType === 'presence') {
+    if (!options.signature && !options.autoAuth) {
+      errors.push('Signature or autoAuth is required for private/presence channels');
+    }
+  }
+
+  if (channelType === 'presence') {
+    if (!options.user) {
+      errors.push('User data is required for presence channels');
+    } else if (!options.user.id) {
+      errors.push('User ID is required for presence channels');
+    }
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Генерация уникального ID
+ * @returns {string} - Уникальный ID
+ */
+export function generateId() {
+  return Math.random().toString(36).substr(2, 9) + Date.now();
+}
+
+/**
+ * Генерация уникального ID сокета
+ * @returns {string} - Уникальный ID сокета
+ */
+export function generateSocketId() {
+  return Math.random().toString(36).substr(2, 9) + '.' + Math.floor(Math.random() * 1000000);
+}
+
+/**
+ * Проверка поддержки WebSocket в браузере
+ * @returns {boolean} - Поддерживается ли WebSocket
+ */
+export function isWebSocketSupported() {
+  return typeof WebSocket !== 'undefined';
+}
+
+/**
+ * Форматирование ошибки
+ * @param {Error|string} error - Ошибка
+ * @returns {Object} - Форматированная ошибка
+ */
+export function formatError(error) {
+  if (typeof error === 'string') {
+    return { message: error };
+  }
+  
+  if (error instanceof Error) {
+    return { message: error.message, stack: error.stack };
+  }
+  
+  return { message: 'Unknown error' };
+}