@nexustechpro/baileys 2.0.2 → 2.0.5

package/lib/Socket/Client/websocket.js

@@ -1,311 +1,46 @@
-import WebSocket from 'ws'
-import { DEFAULT_ORIGIN } from '../../Defaults/index.js'
-import { AbstractSocketClient } from './types.js'
-
-// ==================== CONSTANTS ====================
-const CONSTANTS = {
-  MIN_SEND_INTERVAL_MS: 50,
-  MAX_RECONNECT_ATTEMPTS: 5,
-  INITIAL_RECONNECT_DELAY: 1000,
-  MAX_RECONNECT_DELAY: 30000,
-  RECONNECT_BACKOFF_MULTIPLIER: 2
-}
-
-// ==================== WEBSOCKET CLIENT ====================
-export class WebSocketClient extends AbstractSocketClient {
-  constructor() {
-    super(...arguments)
-    
-    // Core socket
-    this.socket = null
-    
-    // Message queue
-    this._queue = []
-    this._isDispatching = false
-    this._lastDispatch = 0
-    this._minSendIntervalMs = CONSTANTS.MIN_SEND_INTERVAL_MS
-    
-    // Reconnection state
-    this._reconnectTimeout = null
-    this._reconnectAttempts = 0
-    this._maxReconnectAttempts = CONSTANTS.MAX_RECONNECT_ATTEMPTS
-    this._reconnectDelay = CONSTANTS.INITIAL_RECONNECT_DELAY
-    this._shouldReconnect = true
-    this._isManualClose = false
-    this._isReconnecting = false
-  }
-
-  // ==================== LOGGER ====================
-  get logger() {
-    return this.config?.logger || console
-  }
-
-  // ==================== CONNECTION STATE ====================
-  get isOpen() {
-    return this.socket?.readyState === WebSocket.OPEN
-  }
-
-  get isClosed() {
-    return !this.socket || this.socket.readyState === WebSocket.CLOSED
-  }
-
-  get isClosing() {
-    return !this.socket || this.socket.readyState === WebSocket.CLOSING
-  }
-
-  get isConnecting() {
-    return this.socket?.readyState === WebSocket.CONNECTING
-  }
-
-  // ==================== CONNECTION MANAGEMENT ====================
-  async connect() {
-    if (this.socket && !this.isClosed) {
-      this.logger.debug({ state: this.socket.readyState }, 'already connected or connecting')
-      return
-    }
-
-    try {
-      this.logger.debug('establishing websocket connection')
-      
-      this.socket = new WebSocket(this.url, {
-        origin: DEFAULT_ORIGIN,
-        headers: this.config.options?.headers,
-        handshakeTimeout: this.config.connectTimeoutMs,
-        timeout: this.config.connectTimeoutMs,
-        agent: this.config.agent
-      })
-
-      if (!this.socket) {
-        throw new Error('WebSocket creation failed')
-      }
-
-      this.socket.setMaxListeners(0)
-
-      // Forward all WebSocket events
-      const events = ['error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']
-      events.forEach(e => {
-        this.socket?.on(e, (...args) => this.emit(e, ...args))
-      })
-
-      // Handle close with auto-reconnect
-      this.socket.on('close', (...args) => {
-        this.emit('close', ...args)
-        if (this._shouldReconnect && !this._isManualClose) {
-          this._attemptReconnect()
-        }
-      })
-
-      // Handle successful connection
-      this.socket.on('open', () => {
-        this.logger.info('websocket connection established')
-        this._reconnectAttempts = 0
-        this._reconnectDelay = CONSTANTS.INITIAL_RECONNECT_DELAY
-        this._isReconnecting = false
-
-        // Process any queued messages
-        if (this._queue.length > 0) {
-          this.logger.debug({ queueLength: this._queue.length }, 'processing queued messages')
-          this._dispatch()
-        }
-      })
-
-    } catch (error) {
-      this.logger.error({ error: error.message }, 'websocket connection failed')
-      this.socket = null
-      throw error
-    }
-  }
-
-  async close() {
-    this.logger.debug('closing websocket connection (manual)')
-    
-    this._isManualClose = true
-    this._shouldReconnect = false
-    this._isReconnecting = false
-
-    if (this._reconnectTimeout) {
-      clearTimeout(this._reconnectTimeout)
-      this._reconnectTimeout = null
-    }
-
-    this.socket?.close?.()
-    this.socket = null
-    this._queue = []
-  }
-
-  async restart() {
-    this.logger.info('restarting websocket connection')
-    
-    this._isManualClose = true
-    this._isReconnecting = false
-
-    // Force close existing connection
-    if (this.socket) {
-      await new Promise(resolve => {
-        this.socket.once('close', resolve)
-        this.socket.terminate()
-      })
-      this.socket = null
-    }
-
-    // Clear queue and reset state
-    this._queue = []
-    this._reconnectDelay = CONSTANTS.INITIAL_RECONNECT_DELAY
-    this._isManualClose = false
-    this._shouldReconnect = true
-
-    // Reconnect
-    await this.connect()
-  }
-
-  // ==================== RECONNECTION LOGIC ====================
-  _attemptReconnect() {
-    if (this._isReconnecting) {
-      this.logger.trace('reconnection already in progress')
-      return
-    }
-
-    if (this._reconnectAttempts >= this._maxReconnectAttempts) {
-      this.logger.error(
-        { attempts: this._reconnectAttempts, max: this._maxReconnectAttempts },
-        'max reconnect attempts reached'
-      )
-      this.emit('reconnect-failed')
-      return
-    }
-
-    if (this._reconnectTimeout) {
-      clearTimeout(this._reconnectTimeout)
-    }
-
-    this._isReconnecting = true
-    this._reconnectAttempts++
-
-    this.logger.info(
-      {
-        attempt: this._reconnectAttempts,
-        maxAttempts: this._maxReconnectAttempts,
-        delay: this._reconnectDelay
-      },
-      'attempting websocket reconnection'
-    )
-
-    this._reconnectTimeout = setTimeout(async () => {
-      try {
-        await this.connect()
-      } catch (error) {
-        this.logger.warn({ error: error.message }, 'reconnection attempt failed')
-        this._isReconnecting = false
-
-        if (this._reconnectAttempts < this._maxReconnectAttempts) {
-          this._attemptReconnect()
-        } else {
-          this.emit('reconnect-failed')
-        }
-      }
-    }, this._reconnectDelay)
-
-    // Exponential backoff with cap
-    this._reconnectDelay = Math.min(
-      this._reconnectDelay * CONSTANTS.RECONNECT_BACKOFF_MULTIPLIER,
-      CONSTANTS.MAX_RECONNECT_DELAY
-    )
-  }
-
-  // ==================== MESSAGE SENDING ====================
-  send(str, cb) {
-    const doSend = () => {
-      // Handle closed/closing socket
-      if (this.isClosed || this.isClosing) {
-        this.logger.warn('socket closed, attempting reconnection')
-        
-        this._isManualClose = false
-        this._shouldReconnect = true
-        this._attemptReconnect()
-        this._queue.unshift(doSend) // Re-queue at front
-        
-        cb?.(new Error('Socket closed, reconnecting...'))
-        return false
-      }
-
-      // Check if socket is ready
-      if (!this.socket || !this.isOpen) {
-        cb?.(new Error('Socket not open'))
-        return false
-      }
-
-      // Send the message
-      try {
-        this.socket.send(str, cb)
-        return true
-      } catch (error) {
-        this.logger.error({ error: error.message }, 'failed to send message')
-        cb?.(error)
-        return false
-      }
-    }
-
-    this._queue.push(doSend)
-    this._dispatch()
-    return true
-  }
-
-  // ==================== MESSAGE QUEUE DISPATCH ====================
-  _dispatch() {
-    // Don't dispatch if already dispatching or socket not ready
-    if (this._isDispatching || (!this.isOpen && !this.isConnecting)) {
-      return
-    }
-
-    const now = Date.now()
-    const elapsed = now - this._lastDispatch
-
-    // Check if enough time has passed and queue has items
-    if (this._queue.length && elapsed >= this._minSendIntervalMs) {
-      this._isDispatching = true
-      
-      const sendFn = this._queue.shift()
-      sendFn?.()
-      
-      this._lastDispatch = Date.now()
-      this._isDispatching = false
-
-      // Schedule next dispatch if queue not empty
-      if (this._queue.length) {
-        const nextDelay = Math.max(0, this._minSendIntervalMs - (Date.now() - this._lastDispatch))
-        setTimeout(() => this._dispatch(), nextDelay)
-      }
-    } else if (this._queue.length) {
-      // Schedule dispatch after required interval
-      const delay = Math.max(0, this._minSendIntervalMs - elapsed)
-      setTimeout(() => this._dispatch(), delay)
-    }
-  }
-
-  // ==================== PUBLIC CONTROL METHODS ====================
-  disableAutoReconnect() {
-    this.logger.info('auto-reconnect disabled')
-    this._shouldReconnect = false
-  }
-
-  enableAutoReconnect() {
-    this.logger.info('auto-reconnect enabled')
-    this._shouldReconnect = true
-    this._isManualClose = false
-  }
-
-  // Getters for external monitoring
-  get reconnectAttempts() {
-    return this._reconnectAttempts
-  }
-
-  get queueLength() {
-    return this._queue.length
-  }
-
-  get isReconnecting() {
-    return this._isReconnecting
-  }
-}
-
+import WebSocket from 'ws'
+import { DEFAULT_ORIGIN } from '../../Defaults/index.js'
+import { AbstractSocketClient } from './types.js'
+
+export class WebSocketClient extends AbstractSocketClient {
+  constructor() {
+    super(...arguments)
+    this.socket = null
+  }
+
+  get isOpen() { return this.socket?.readyState === WebSocket.OPEN }
+  get isClosed() { return this.socket === null || this.socket?.readyState === WebSocket.CLOSED }
+  get isClosing() { return this.socket === null || this.socket?.readyState === WebSocket.CLOSING }
+  get isConnecting() { return this.socket?.readyState === WebSocket.CONNECTING }
+
+  connect() {
+    if (this.socket) return
+    this.socket = new WebSocket(this.url, {
+      origin: DEFAULT_ORIGIN,
+      headers: this.config.options?.headers,
+      handshakeTimeout: this.config.connectTimeoutMs,
+      timeout: this.config.connectTimeoutMs,
+      agent: this.config.agent
+    })
+    this.socket.setMaxListeners(0)
+    const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']
+    for (const event of events) { this.socket?.on(event, (...args) => this.emit(event, ...args)) }
+  }
+
+  async close() {
+    if (!this.socket) return
+    const closePromise = new Promise(resolve => {
+      this.socket?.once('close', resolve)
+    })
+    this.socket.close()
+    await closePromise
+    this.socket = null
+  }
+
+  send(str, cb) {
+    this.socket?.send(str, cb)
+    return Boolean(this.socket)
+  }
+}
+
 export default WebSocketClient