aqualink 2.2.0 → 2.3.0

package/build/structures/Aqua.js

@@ -1,5 +1,4 @@
 "use strict";
-
 const { EventEmitter } = require("node:events");
 const Node = require("./Node");
 const Player = require("./Player");
@@ -14,14 +13,12 @@ class Aqua extends EventEmitter {
         if (!Array.isArray(nodes) || !nodes.length) {
             throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
         }
-
         this.client = client;
         this.nodes = nodes;
         this.nodeMap = new Map();
         this.players = new Map();
         this.clientId = null;
         this.initiated = false;
-
         this.shouldDeleteMessage = options.shouldDeleteMessage ?? false;
         this.defaultSearchPlatform = options.defaultSearchPlatform ?? 'ytsearch';
         this.leaveOnEnd = options.leaveOnEnd ?? true;
@@ -32,88 +29,72 @@ class Aqua extends EventEmitter {
         this.autoResume = options.autoResume ?? false;
         this.infiniteReconnects = options.infiniteReconnects ?? false;
         this.options = options;
-
         this.setMaxListeners(0);
         this._leastUsedCache = { nodes: [], timestamp: 0 };
     }
 
-
     defaultSendFunction(payload) {
         const guild = this.client.guilds.cache.get(payload.d.guild_id);
         if (guild) guild.shard.send(payload);
     }
 
-    validateInputs(client, nodes) {
-        if (!client) throw new Error("Client is required to initialize Aqua");
-        if (!Array.isArray(nodes) || !nodes.length) {
-            throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
-        }
-    }
-
     get leastUsedNodes() {
         const now = Date.now();
         if (now - this._leastUsedCache.timestamp < 50) return this._leastUsedCache.nodes;
-
-        const nodes = [];
-        for (const node of this.nodeMap.values()) {
-            if (node.connected) nodes.push(node);
-        }
+        const nodes = Array.from(this.nodeMap.values()).filter(node => node.connected);
         nodes.sort((a, b) => a.rest.calls - b.rest.calls);
-
         this._leastUsedCache = { nodes, timestamp: now };
         return nodes;
     }
-    init(clientId) {
-        if (this.initiated) return this;
 
+    async init(clientId) {
+        if (this.initiated) return this;
         this.clientId = clientId;
-
         try {
-            for (let i = 0; i < this.nodes.length; i++) { this.createNode(this.nodes[i]); }
-            if (this.plugins.length > 0) { for (let i = 0; i < this.plugins.length; i++) { this.plugins[i].load(this); } }
-
+            for (let i = 0; i < this.nodes.length; i++) {
+                const node = this.nodes[i];
+                await this.createNode(node);
+            }
+            for (let i = 0; i < this.plugins.length; i++) {
+                const plugin = this.plugins[i];
+                plugin.load(this);
+            }
             this.initiated = true;
         } catch (error) {
             this.initiated = false;
             throw error;
         }
-
         return this;
     }
 
-    createNode(options) {
+    async createNode(options) {
         const nodeId = options.name || options.host;
         this.destroyNode(nodeId);
-
         const node = new Node(this, options, this.options);
         this.nodeMap.set(nodeId, node);
         this._leastUsedCache.timestamp = 0;
-
-        node.connect()
-            .then(() => this.emit("nodeCreate", node))
-            .catch(error => {
-                this.nodeMap.delete(nodeId);
-                console.error("Failed to connect node:", error);
-                throw error;
-            });
-
+        try {
+            await node.connect();
+            this.emit("nodeCreate", node);
+        } catch (error) {
+            this.nodeMap.delete(nodeId);
+            console.error("Failed to connect node:", error);
+            throw error;
+        }
         return node;
     }
 
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-
         node.destroy();
         this.nodeMap.delete(identifier);
         this.emit("nodeDestroy", node);
     }
 
-
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
         if (!player) return;
-
         const updateMethod = t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
         if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
             if (player.connection && typeof player.connection[updateMethod] === "function") {
@@ -127,14 +108,12 @@ class Aqua extends EventEmitter {
 
     fetchRegion(region) {
         if (!region) return this.leastUsedNodes;
-
         const lowerRegion = region.toLowerCase();
-        const regionNodes = Array.from(this.nodeMap.values()).filter(node =>
+        const nodes = Array.from(this.nodeMap.values()).filter(node =>
             node.connected && node.regions?.includes(lowerRegion)
         );
-        regionNodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
-
-        return regionNodes;
+        nodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
+        return nodes;
     }
 
     calculateLoad(node) {
@@ -147,11 +126,9 @@ class Aqua extends EventEmitter {
         this.ensureInitialized();
         const existingPlayer = this.players.get(options.guildId);
         if (existingPlayer && existingPlayer.voiceChannel) return existingPlayer;
-
         const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes;
         const node = availableNodes[0];
         if (!node) throw new Error("No nodes are available");
-
         return this.createPlayer(node, options);
     }
 
@@ -159,11 +136,9 @@ class Aqua extends EventEmitter {
         this.destroyPlayer(options.guildId);
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
-
         player.once("destroy", () => {
             this.players.delete(options.guildId);
         });
-
         player.connect(options);
         this.emit("playerCreate", player);
         return player;
@@ -172,7 +147,6 @@ class Aqua extends EventEmitter {
     async destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
-
         try {
             await player.clearData();
             player.removeAllListeners();
@@ -187,7 +161,6 @@ class Aqua extends EventEmitter {
         this.ensureInitialized();
         const requestNode = this.getRequestNode(nodes);
         const formattedQuery = this.formatQuery(query, source);
-
         try {
             const response = await requestNode.rest.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`);
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
@@ -204,11 +177,9 @@ class Aqua extends EventEmitter {
 
     getRequestNode(nodes) {
         if (!nodes) return this.leastUsedNodes[0];
-
         if (!(typeof nodes === "string" || nodes instanceof Node)) {
             throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
         }
-
         return (typeof nodes === "string" ? this.nodeMap.get(nodes) : nodes) ?? this.leastUsedNodes[0];
     }
 
@@ -224,11 +195,9 @@ class Aqua extends EventEmitter {
         try {
             const ytIdentifier = `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`;
             const youtubeResponse = await rest.makeRequest("GET", ytIdentifier);
-
             if (!["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
                 return youtubeResponse;
             }
-
             const spotifyIdentifier = `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`;
             return await rest.makeRequest("GET", spotifyIdentifier);
         } catch (error) {
@@ -245,14 +214,11 @@ class Aqua extends EventEmitter {
             pluginInfo: response.pluginInfo ?? {},
             tracks: []
         };
-
         if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
             baseResponse.exception = response.data ?? response.exception;
             return baseResponse;
         }
-
         const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
-
         switch (response.loadType) {
             case "track":
                 if (response.data) {
@@ -289,7 +255,6 @@ class Aqua extends EventEmitter {
                 }
                 break;
         }
-
         return baseResponse;
     }
 
@@ -301,7 +266,6 @@ class Aqua extends EventEmitter {
 
     async search(query, requester, source = this.defaultSearchPlatform) {
         if (!query || !requester) return null;
-
         try {
             const { tracks } = await this.resolve({ query, source, requester });
             return tracks || null;
@@ -311,11 +275,33 @@ class Aqua extends EventEmitter {
         }
     }
 
-    cleanupPlayer(player) {
-        if (player && this.players.has(player.guildId)) {
+    async cleanupPlayer(player) {
+        if (!player) return;
+        try {
+            if (player.connection) {
+                try {
+                    await player.connection.disconnect();
+                    player.connection = null;
+                } catch (error) {
+                    console.error(`Error disconnecting player connection: ${error.message}`);
+                }
+            }
+            if (player.queue) {
+                player.queue.clear();
+            }
+            if (typeof player.stop === 'function') {
+                try {
+                    await player.stop();
+                } catch (error) {
+                    console.error(`Error stopping player: ${error.message}`);
+                }
+            }
+            player.removeAllListeners();
             this.players.delete(player.guildId);
+            this.emit("playerCleanup", player.guildId);
+        } catch (error) {
+            console.error(`Error during player cleanup: ${error.message}`);
         }
     }
 }
-
 module.exports = Aqua;