aqualink 1.5.1 → 1.6.0

package/README.md

@@ -18,23 +18,27 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 - Minimal Requests to the lavalink server (helps the lavalink recourses!)
 - Easy player, node, aqua managing
 - Fast responses from rest and node
-- Playlist support (My mix playlists, youtube playlists)
+- Playlist support (My mix playlists, youtube playlists, spotify playlists)
 
 # Docs (Wiki)
 - https://github.com/ToddyTheNoobDud/AquaLink/wiki
 
 - Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
 
-# Yay, Version 1.5.0 || 1.5.1 is released, wow
+# Omg version 1.6.0 woah aqualink
 
-- Optimized memory usage in `FetchImage` by removing unnecessary code and saving, addressing some memory leaks.
-- Updated `AQUA` with additional cleanup options, faster response arrays, Remade `ConstructResponse` and `resolve`, and improved the `UpdateVoice` handler.
-- Updated `CONNECTION` to fix bugs, improve the cleanup system, and Improve speed.
-- Improved cleanup in the `NODE` manager and fixed issues for VPS.
-- Rewrited the `TRACK` handler for better speed by removing redundant checks and code.
-- REMADE the `PLAYER` system to fix bugs, resolve message sending issues, Fixes `EventEmitter` memory leaks (also Fixes `AQUA`), remove unnecessary JSDoc comments, rewrite some methods, and enhance cleanup.
-- 1.5.1 : Fully fixed destroy and the queue handling for delete, also now it deletes from lavalink...
+- Reworked the `TRACK` Manager (This improves the speed by wayyy more, also uses objects, removed useless code)
+- Improved the `REST` Manager (This improves the garbage collector, an faster code, and more optimized)
+- Added enqueue to `QUEUE` (this gets the previous, made for dev), removed addMultiple (useless)
+- Fully Rewrite the `PLAYER` Manager (Way faster resolving, way less recourse intensive, more responsive, better error handling)
 
+^^ Now uses the WeakMap and WeakSet for an garbage collector, making it with an better memory management.
+
+- Rewrite the `NODE` Manager (reconnect speeds improved, various methods improved, Rewrite the cache and status handler, improve the performance) - Also fixed player resuming.
+- Remade some stuff in `CONNECTION` (this improves error handling, cleaning up, and speed)
+- Rewrite `AQUA` Manager (remade every single method, improved the resolve, made the code dynamic, fixed lots of bugs, uses weakMap too.) - Added autoResume option (true false)
+
+- There are way more stuff that i forgot to add on changelog. pls report bugs on my github !
 # How to install
 
 `npm install aqualink`

package/build/handlers/fetchImage.js

