aqualink 2.7.0 → 2.7.1

package/build/structures/Aqua.js

@@ -4,7 +4,7 @@ const Player = require("./Player");
 const Track = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const { EventEmitter } = require('tseep');
-const fs = require('fs-extra');
+const fs = require('fs/promises');
 
 const URL_REGEX = /^https?:\/\//;
 const DEFAULT_OPTIONS = Object.freeze({
@@ -57,11 +57,11 @@ class Aqua extends EventEmitter {
         this.send = this.options.send || this.defaultSendFunction.bind(this);
 
         this._leastUsedCache = { nodes: [], timestamp: 0 };
-        
+
         this._nodeStates = new Map();
         this._failoverQueue = new Map();
         this._lastFailoverAttempt = new Map();
-        
+
         this._boundCleanupPlayer = this.cleanupPlayer.bind(this);
         this._boundHandlePlayerDestroy = this._handlePlayerDestroy.bind(this);
     }
@@ -100,16 +100,16 @@ class Aqua extends EventEmitter {
                 console.error(`Failed to create node ${node.name || node.host}:`, err);
                 return null;
             }));
-            
+
             const results = await Promise.allSettled(nodePromises);
             const successfulNodes = results.filter(r => r.status === 'fulfilled' && r.value).length;
-            
+
             if (successfulNodes === 0) {
                 throw new Error("No nodes could be connected");
             }
 
