@nexustechpro/baileys 1.1.4 → 1.1.7

package/lib/Socket/Client/websocket.js

@@ -2,57 +2,310 @@ 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 {
-  socket = null
+  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 === null || this.socket?.readyState === WebSocket.CLOSED
+    return !this.socket || this.socket.readyState === WebSocket.CLOSED
   }
 
   get isClosing() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSING
+    return !this.socket || this.socket.readyState === WebSocket.CLOSING
   }
 
   get isConnecting() {
     return this.socket?.readyState === WebSocket.CONNECTING
   }
 
-  connect() {
-    if (this.socket) return
+  // ==================== 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
+      })
 
-    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)
+      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))
+      // 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() {
-    if (!this.socket) return
-    const closePromise = new Promise(resolve => this.socket?.once('close', resolve))
-    this.socket.close()
-    await closePromise
+    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) {
-    this.socket?.send(str, cb)
-    return Boolean(this.socket)
+    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
   }
 
-  async restart() {
-    await this.close()
-    this.connect()
+  // ==================== 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
+  }
+}
+
+export default WebSocketClient