@@ -22,10 +22,9 @@ async function getImageUrl(info) {
 
 async function fetchThumbnail(url) {
     try {
-        const response = await request(url, { method: "GET" });
-        const json = await response.json();
-        response.body.destroy();
-
+        const { body } = await request(url, { method: "GET" });
+        const json = await body.json();
+        await body.dump();
         return json.thumbnail_url || null;
     } catch (error) {
         console.error(`Error fetching ${url}:`, error);

package/build/structures/Aqua.js

@@ -3,7 +3,8 @@ const { Node } = require("./Node");
 const { Player } = require("./Player");
 const { Track } = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
-
+const URL_REGEX = /^https?:\/\//;
+const REQUEST_TIMEOUT = 10000;
 class Aqua extends EventEmitter {
     /**
      * @param {Object} client - The client instance.
@@ -14,6 +15,7 @@ class Aqua extends EventEmitter {
      * @param {string} [options.restVersion="v4"] - Version of the REST API.
      * @param {Array<Object>} [options.plugins=[]] - Plugins to load.
      * @param {string} [options.shouldDeleteMessage='none'] - Should delete your message? (true, false)
+     * @param {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
      */
     constructor(client, nodes, options) {
         super();
@@ -31,138 +33,218 @@ class Aqua extends EventEmitter {
         this.version = pkgVersion;
         this.options = options;
         this.send = options.send;
+        this.autoResume = options.autoResume || false;
         this.setMaxListeners(0);
     }
 
     validateInputs(client, nodes, options) {
         if (!client) throw new Error("Client is required to initialize Aqua");
-        if (!Array.isArray(nodes) || nodes.length === 0) throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
+        if (!Array.isArray(nodes) || !nodes.length) throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
         if (typeof options?.send !== "function") throw new Error("Send function is required to initialize Aqua");
     }
 
     get leastUsedNodes() {
-        return Array.from(this.nodeMap.values())
-            .filter(node => node.connected)
-            .sort((a, b) => a.rest.calls - b.rest.calls);
+        const activeNodes = [...this.nodeMap.values()].filter(node => node.connected);
+        if (!activeNodes.length) return [];
+        return activeNodes.sort((a, b) => a.rest.calls - b.rest.calls);
     }
 
     init(clientId) {
         if (this.initiated) return this;
         this.clientId = clientId;
-        this.nodes.forEach(nodeConfig => this.createNode(nodeConfig));
-        this.initiated = true;
-        this.plugins.forEach(plugin => plugin.load(this));
+
+        try {
+            this.nodes.forEach(nodeConfig => this.createNode(nodeConfig));
+            this.initiated = true;
+            this.plugins.forEach(plugin => plugin.load(this));
+        } catch (error) {
+            this.initiated = false;
+            throw error;
+        }
+
         return this;
     }
 
     createNode(options) {
+        const nodeId = options.name || options.host;
+        if (this.nodeMap.has(nodeId)) {
+            this.destroyNode(nodeId);
+        }
+
         const node = new Node(this, options, this.options);
-        this.nodeMap.set(options.name || options.host, node);
-        node.connect();
-        this.emit("nodeCreate", node);
-        return node;
+        this.nodeMap.set(nodeId, node);
+
+        try {
+            node.connect();
+            this.emit("nodeCreate", node);
+            return node;
+        } catch (error) {
+            this.nodeMap.delete(nodeId);
+            throw error;
+        }
     }
 
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
-        if (node) {
+        if (!node) return;
+
+        try {
             node.disconnect();
+            node.removeAllListeners(); 
             this.nodeMap.delete(identifier);
             this.emit("nodeDestroy", node);
+        } catch (error) {
+            console.error(`Error destroying node ${identifier}:`, error);
         }
     }
 
     updateVoiceState(packet) {
+        if (!packet?.d?.guild_id) return;
+
         const player = this.players.get(packet.d.guild_id);
-        if (player && (packet.t === "VOICE_SERVER_UPDATE" || packet.t === "VOICE_STATE_UPDATE" && packet.d.user_id === this.clientId)) {
-            player.connection[packet.t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate"](packet.d);
+        if (!player) return;
+
+        if (packet.t === "VOICE_SERVER_UPDATE" ||
+            (packet.t === "VOICE_STATE_UPDATE" && packet.d.user_id === this.clientId)) {
+
+            const updateType = packet.t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
+            player.connection[updateType](packet.d);
+
             if (packet.d.status === "disconnected") {
-                this.cleanupPlayer(player); // Cleanup when disconnected
+                this.cleanupPlayer(player);
             }
         }
     }
 
     fetchRegion(region) {
-        const lowerRegion = region?.toLowerCase();
-        return [...this.nodeMap.values()]
-            .filter(node => node.connected && node.regions?.includes(lowerRegion))
-            .sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
+        if (!region) return this.leastUsedNodes;
+
+        const lowerRegion = region.toLowerCase();
+        const eligibleNodes = [...this.nodeMap.values()].filter(
+            node => node.connected && node.regions?.includes(lowerRegion)
+        );
+
+        return eligibleNodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
     }
 
     calculateLoad(node) {
-        return node.stats.cpu ? (node.stats.cpu.systemLoad / node.stats.cpu.cores) * 100 : 0;
+        if (!node?.stats?.cpu) return 0;
+        const { systemLoad, cores } = node.stats.cpu;
+        return (systemLoad / cores) * 100;
     }
 
     createConnection(options) {
         this.ensureInitialized();
-        const player = this.players.get(options.guildId);
-        if (player && player.voiceChannel) return player;
-        const node = options.region ? this.fetchRegion(options.region)[0] : this.leastUsedNodes[0];
+
+        const existingPlayer = this.players.get(options.guildId);
+        if (existingPlayer?.voiceChannel) return existingPlayer;
+
+        const node = options.region ?
+            this.fetchRegion(options.region)[0] :
+            this.leastUsedNodes[0];
+
         if (!node) throw new Error("No nodes are available");
         return this.createPlayer(node, options);
     }
 
     createPlayer(node, options) {
+        this.destroyPlayer(options.guildId);
+
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
-        player.setMaxListeners(0);
+        const weakPlayer = new WeakRef(player);
+
+        const destroyHandler = () => {
+            const playerInstance = weakPlayer.deref();
+            if (playerInstance) {
+                this.cleanupPlayer(playerInstance);
+            }
+        };
+
+        player.once("destroy", destroyHandler);
         player.connect(options);
-        player.on("destroy", () => this.cleanupPlayer(player)); // Listen for player destruction
         this.emit("playerCreate", player);
+
         return player;
     }
 
     destroyPlayer(guildId) {
         const player = this.players.get(guildId);
-        if (player) {
+        if (!player) return;
+
+        try {
             player.clearData();
+            player.removeAllListeners(); // Clear all event listeners
             player.destroy();
             this.players.delete(guildId);
             this.emit("playerDestroy", player);
+        } catch (error) {
+            console.error(`Error destroying player for guild ${guildId}:`, error);
         }
     }
-
     async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
         this.ensureInitialized();
         const requestNode = this.getRequestNode(nodes);
         const formattedQuery = this.formatQuery(query, source);
+
         try {
-            let response = await requestNode.rest.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`);
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+
+            const response = await requestNode.rest.makeRequest("GET",
+                `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`,
+                { signal: controller.signal }
+            );
+
+            clearTimeout(timeoutId);
+
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
-                response = await this.handleNoMatches(requestNode.rest, query);
+                return await this.handleNoMatches(requestNode.rest, query);
             }
             return this.constructorResponse(response, requester, requestNode);
         } catch (error) {
-            console.error("Error resolving track:", error);
-            throw new Error("Failed to resolve track");
+            if (error.name === 'AbortError') {
+                throw new Error("Request timed out");
+            }
+            throw new Error(`Failed to resolve track: ${error.message}`);
+        }
+    }
+
+    getRequestNode(nodes) {
+        if (nodes && !(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];
     }
 
     ensureInitialized() {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
     }
 
-    getRequestNode(nodes) {
-        if (nodes && (typeof nodes !== "string" && !(nodes instanceof Node))) {
-            throw new Error(`'nodes' must be a string or Node instance, but received: ${typeof nodes}`);
-        }
-        return (typeof nodes === 'string' ? this.nodeMap.get(nodes) : nodes) || this.leastUsedNodes[0];
-    }
 
     formatQuery(query, source) {
-        return /^https?:\/\//.test(query) ? query : `${source}:${query}`;
+        return URL_REGEX.test(query) ? query : `${source}:${query}`;
     }
 
     async handleNoMatches(rest, query) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+
         try {
-            const youtubeResponse = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+            const youtubeResponse = await rest.makeRequest("GET",
+                `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`,
+                { signal: controller.signal }
+            );
+
             if (["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
-                return await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
+                return await rest.makeRequest("GET",
+                    `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`,
+                    { signal: controller.signal }
+                );
             }
             return youtubeResponse;
-        } catch (error) {
-            console.error("Error handling no matches:", error);
-            throw new Error("Failed to handle no matches");
+        } finally {
+            clearTimeout(timeoutId);
         }
     }
 
@@ -171,29 +253,34 @@ class Aqua extends EventEmitter {
             loadType: response.loadType,
             exception: null,
             playlistInfo: null,
-            pluginInfo: response.pluginInfo || {},
+            pluginInfo: response.pluginInfo ?? {},
             tracks: [],
         };
-        const { loadType, data } = response;
-        if (loadType === "error" || loadType === "LOAD_FAILED") {
-            baseResponse.exception = data || response.exception;
+
+        if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
+            baseResponse.exception = response.data ?? response.exception;
             return baseResponse;
         }
-        switch (loadType) {
+
+        const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
+
+        switch (response.loadType) {
             case "track":
-                if (data) {
-                    baseResponse.tracks.push(new Track(data, requester, requestNode));
+                if (response.data) {
+                    baseResponse.tracks.push(trackFactory(response.data));
                 }
                 break;
             case "playlist":
-                baseResponse.playlistInfo = {
-                    name: data?.info?.name || data?.info?.title,
-                    ...data?.info,
-                };
-                baseResponse.tracks = (data?.tracks || []).map(track => new Track(track, requester, requestNode));
+                if (response.data?.info) {
+                    baseResponse.playlistInfo = {
+                        name: response.data.info.name ?? response.data.info.title,
+                        ...response.data.info,
+                    };
+                }
+                baseResponse.tracks = (response.data?.tracks ?? []).map(trackFactory);
                 break;
             case "search":
-                baseResponse.tracks = (data || []).map(track => new Track(track, requester, requestNode));
+                baseResponse.tracks = (response.data ?? []).map(trackFactory);
                 break;
         }
         return baseResponse;
@@ -206,38 +293,55 @@ class Aqua extends EventEmitter {
     }
 
     cleanupIdle() {
+        const now = Date.now();
         for (const [guildId, player] of this.players) {
-            if (!player.playing && !player.paused && player.queue.isEmpty()) {
+            if (!player.playing && !player.paused && player.queue.isEmpty() &&
+                (now - player.lastActivity) > this.options.idleTimeout) {
                 this.cleanupPlayer(player);
             }
         }
     }
 
     cleanupPlayer(player) {
-        if (player) {
+        if (!player) return;
+
+        try {
             player.clearData();
+            player.removeAllListeners();
             player.destroy();
             this.players.delete(player.guildId);
             this.emit("playerDestroy", player);
+        } catch (error) {
+            console.error(`Error during player cleanup: ${error.message}`);
         }
     }
 
     cleanup() {
+        // Clear all players
         for (const player of this.players.values()) {
             this.cleanupPlayer(player);
         }
+
+        // Clear all nodes
         for (const node of this.nodeMap.values()) {
             this.destroyNode(node.name || node.host);
         }
+
+        // Clear maps
         this.nodeMap.clear();
         this.players.clear();
+
+        // Clear references
         this.client = null;
         this.nodes = null;
+        this.plugins?.forEach(plugin => plugin.unload?.(this));
         this.plugins = null;
         this.options = null;
         this.send = null;
         this.version = null;
+
+        // Remove all listeners
+        this.removeAllListeners();
     }
 }
-
 module.exports = { Aqua };

package/build/structures/Connection.js

@@ -8,24 +8,11 @@ class Connection {
         this.voiceChannel = player.voiceChannel;
         this.lastUpdateTime = 0;
         this.updateThrottle = 1000;
-
-        // Bind event listeners
-        this.onPlayerMove = this.onPlayerMove.bind(this);
-        this.onPlayerLeave = this.onPlayerLeave.bind(this);
-        this.player.aqua.on("playerMove", this.onPlayerMove);
-        this.player.aqua.on("playerLeave", this.onPlayerLeave);
-    }
-
-    onPlayerMove(oldChannel, newChannel) {
-        // Handle player movement
-    }
-
-    onPlayerLeave(channelId) {
-        // Handle player leaving
     }
 
     setServerUpdate({ endpoint, token }) {
         if (!endpoint) throw new Error("Missing 'endpoint' property in VOICE_SERVER_UPDATE");
+        
         const newRegion = endpoint.split('.')[0].replace(/[0-9]/g, "");
         if (this.region !== newRegion) {
             this.updateRegion(newRegion, endpoint, token);
@@ -38,7 +25,9 @@ class Connection {
         this.region = newRegion;
         this.voice.endpoint = endpoint;
         this.voice.token = token;
+
         this.player.aqua.emit("debug", `[Player ${this.player.guildId} - CONNECTION] ${previousVoiceRegion ? `Changed Voice Region from ${previousVoiceRegion} to ${this.region}` : `Voice Server: ${this.region}`}`);
+
         if (this.player.paused) {
             this.player.pause(false);
         }
@@ -49,11 +38,13 @@ class Connection {
             this.cleanup();
             return;
         }
+
         if (this.player.voiceChannel !== data.channel_id) {
             this.player.aqua.emit("playerMove", this.player.voiceChannel, data.channel_id);
             this.player.voiceChannel = data.channel_id;
             this.voiceChannel = data.channel_id;
         }
+
         this.selfDeaf = data.self_deaf;
         this.selfMute = data.self_mute;
         this.voice.sessionId = data.session_id;
@@ -63,25 +54,29 @@ class Connection {
         const currentTime = Date.now();
         if (currentTime - this.lastUpdateTime >= this.updateThrottle) {
             this.lastUpdateTime = currentTime;
-            const data = ({
+
+            const data = {
                 voice: this.voice,
                 volume: this.player.volume,
-            });
+            };
+
             this.player.nodes.rest.updatePlayer({
                 guildId: this.player.guildId,
                 data,
+            }).catch(err => {
+                this.player.aqua.emit("apiError", "updatePlayer", err);
             });
         }
     }
 
     cleanup() {
-        this.player.aqua.off("playerMove", this.onPlayerMove);
-        this.player.aqua.off("playerLeave", this.onPlayerLeave);
         this.player.aqua.emit("playerLeave", this.player.voiceChannel);
         this.player.voiceChannel = null;
         this.voiceChannel = null;
+
         this.player.destroy();
         this.player.aqua.emit("playerDestroy", this.player);
+
         this.player = null;
         this.voice = null;
         this.region = null;