aqualink 2.2.0 → 2.3.0

package/build/structures/Node.js

@@ -8,11 +8,9 @@ class Node {
     static WS_OPEN = WebSocket.OPEN;
 
     constructor(aqua, connOptions, options = {}) {
-        const host = connOptions.host || "localhost";
-        
         this.aqua = aqua;
-        this.name = connOptions.name || host;
-        this.host = host;
+        this.host = connOptions.host || "localhost";
+        this.name = connOptions.name || this.host;
         this.port = connOptions.port || 2333;
         this.password = connOptions.password || "youshallnotpass";
         this.secure = !!connOptions.secure;
@@ -20,16 +18,23 @@ class Node {
         this.regions = connOptions.regions || [];
         
         this.wsUrl = `ws${this.secure ? "s" : ""}://${this.host}:${this.port}/v4/websocket`;
-        
         this.rest = new Rest(aqua, this);
         this.resumeTimeout = options.resumeTimeout || 60;
         this.autoResume = !!options.autoResume;
         this.reconnectTimeout = options.reconnectTimeout || 2000;
         this.reconnectTries = options.reconnectTries || 3;
         this.infiniteReconnects = !!options.infiniteReconnects;
+        
         this.connected = false;
         this.info = null;
+        this.ws = null;
+        this.reconnectAttempted = 0;
+        this.reconnectTimeoutId = null;
         
+        this.initializeStats();
+    }
+
+    initializeStats() {
         this.stats = {
             players: 0,
             playingPlayers: 0,
@@ -39,189 +44,211 @@ class Node {
             frameStats: { sent: 0, nulled: 0, deficit: 0 },
             ping: 0
         };
-        
-        let ws = null;
-        let reconnectAttempted = 0;
-        let reconnectTimeoutId = null;
-        
-        this._onOpen = () => {
-            this.connected = true;
-            reconnectAttempted = 0;
-            if (aqua.listenerCount('debug') > 0) {
-                aqua.emit("debug", this.name, `Connected to ${this.wsUrl}`);
-            }
+    }
 
-            this.rest.makeRequest("GET", "/v4/info")
-                .then(info => {
-                    this.info = info;
-                    if (this.autoResume && this.sessionId) {
-                        return this.resumePlayers();
-                    }
-                })
-                .catch(err => {
-                    this.info = null;
-                    if (!aqua.bypassChecks?.nodeFetchInfo && aqua.listenerCount('error') > 0) {
-                        aqua.emit("error", this, `Failed to fetch node info: ${err.message}`);
-                    }
-                });
+    _constructHeaders() {
+        const headers = {
+            Authorization: this.password,
+            "User-Id": this.aqua.clientId,
+            "Client-Name": `Aqua/${this.aqua.version}`
         };
         
-         this._onError = (error) => {
-            if (aqua.listenerCount('nodeError') > 0) {
-                aqua.emit("nodeError", this, error);
-            }
-        };
+        if (this.sessionId) {
+            headers["Session-Id"] = this.sessionId;
+        }
         
-        this._onMessage = (msg) => {
-            let payload;
-            try {
-                payload = JSON.parse(msg);
-            } catch {
-                return;
-            }
+        return headers;
+    }
 
-            const op = payload?.op;
-            if (!op) return;
+    _onOpen() {
+        this.connected = true;
+        this.reconnectAttempted = 0;
+        this.emitDebug(`Connected to ${this.wsUrl}`);
 
-            switch (op) {
-                case "stats":
-                    this._updateStats(payload);
-                    break;
-                case "ready":
-                    this._handleReadyOp(payload);
-                    break;
-                default:
-                    if (payload.guildId) {
-                        const player = aqua.players.get(payload.guildId);
-                        if (player) player.emit(op, payload);
-                    }
-            }
-        };
-        
-        this._onClose = (code, reason) => {
-            this.connected = false;
-            
-            if (aqua.listenerCount('nodeDisconnect') > 0) {
-                aqua.emit("nodeDisconnect", this, { 
-                    code, 
-                    reason: reason?.toString() || "No reason provided" 
-                });
-            }
-            
-            clearTimeout(reconnectTimeoutId);
-            
-            if (this.infiniteReconnects) {
-                if (aqua.listenerCount('nodeReconnect') > 0) {
-                    aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds");
+        this.rest.makeRequest("GET", "/v4/info")
+            .then(info => {
+                this.info = info;
+                if (this.autoResume && this.sessionId) {
+                    return this.resumePlayers();
                 }
-                reconnectTimeoutId = setTimeout(() => this.connect(), 10000);
-                return;
-            }
+            })
+            .catch(err => {
+                this.info = null;
+                if (!this.aqua.bypassChecks?.nodeFetchInfo) {
+                    this.emitError(`Failed to fetch node info: ${err.message}`);
+                }
+            });
+    }
+    
+    _onError(error) {
+        this.aqua.emit("nodeError", this, error);
+    }
+    
+    _onMessage(msg) {
+        let payload;
+        try {
+            payload = JSON.parse(msg);
+        } catch {
+            return;
+        }
 
-            if (reconnectAttempted >= this.reconnectTries) {
-                if (aqua.listenerCount('nodeError') > 0) {
-                    aqua.emit("nodeError", this, 
-                        new Error(`Max reconnection attempts reached (${this.reconnectTries})`));
+        const op = payload?.op;
+        if (!op) return;
+
+        switch (op) {
+            case "stats":
+                this._updateStats(payload);
+                break;
+            case "ready":
+                this._handleReadyOp(payload);
+                break;
+            default:
+                if (payload.guildId) {
+                    const player = this.aqua.players.get(payload.guildId);
+                    if (player) player.emit(op, payload);
                 }
-                this.destroy(true);
-                return;
-            }
+        }
+    }
+    
+    _onClose(code, reason) {
+        this.connected = false;
+        
+        this.aqua.emit("nodeDisconnect", this, { 
+            code, 
+            reason: reason?.toString() || "No reason provided" 
+        });
+        
+        this.scheduleReconnect(code);
+    }
+
+    scheduleReconnect(code) {
+        this.clearReconnectTimeout();
+        
+        if (code === 1000) {
+            return;
+        }
+        
+        if (this.infiniteReconnects) {
+            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds");
+            this.reconnectTimeoutId = setTimeout(() => this.connect(), 10000);
+            return;
+        }
 
-            const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, reconnectAttempted);
-            const jitter = Math.random() * Math.min(2000, baseBackoff * 0.2);
-            const backoffTime = Math.min(baseBackoff + jitter, Node.MAX_BACKOFF);
+        if (this.reconnectAttempted >= this.reconnectTries) {
+            this.emitError(new Error(`Max reconnection attempts reached (${this.reconnectTries})`));
+            this.destroy(true);
+            return;
+        }
 
-            reconnectAttempted++;
-            
-            if (aqua.listenerCount('nodeReconnect') > 0) {
-                aqua.emit("nodeReconnect", this, {
-                    attempt: reconnectAttempted,
-                    backoffTime
-                });
-            }
-            
-            reconnectTimeoutId = setTimeout(() => this.connect(), backoffTime);
-        };
+        const backoffTime = this.calculateBackoff();
+        this.reconnectAttempted++;
         
-        this.connect = async () => {
-            ws = new WebSocket(this.wsUrl, {
-                headers: this._constructHeaders(),
-                perMessageDeflate: false,
-            });
-            
-            ws.once("open", this._onOpen);
-            ws.once("error", this._onError);
-            ws.on("message", this._onMessage);
-            ws.once("close", this._onClose);
-        };
+        this.aqua.emit("nodeReconnect", this, {
+            attempt: this.reconnectAttempted,
+            backoffTime
+        });
         
-        this.destroy = (clean = false) => {
-            clearTimeout(reconnectTimeoutId);
+        this.reconnectTimeoutId = setTimeout(() => this.connect(), backoffTime);
+    }
 
-            if (ws) {
-                ws.removeAllListeners();
-                if (ws.readyState === Node.WS_OPEN) {
-                    ws.close();
-                }
-                ws = null;
-            }
+    calculateBackoff() {
+        const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.reconnectAttempted);
+        const jitter = Math.random() * Math.min(2000, baseBackoff * 0.2);
+        return Math.min(baseBackoff + jitter, Node.MAX_BACKOFF);
+    }
 
-            if (clean) {
-                if (aqua.listenerCount('nodeDestroy') > 0) {
-                    aqua.emit("nodeDestroy", this);
-                }
-                aqua.nodes.delete(this.name);
-                return;
-            }
+    clearReconnectTimeout() {
+        if (this.reconnectTimeoutId) {
+            clearTimeout(this.reconnectTimeoutId);
+            this.reconnectTimeoutId = null;
+        }
+    }
 
-            if (this.connected) {
-                for (const player of aqua.players.values()) {
-                    if (player.node === this) {
-                        player.destroy();
-                    }
-                }
-            }
+    async connect() {
+        this.cleanupExistingConnection();
+        
+        this.ws = new WebSocket(this.wsUrl, {
+            headers: this._constructHeaders(),
+            perMessageDeflate: false,
+        });
+        
+        this.ws.once("open", this._onOpen.bind(this));
+        this.ws.once("error", this._onError.bind(this));
+        this.ws.on("message", this._onMessage.bind(this));
+        this.ws.once("close", this._onClose.bind(this));
+    }
 
-            this.connected = false;
-            aqua.nodes.delete(this.name);
+    cleanupExistingConnection() {
+        if (this.ws) {
+            this.ws.removeAllListeners();
             
-            if (aqua.listenerCount('nodeDestroy') > 0) {
-                aqua.emit("nodeDestroy", this);
+            if (this.ws.readyState === Node.WS_OPEN) {
+                try {
+                    this.ws.close();
+                } catch (err) {
+                    this.emitDebug(`Error closing WebSocket: ${err.message}`);
+                }
             }
             
-            this.info = null;
-        };
+            this.ws = null;
+        }
     }
+    
+    destroy(clean = false) {
+        this.clearReconnectTimeout();
+        this.cleanupExistingConnection();
 
-    _constructHeaders() {
-        const headers = {
-            Authorization: this.password,
-            "User-Id": this.aqua.clientId,
-            "Client-Name": `Aqua/${this.aqua.version}`
-        };
-        
-        if (this.sessionId) {
-            headers["Session-Id"] = this.sessionId;
+        if (clean) {
+            this.aqua.emit("nodeDestroy", this);
+            this.aqua.nodes.delete(this.name);
+            return;
         }
-        
-        return headers;
+
+        if (this.connected) {
+            for (const player of this.aqua.players.values()) {
+                if (player.nodes === this) {
+                    player.destroy();
+                }
+            }
+        }
+
+        this.connected = false;
+        this.aqua.nodes.delete(this.name);
+        this.aqua.emit("nodeDestroy", this);
+        this.info = null;
     }
 
     async getStats() {
-        const newStats = await this.rest.getStats();
-        Object.assign(this.stats, newStats);
-        return this.stats;
+        try {
+            const newStats = await this.rest.getStats();
+            Object.assign(this.stats, newStats);
+            return this.stats;
+        } catch (err) {
+            this.emitError(`Failed to fetch node stats: ${err.message}`);
+            return this.stats;
+        }
     }
 
     _updateStats(payload) {
         if (!payload) return;
 
+        this._updateBasicStats(payload);
+        
+        this._updateMemoryStats(payload.memory);
+        
+        this._updateCpuStats(payload.cpu);
+        
+        this._updateFrameStats(payload.frameStats);
+    }
+    
+    _updateBasicStats(payload) {
         this.stats.players = payload.players || this.stats.players;
         this.stats.playingPlayers = payload.playingPlayers || this.stats.playingPlayers;
         this.stats.uptime = payload.uptime || this.stats.uptime;
         this.stats.ping = payload.ping || this.stats.ping;
-
-        const memory = payload.memory || {};
+    }
+    
+    _updateMemoryStats(memory = {}) {
         const allocated = memory.allocated || this.stats.memory.allocated;
         const free = memory.free || this.stats.memory.free;
         const used = memory.used || this.stats.memory.used;
@@ -235,8 +262,9 @@ class Node {
             this.stats.memory.freePercentage = (free / allocated) * 100;
             this.stats.memory.usedPercentage = (used / allocated) * 100;
         }
-
-        const cpu = payload.cpu || {};
+    }
+    
+    _updateCpuStats(cpu = {}) {
         const cores = cpu.cores || this.stats.cpu.cores;
         
         this.stats.cpu.cores = cores;
@@ -246,9 +274,10 @@ class Node {
         if (cores) {
             this.stats.cpu.lavalinkLoadPercentage = (cpu.lavalinkLoad / cores) * 100;
         }
-
-        const frameStats = payload.frameStats || {};
-        
+    }
+    
+    _updateFrameStats(frameStats = {}) {
+        if (!frameStats) return;
         this.stats.frameStats.sent = frameStats.sent || this.stats.frameStats.sent;
         this.stats.frameStats.nulled = frameStats.nulled || this.stats.frameStats.nulled;
         this.stats.frameStats.deficit = frameStats.deficit || this.stats.frameStats.deficit;
@@ -256,18 +285,13 @@ class Node {
 
     _handleReadyOp(payload) {
         if (!payload.sessionId) {
-            if (this.aqua.listenerCount('error') > 0) {
-                this.aqua.emit("error", this, "Ready payload missing sessionId");
-            }
+            this.emitError("Ready payload missing sessionId");
             return;
         }
 
         this.sessionId = payload.sessionId;
         this.rest.setSessionId(payload.sessionId);
-
-        if (this.aqua.listenerCount('nodeConnect') > 0) {
-            this.aqua.emit("nodeConnect", this);
-        }
+        this.aqua.emit("nodeConnect", this);
     }
 
     async resumePlayers() {
@@ -277,13 +301,25 @@ class Node {
                 timeout: this.resumeTimeout
             });
             
-            if (this.aqua.listenerCount('debug') > 0) {
-                this.aqua.emit("debug", this.name, `Successfully resumed session ${this.sessionId}`);
-            }
+            this.emitDebug(`Successfully resumed session ${this.sessionId}`);
         } catch (err) {
-            if (this.aqua.listenerCount('error') > 0) {
-                this.aqua.emit("error", this, `Failed to resume session: ${err.message}`);
-            }
+            this.emitError(`Failed to resume session: ${err.message}`);
+        }
+    }
+    
+    emitDebug(message) {
+        if (this.aqua.listenerCount('debug') > 0) {
+            this.aqua.emit("debug", this.name, message);
+        }
+    }
+    
+    emitError(error) {
+        const errorObj = error instanceof Error ? error : new Error(error);
+        
+        console.error(`[Aqua] [${this.name}] Error:`, errorObj);
+        
+        if (this.aqua.listenerCount('error') > 0) {
+            this.aqua.emit("error", this, errorObj);
         }
     }
 }

package/build/structures/Player.js

@@ -40,8 +40,10 @@ class Player extends EventEmitter {
         this.loop = Player.validModes.has(options.loop) ? options.loop : Player.LOOP_MODES.NONE;
         
         this.queue = new Queue();
-        this.previousTracks = Array(50);
+        this.previousTracks = new Array(50);
+        this.previousTracksIndex = 0;
         this.previousTracksCount = 0;
+        
         this.shouldDeleteMessage = Boolean(options.shouldDeleteMessage);
         this.leaveOnEnd = Boolean(options.leaveOnEnd);
 
@@ -56,15 +58,19 @@ class Player extends EventEmitter {
         this.isAutoplayEnabled = false;
         this.isAutoplay = false;
         
-        this._handlePlayerUpdate = this._handlePlayerUpdate.bind(this);
-        this._handleEvent = this._handleEvent.bind(this);
+        this._boundHandlers = {
+            playerUpdate: this._handlePlayerUpdate.bind(this),
+            event: this._handleEvent.bind(this)
+        };
+        
+        this.on("playerUpdate", this._boundHandlers.playerUpdate);
+        this.on("event", this._boundHandlers.event);
         
-        this.on("playerUpdate", this._handlePlayerUpdate);
-        this.on("event", this._handleEvent);
+        this._dataStore = null;
     }
 
     get previous() {
-        return this.previousTracksCount > 0 ? this.previousTracks[0] : null;
+        return this.previousTracksCount > 0 ? this.previousTracks[this.previousTracksIndex] : null;
     }
     
     get currenttrack() {
@@ -154,17 +160,11 @@ class Player extends EventEmitter {
     addToPreviousTrack(track) {
         if (!track) return;
         
+        this.previousTracks[this.previousTracksIndex] = track;
+        this.previousTracksIndex = (this.previousTracksIndex + 1) % 50;
+        
         if (this.previousTracksCount < 50) {
-            for (let i = this.previousTracksCount; i > 0; i--) {
-                this.previousTracks[i] = this.previousTracks[i-1];
-            }
-            this.previousTracks[0] = track;
             this.previousTracksCount++;
-        } else {
-            for (let i = 49; i > 0; i--) {
-                this.previousTracks[i] = this.previousTracks[i-1];
-            }
-            this.previousTracks[0] = track;
         }
     }
 
@@ -222,19 +222,34 @@ class Player extends EventEmitter {
         
         this.disconnect();
         
-        if (this.nowPlayingMessage) {
-            this.nowPlayingMessage.delete().catch(() => {});
-            this.nowPlayingMessage = null;
-        }
+        this._cleanupNowPlayingMessage();
         
         this.isAutoplay = false;
 
+        this.off("playerUpdate", this._boundHandlers.playerUpdate);
+        this.off("event", this._boundHandlers.event);
+        
         this.aqua.destroyPlayer(this.guildId);
         this.nodes.rest.destroyPlayer(this.guildId);
+        
         this.clearData();
         this.removeAllListeners();
+        
+        this._boundHandlers = null;
+        this.queue = null;
+        this.previousTracks = null;
+        this.connection = null;
+        this.filters = null;
+        
         return this;
     }
+    
+    _cleanupNowPlayingMessage() {
+        if (this.nowPlayingMessage) {
+            this.nowPlayingMessage.delete().catch(() => {});
+            this.nowPlayingMessage = null;
+        }
+    }
 
     pause(paused) {
         if (this.paused === paused) return this;
@@ -312,6 +327,8 @@ class Player extends EventEmitter {
     }
 
     disconnect() {
+        if (!this.connected) return this;
+        
         this.connected = false;
         this.send({ guild_id: this.guildId, channel_id: null });
         this.voiceChannel = null;
@@ -372,26 +389,34 @@ class Player extends EventEmitter {
             return;
         }
 
+        await this._handleTrackLooping(player, track);
+
+        if (player.queue.isEmpty()) {
+            await this._handleEmptyQueue(player);
+        } else {
+            this.aqua.emit("trackEnd", player, track, reason);
+            await player.play();
+        }
+    }
+    
+    async _handleTrackLooping(player, track) {
         if (this.loop === Player.LOOP_MODES.TRACK) {
             player.queue.unshift(track);
         } else if (this.loop === Player.LOOP_MODES.QUEUE) {
             player.queue.push(track);
         }
-
-        if (player.queue.isEmpty()) {
-            if (this.isAutoplayEnabled) {
-                await player.autoplay(player);
-            } else {
-                this.playing = false;
-                if (this.leaveOnEnd) {
-                    this.clearData();
-                    this.cleanup();
-                }
-                this.aqua.emit("queueEnd", player);
-            }
+    }
+    
+    async _handleEmptyQueue(player) {
+        if (this.isAutoplayEnabled) {
+            await player.autoplay(player);
         } else {
-            this.aqua.emit("trackEnd", player, track, reason);
-            await player.play();
+            this.playing = false;
+            if (this.leaveOnEnd) {
+                this.clearData();
+                this.cleanup();
+            }
+            this.aqua.emit("queueEnd", player);
         }
     }