-            await Promise.all(this.plugins.map(plugin => 
-                Promise.resolve(plugin.load(this)).catch(err => 
+            await Promise.all(this.plugins.map(plugin =>
+                Promise.resolve(plugin.load(this)).catch(err =>
                     console.error("Plugin load error:", err)
                 )
             ));
@@ -166,10 +166,10 @@ class Aqua extends EventEmitter {
 
     async handleNodeFailover(failedNode) {
         if (!this.failoverOptions.enabled) return;
-        
+
         const nodeId = failedNode.name || failedNode.host;
         const now = Date.now();
-        
+
         const nodeState = this._nodeStates.get(nodeId);
         if (nodeState?.failoverInProgress) return;
 
@@ -182,10 +182,10 @@ class Aqua extends EventEmitter {
         this._nodeStates.set(nodeId, { connected: false, failoverInProgress: true });
         this._lastFailoverAttempt.set(nodeId, now);
         this._failoverQueue.set(nodeId, currentAttempts + 1);
-        
+
         try {
             this.emit("nodeFailover", failedNode);
-            
+
             const affectedPlayers = this._getPlayersForNode(failedNode);
             if (affectedPlayers.length === 0) {
                 this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
@@ -200,14 +200,14 @@ class Aqua extends EventEmitter {
             }
 
             const failoverResults = await this._migratePlayersWithRetry(affectedPlayers, availableNodes);
-            
+
             const successful = failoverResults.filter(r => r.success).length;
             const failed = failoverResults.length - successful;
-            
+
             if (successful > 0) {
                 this.emit("nodeFailoverComplete", failedNode, successful, failed);
             }
-            
+
         } catch (error) {
             this.emit("error", null, new Error(`Failover failed for node ${nodeId}: ${error.message}`));
         } finally {
@@ -226,14 +226,14 @@ class Aqua extends EventEmitter {
     }
 
     _getAvailableNodesForFailover(failedNode) {
-        return this.leastUsedNodes.filter(node => 
+        return this.leastUsedNodes.filter(node =>
             node !== failedNode && node.name !== failedNode.name
         );
     }
 
     async _migratePlayersWithRetry(players, availableNodes) {
         const results = [];
-        
+
         const concurrency = 3;
         for (let i = 0; i < players.length; i += concurrency) {
             const batch = players.slice(i, i + concurrency);
@@ -246,11 +246,11 @@ class Aqua extends EventEmitter {
                     return { player, success: false, error };
                 }
             });
-            
+
             const batchResults = await Promise.allSettled(batchPromises);
             results.push(...batchResults.map(r => r.value || r.reason));
         }
-        
+
         return results;
     }
 
@@ -261,7 +261,7 @@ class Aqua extends EventEmitter {
 
         const guildId = player.guildId;
         let retryCount = 0;
-        
+
         while (retryCount < this.failoverOptions.maxRetries) {
             try {
                 const targetNode = this._selectBestNode(availableNodes, player);
@@ -274,15 +274,15 @@ class Aqua extends EventEmitter {
                 if (!newPlayer) throw new Error("Failed to create player on target node");
 
                 await this._restorePlayerState(newPlayer, playerState);
-                
+
                 newPlayer.destroy();
                 if (playerState.current) {
                     newPlayer.queue.add(playerState.current);
                 }
-                
+
                 this.emit("playerMigrated", player, newPlayer, targetNode);
                 return newPlayer;
-                
+
             } catch (error) {
                 retryCount++;
                 if (retryCount < this.failoverOptions.maxRetries) {
@@ -296,12 +296,12 @@ class Aqua extends EventEmitter {
 
     _selectBestNode(availableNodes, player) {
         if (player.region) {
-            const regionNode = availableNodes.find(node => 
+            const regionNode = availableNodes.find(node =>
                 node.regions?.includes(player.region.toLowerCase())
             );
             if (regionNode) return regionNode;
         }
-        
+
         return availableNodes[0];
     }
 
@@ -349,7 +349,7 @@ class Aqua extends EventEmitter {
         try {
             // Batch operations where possible
             const operations = [];
-            
+
             if (playerState.volume !== undefined) {
                 operations.push(newPlayer.setVolume(playerState.volume));
             }
@@ -365,15 +365,15 @@ class Aqua extends EventEmitter {
             // Handle current track restoration
             if (playerState.current && this.failoverOptions.preservePosition) {
                 newPlayer.queue.unshift(playerState.current);
-                
+
                 if (this.failoverOptions.resumePlayback) {
                     await newPlayer.play();
-                    
+
                     if (playerState.position > 0) {
                         await this._delay(300); // Reduced delay
                         await newPlayer.seek(playerState.position);
                     }
-                    
+
                     if (playerState.paused) {
                         await newPlayer.pause();
                     }
@@ -557,7 +557,7 @@ class Aqua extends EventEmitter {
                     baseResponse.tracks.push(new Track(response.data, requester, requestNode));
                 }
                 break;
-                
+
             case "playlist": {
                 const info = response.data?.info;
                 if (info) {
@@ -604,42 +604,50 @@ class Aqua extends EventEmitter {
         }
     }
 
-    // Optimized save/load methods
     async savePlayer(filePath = "./AquaPlayers.json") {
-        const data = Array.from(this.players.values(), player => ({
-            g: player.guildId,
-            t: player.textChannel,
-            v: player.voiceChannel,
-            u: player.current?.uri || null,
-            p: player.position || 0,
-            ts: player.timestamp || 0,
-            q: player.queue?.tracks?.slice(0, 5).map(tr => tr.uri) || [],
-            r: player.requester || player.current?.requester,
-            vol: player.volume,
-            pa: player.paused,
-            n: player.nodes?.name || null
-        }));
-        
+        const data = Array.from(this.players.values()).map(player => {
+            const requester = player.requester || player.current?.requester;
+
+            return {
+                g: player.guildId,
+                t: player.textChannel,
+                v: player.voiceChannel,
+                u: player.current?.uri || null,
+                p: player.position || 0,
+                ts: player.timestamp || 0,
+                q: player.queue?.tracks?.map(tr => tr.uri).slice(0, 5) || [],
+                r: requester ? {
+                    id: requester.id,
+                    username: requester.username,
+                    globalName: requester.globalName,
+                    discriminator: requester.discriminator,
+                    avatar: requester.avatar
+                } : null,
+                vol: player.volume,
+                pa: player.paused,
+                isPlaying: !!player.current && !player.paused
+            };
+        });
+
         await fs.writeFile(filePath, JSON.stringify(data), "utf8");
+        this.emit("debug", "Aqua", `Saved ${data.length} players to ${filePath}`);
     }
 
     async loadPlayers(filePath = "./AquaPlayers.json") {
         try {
             await fs.access(filePath);
             await this._waitForFirstNode();
-            
+
             const data = JSON.parse(await fs.readFile(filePath, "utf8"));
-            
-            // Process in batches to avoid overwhelming
+
             const batchSize = 5;
             for (let i = 0; i < data.length; i += batchSize) {
                 const batch = data.slice(i, i + batchSize);
                 await Promise.all(batch.map(p => this._restorePlayer(p)));
             }
-            
+
             await fs.writeFile(filePath, "[]", "utf8");
         } catch (error) {
-            // Silent fail if file doesn't exist
         }
     }
 
@@ -647,11 +655,11 @@ class Aqua extends EventEmitter {
         try {
             let player = this.players.get(p.g);
             if (!player) {
-                const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ? 
+                const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ?
                     this.nodeMap.get(p.n) : this.leastUsedNodes[0];
-                
+
                 if (!targetNode) return;
-                
+
                 player = await this.createConnection({
                     guildId: p.g,
                     textChannel: p.t,
@@ -661,7 +669,6 @@ class Aqua extends EventEmitter {
                 });
             }
 
-            // Restore current track
             if (p.u && player) {
                 const resolved = await this.resolve({ query: p.u, requester: p.r });
                 if (resolved.tracks?.[0]) {
@@ -670,13 +677,12 @@ class Aqua extends EventEmitter {
                     if (typeof p.ts === "number") player.timestamp = p.ts;
                 }
             }
-            
-            // Restore queue
+
             if (p.q?.length && player) {
                 const queuePromises = p.q
                     .filter(uri => uri !== p.u)
                     .map(uri => this.resolve({ query: uri, requester: p.r }));
-                
+
                 const queueResults = await Promise.allSettled(queuePromises);
                 queueResults.forEach(result => {
                     if (result.status === 'fulfilled' && result.value.tracks?.[0]) {
@@ -684,21 +690,20 @@ class Aqua extends EventEmitter {
                     }
                 });
             }
-            
+
             if (player) {
                 player.paused = !!p.pa;
-                if (!player.playing && !player.paused && player.queue.size > 0) {
+                if ((p.isPlaying || (p.pa && p.u)) && player.queue.size > 0) {
                     player.play();
                 }
             }
         } catch (error) {
-            // Silent fail for individual player restoration
         }
     }
 
     async _waitForFirstNode() {
         if (this.leastUsedNodes.length > 0) return;
-        
+
         return new Promise(resolve => {
             const checkInterval = setInterval(() => {
                 if (this.leastUsedNodes.length > 0) {
@@ -747,15 +752,15 @@ class Aqua extends EventEmitter {
         }
         return stats;
     }
-    
+
     async forceFailover(nodeIdentifier) {
         const node = this.nodeMap.get(nodeIdentifier);
         if (!node) return;
-        
+
         if (node.connected) {
             await node.destroy();
         }
-        
+
         this._cleanupNode(nodeIdentifier);
     }
 }

package/build/structures/Node.js

@@ -1,4 +1,5 @@
 "use strict";
+
 const WebSocket = require('ws');
 const Rest = require("./Rest");
 
@@ -29,9 +30,6 @@ class Node {
         this.sessionId = sessionId;
         this.regions = regions;
 
-        this.wsUrl = `ws${this.secure ? "s" : ""}://${this.host}:${this.port}/v4/websocket`;
-        this.rest = new Rest(aqua, this);
-
         const {
             resumeTimeout = 60,
             autoResume = false,
@@ -46,15 +44,24 @@ class Node {
         this.reconnectTries = reconnectTries;
         this.infiniteReconnects = infiniteReconnects;
 
+        this.wsUrl = `ws${this.secure ? "s" : ""}://${this.host}:${this.port}/v4/websocket`;
+        this.rest = new Rest(aqua, this);
+        this._headers = this._constructHeaders();
+
         this.connected = false;
+        this.isDestroyed = false;
         this.info = null;
         this.ws = null;
         this.reconnectAttempted = 0;
         this.reconnectTimeoutId = null;
-        this.isDestroyed = false;
         this.lastHealthCheck = Date.now();
 
-        this._headers = this._constructHeaders();
+        // Pre-bind event handlers for efficiency
+        this._onOpen = this._onOpen.bind(this);
+        this._onError = this._onError.bind(this);
+        this._onMessage = this._onMessage.bind(this);
+        this._onClose = this._onClose.bind(this);
+
         this.initializeStats();
     }
 
@@ -89,6 +96,9 @@ class Node {
         this.reconnectAttempted = 0;
         this.lastHealthCheck = Date.now();
         this.aqua.emit("debug", this.name, "WebSocket connection established");
+        
+        clearTimeout(this.reconnectTimeoutId);
+        this.reconnectTimeoutId = null;
 
         if (this.aqua.bypassChecks?.nodeFetchInfo) return;
 
@@ -97,7 +107,7 @@ class Node {
             this.aqua.emit("nodeConnected", this);
 
             if (this.autoResume && this.sessionId) {
-                await this.aqua.loadPlayers();
+                await this.resumePlayers();
             }
         } catch (err) {
             this.info = null;
@@ -118,30 +128,27 @@ class Node {
             return;
         }
 
-        const op = payload?.op;
+        const { op, guildId } = payload;
         if (!op) return;
 
         this.lastHealthCheck = Date.now();
-
-        if (op === "stats") {
-            this._updateStats(payload);
-            return;
-        }
-        if (op === "ready") {
-            this._handleReadyOp(payload);
-            return;
-        }
-
-        if (op.startsWith("Lyrics")) {
-            const player = payload.guildId ? this.aqua.players.get(payload.guildId) : null;
-            const track = payload.track || null;
-            this.aqua.emit(op, player, track, payload);
-            return;
-        }
-
-        if (payload.guildId) {
-            const player = this.aqua.players.get(payload.guildId);
-            if (player) player.emit(op, payload);
+        
+        switch (op) {
+            case "stats":
+                this._updateStats(payload);
+                break;
+            case "ready":
+                this._handleReadyOp(payload);
+                break;
+            default:
+                if (op.startsWith("Lyrics")) {
+                    const player = guildId ? this.aqua.players.get(guildId) : null;
+                    this.aqua.emit(op, player, payload.track || null, payload);
+                } else if (guildId) {
+                    const player = this.aqua.players.get(guildId);
+                    player?.emit(op, payload);
+                }
+                break;
         }
     }
 
@@ -150,22 +157,20 @@ class Node {
         const reasonStr = reason?.toString() || "No reason provided";
 
         this.aqua.emit("nodeDisconnect", this, { code, reason: reasonStr });
-
         this.aqua.handleNodeFailover(this);
-
         this.scheduleReconnect(code);
     }
 
     scheduleReconnect(code) {
-        this.clearReconnectTimeout();
-
         if (code === Node.WS_CLOSE_NORMAL || this.isDestroyed) {
-            this.aqua.emit("debug", this.name, "WebSocket closed normally, not reconnecting");
+            this.aqua.emit("debug", this.name, "WebSocket closed normally, not reconnecting.");
             return;
         }
 
+        if (this.reconnectTimeoutId) return;
+
         if (this.infiniteReconnects) {
-            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds");
+            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds.");
             this.reconnectTimeoutId = setTimeout(() => this.connect(), 10000);
             return;
         }
@@ -188,26 +193,19 @@ class Node {
     }
 
     calculateBackoff() {
-        const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.reconnectAttempted);
+        const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.reconnectAttempted - 1);
         const jitter = Math.random() * Math.min(2000, baseBackoff * 0.2);
         return Math.min(baseBackoff + jitter, Node.MAX_BACKOFF);
     }
 
-    clearReconnectTimeout() {
-        if (this.reconnectTimeoutId) {
-            clearTimeout(this.reconnectTimeoutId);
-            this.reconnectTimeoutId = null;
-        }
-    }
-
-    async connect() {
+    connect() {
         if (this.isDestroyed) return;
-        
+
         if (this.ws && this.ws.readyState === Node.WS_OPEN) {
             this.aqua.emit("debug", this.name, "WebSocket already connected");
             return;
         }
-
+        
         this.cleanupExistingConnection();
 
         this.ws = new WebSocket(this.wsUrl, {
@@ -215,31 +213,35 @@ class Node {
             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.ws.once("open", this._onOpen);
+        this.ws.once("error", this._onError);
+        this.ws.on("message", this._onMessage);
+        this.ws.once("close", this._onClose);
     }
 
     cleanupExistingConnection() {
         if (!this.ws) return;
 
         this.ws.removeAllListeners();
-
-        if (this.ws.readyState === Node.WS_OPEN) {
-            try {
-                this.ws.close();
-            } catch (err) {
-                this.emitError(`Failed to close WebSocket: ${err.message}`);
+        try {
+            if (this.ws.readyState === Node.WS_OPEN) {
+                this.ws.close(Node.WS_CLOSE_NORMAL, "Manual closure");
             }
+        } catch (err) {
+            this.emitError(`Failed to close WebSocket: ${err.message}`);
         }
-
         this.ws = null;
     }
 
     destroy(clean = false) {
+        if (this.isDestroyed) return;
         this.isDestroyed = true;
-        this.clearReconnectTimeout();
+
+        if (this.reconnectTimeoutId) {
+            clearTimeout(this.reconnectTimeoutId);
+            this.reconnectTimeoutId = null;
+        }
+
         this.cleanupExistingConnection();
 
         if (!clean) {
@@ -251,61 +253,29 @@ class Node {
         this.aqua.emit("nodeDestroy", this);
         this.info = null;
     }
-
-    async getStats() {
-        if (this.connected && this.stats) {
-            return this.stats;
-        }
-
-        try {
-            const newStats = await this.rest.getStats();
-            if (newStats && this.stats) {
-                this.stats.players = newStats.players ?? this.stats.players;
-                this.stats.playingPlayers = newStats.playingPlayers ?? this.stats.playingPlayers;
-                this.stats.uptime = newStats.uptime ?? this.stats.uptime;
-                this.stats.ping = newStats.ping ?? this.stats.ping;
-                
-                if (newStats.memory) {
-                    Object.assign(this.stats.memory, newStats.memory);
-                    this._calculateMemoryPercentages();
-                }
-                
-                if (newStats.cpu) {
-                    Object.assign(this.stats.cpu, newStats.cpu);
-                    this._calculateCpuPercentages();
-                }
-                
-                if (newStats.frameStats) {
-                    Object.assign(this.stats.frameStats, newStats.frameStats);
-                }
-            }
-            return this.stats;
-        } catch (err) {
-            this.emitError(`Failed to fetch node stats: ${err.message}`);
-            return this.stats;
-        }
-    }
-
+    
     _updateStats(payload) {
         if (!payload) return;
+        
+        const { players, playingPlayers, uptime, memory, cpu, frameStats, ping } = payload;
+        
+        this.stats.players = players;
+        this.stats.playingPlayers = playingPlayers;
+        this.stats.uptime = uptime;
+        this.stats.ping = ping ?? this.stats.ping;
 
-        this.stats.players = payload.players;
-        this.stats.playingPlayers = payload.playingPlayers;
-        this.stats.uptime = payload.uptime;
-        this.stats.ping = payload.ping;
-
-        if (payload.memory) {
-            Object.assign(this.stats.memory, payload.memory);
+        if (memory) {
+            Object.assign(this.stats.memory, memory);
             this._calculateMemoryPercentages();
         }
 
-        if (payload.cpu) {
-            Object.assign(this.stats.cpu, payload.cpu);
+        if (cpu) {
+            Object.assign(this.stats.cpu, cpu);
             this._calculateCpuPercentages();
         }
 
-        if (payload.frameStats) {
-            Object.assign(this.stats.frameStats, payload.frameStats);
+        if (frameStats) {
+            Object.assign(this.stats.frameStats, frameStats);
         }
     }
 
@@ -324,16 +294,16 @@ class Node {
         }
     }
 
-    _handleReadyOp(payload) {
-        if (!payload.sessionId) {
+    _handleReadyOp({ sessionId }) {
+        if (!sessionId) {
             this.emitError("Ready payload missing sessionId");
             return;
         }
 
-        this.sessionId = payload.sessionId;
-        this.rest.setSessionId(payload.sessionId);
+        this.sessionId = sessionId;
+        this.rest.setSessionId(sessionId);
         this._headers = this._constructHeaders();
-        this.aqua.emit("nodeConnect", this);
+        this.aqua.emit("nodeReady", this);
     }
 
     async resumePlayers() {
@@ -344,6 +314,7 @@ class Node {
             this.emitError(`Failed to resume session: ${err.message}`);
         }
     }
+
     emitError(error) {
         const errorObj = error instanceof Error ? error : new Error(error);
         console.error(`[Aqua] [${this.name}] Error:`, errorObj);

package/build/structures/Player.js

@@ -458,7 +458,7 @@ class Player extends EventEmitter {
             try {
                 await this.nowPlayingMessage.delete();
             } catch (error) {
-                console.error("Error deleting now playing message:", error);
+                // Ignore
             } finally {
                 this.nowPlayingMessage = null;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",
@@ -42,7 +42,6 @@
   },
   "dependencies": {
     "ws": "^8.18.3",
-    "fs-extra": "^11.3.0",
 		"tseep": "^1.3.1"
   },
   "maintainers": [