aqualink 1.0.2 → 1.0.3

package/build/structures/Aqua.js

@@ -5,9 +5,17 @@ const { Track } = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 
 class Aqua extends EventEmitter {
+    /**
+     * @param {Object} client - The client instance.
+     * @param {Array<Object>} nodes - An array of node configurations.
+     * @param {Object} options - Configuration options for Aqua.
+     * @param {Function} options.send - Function to send data.
+     * @param {string} [options.defaultSearchPlatform="ytsearch"] - Default search platform.
+     * @param {string} [options.restVersion="v4"] - Version of the REST API.
+     * @param {Array<Object>} [options.plugins=[]] - Plugins to load.
+     */
     constructor(client, nodes, options) {
-      super()
-        // Input validation
+        super();
         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 (typeof options.send !== "function") throw new Error("Send function is required to initialize Aqua");
@@ -30,22 +38,36 @@ class Aqua extends EventEmitter {
         this.options = options;
         this.send = options.send || null;
     }
+
+    /**
+     * Gets the least used nodes based on call count.
+     * @returns {Array<Node>} Array of least used nodes.
+     */
     get leastUsedNodes() {
         return [...this.nodeMap.values()]
             .filter(node => node.connected)
             .sort((a, b) => a.rest.calls - b.rest.calls);
     }
 
+    /**
+     * Initializes Aqua with the provided client ID.
+     * @param {string} clientId - The client ID.
+     * @returns {Aqua} The Aqua instance.
+     */
     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));
+        return this;
     }
 
+    /**
+     * Creates a new node with the specified options.
+     * @param {Object} options - The configuration for the node.
+     * @returns {Node} The created node instance.
+     */
     createNode(options) {
         const node = new Node(this, options, this.options);
         this.nodeMap.set(options.name || options.host, node);
@@ -54,29 +76,33 @@ class Aqua extends EventEmitter {
         return node;
     }
 
+    /**
+     * Destroys a node identified by the given identifier.
+     * @param {string} identifier - The identifier of the node to destroy.
+     */
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-
         node.disconnect();
         this.nodeMap.delete(identifier);
         this.emit("nodeDestroy", node);
     }
 
+    /**
+     * Updates the voice state based on the received packet.
+     * @param {Object} packet - The packet containing voice state information.
+     */
     updateVoiceState(packet) {
-        if (!["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(packet.t)) return;
-
         const player = this.players.get(packet.d.guild_id);
         if (!player) return;
-
-        if (packet.t === "VOICE_SERVER_UPDATE") {
-            player.connection.setServerUpdate(packet.d);
-        } else if (packet.t === "VOICE_STATE_UPDATE") {
-            if (packet.d.user_id !== this.clientId) return;
-            player.connection.setStateUpdate(packet.d);
-        }
+        if (packet.t === "VOICE_SERVER_UPDATE") player.connection.setServerUpdate(packet.d);
+        else if (packet.t === "VOICE_STATE_UPDATE" && packet.d.user_id === this.clientId) player.connection.setStateUpdate(packet.d);
     }
-
+    /**
+     * Fetches nodes by the specified region.
+     * @param {string} region - The region to filter nodes by.
+     * @returns {Array<Node>} Array of nodes in the specified region.
+     */
     fetchRegion(region) {
         const nodesByRegion = [...this.nodeMap.values()]
             .filter(node => node.connected && node.regions?.includes(region?.toLowerCase()))
@@ -85,38 +111,54 @@ class Aqua extends EventEmitter {
                 const bLoad = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
                 return aLoad - bLoad;
             });
-
         return nodesByRegion;
     }
 
+    /**
+     * Creates a connection for a player.
+     * @param {Object} options - Connection options.
+     * @param {string} options.guildId - The ID of the guild.
+     * @param {string} [options.region] - The region to connect to.
+     * @returns {Player} The created player instance.
+     */
     createConnection(options) {
         if (!this.initiated) throw new Error("BRO! Get aqua on before !!!");
-        if (this.leastUsedNodes.length === 0) throw new Error("No nodes are available");
-        const node = options.region 
-            ? this.fetchRegion(options.region)[0] || this.leastUsedNodes[0]
-            : this.leastUsedNodes[0];
+        if (!this.leastUsedNodes.length) throw new Error("No nodes are available");
+
+        const node = (options.region ? this.fetchRegion(options.region) : this.leastUsedNodes)[0];
         if (!node) throw new Error("No nodes are available");
+
         return this.createPlayer(node, options);
     }
-
+    /**
+     * Creates a player using the specified node.
+     * @param {Node} node - The node to create the player with.
+     * @param {Object} options - The player options.
+     * @returns {Player} The created player instance.
+     */
     createPlayer(node, options) {
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
         player.connect(options);
-
         this.emit("playerCreate", player);
         return player;
     }
-
+    /**
+     * Destroys the player associated with the given guild ID.
+     * @param {string} guildId - The ID of the guild.
+     */
     destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
-
         player.destroy();
         this.players.delete(guildId);
         this.emit("playerDestroy", player);
     }
 
+    /**
+     * Removes the connection for the specified guild ID.
+     * @param {string} guildId - The ID of the guild.
+     */
     removeConnection(guildId) {
         const player = this.players.get(guildId);
         if (player) {
@@ -125,16 +167,23 @@ class Aqua extends EventEmitter {
         }
     }
 
+    /**
+     * Resolves a query to tracks using the available nodes.
+     * @param {Object} options - The options for resolving tracks.
+     * @param {string} options.query - The query string to resolve.
+     * @param {string} [options.source] - The source of the query.
+     * @param {Object} [options.requester] - The requester of the query.
+     * @param {string|Node} [options.nodes] - Specific nodes to use for the request.
+     * @returns {Promise<Object>} The resolved tracks and related information.
+     */
     async resolve({ query, source, requester, nodes }) {
         if (!this.initiated) throw new Error("Aqua must be initialized before resolving");
-
         if (nodes && (typeof nodes !== "string" && !(nodes instanceof Node))) {
             throw new Error(`'nodes' must be a string or Node instance, but received: ${typeof nodes}`);
         }
 
         const searchSources = source || this.defaultSearchPlatform;
         const requestNode = (typeof nodes === 'string' ? this.nodeMap.get(nodes) : nodes) || this.leastUsedNodes[0];
-
         if (!requestNode) throw new Error("No nodes are available.");
 
         const formattedQuery = /^https?:\/\//.test(query) ? query : `${searchSources}:${query}`;
@@ -149,6 +198,12 @@ class Aqua extends EventEmitter {
         return this.constructResponse();
     }
 
+    /**
+     * Handles cases where no matches were found for a query.
+     * @param {Object} rest - The REST client for making requests.
+     * @param {string} query - The original query string.
+     * @returns {Promise<Object>} The response object from the request.
+     */
     async handleNoMatches(rest, query) {
         let response = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
         if (["empty", "NO_MATCHES"].includes(response.loadType)) {
@@ -157,6 +212,12 @@ class Aqua extends EventEmitter {
         return response;
     }
 
+    /**
+     * Loads tracks from the resolved response.
+     * @param {Object} response - The response from the track resolution.
+     * @param {Object} requester - The requester of the tracks.
+     * @param {Node} requestNode - The node that handled the request.
+     */
     loadTracks(response, requester, requestNode) {
         this.tracks = [];
         if (response.loadType === "track") {
@@ -169,11 +230,14 @@ class Aqua extends EventEmitter {
         } else if (response.loadType === "search") {
             this.tracks = response.data.map(track => new Track(track, requester, requestNode));
         }
-
         this.loadType = response.loadType;
         this.pluginInfo = response.pluginInfo || {};
     }
 
+    /**
+     * Constructs the response object for the resolved tracks.
+     * @returns {Object} The constructed response.
+     */
     constructResponse() {
         return {
             loadType: this.loadType,
@@ -184,13 +248,30 @@ class Aqua extends EventEmitter {
         };
     }
 
+    /**
+     * Gets the player associated with the specified guild ID.
+     * @param {string} guildId - The ID of the guild.
+     * @returns {Player} The player instance.
+     * @throws {Error} If the player is not found.
+     */
     get(guildId) {
         const player = this.players.get(guildId);
         if (!player) throw new Error(`Player not found for guild ID: ${guildId}`);
         return player;
     }
+
+    /**
+     * Cleans up idle players and nodes to free up resources.
+     */
+    cleanupIdle() {
+        for (const [guildId, player] of this.players) {
+            if (!player.playing && !player.paused && player.queue.isEmpty()) {
+                player.destroy();
+                this.players.delete(guildId);
+                this.emit("playerDestroy", player);
+            }
+        }
+    }
 }
 
 module.exports = { Aqua };
-
-

package/build/structures/Connection.js

@@ -22,7 +22,7 @@ class Connection {
         if (!endpoint) {
             throw new Error("Missing 'endpoint' property in VOICE_SERVER_UPDATE packet/payload. Please wait or disconnect the bot from the voice channel and try again.");
         }
-        
+
         const previousVoiceRegion = this.region;
         this.voice.endpoint = endpoint;
         this.voice.token = token;
@@ -45,7 +45,10 @@ class Connection {
      * @param {boolean} data.self_mute The self-muted status of the player.
      */
     setStateUpdate({ session_id, channel_id, self_deaf, self_mute }) {
-        if (channel_id == null) {
+        if (channel_id == null || session_id == null) {
+            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);
             return;
@@ -59,7 +62,7 @@ class Connection {
 
         this.selfDeaf = self_deaf;
         this.selfMute = self_mute;
-        this.voice.sessionId = session_id || null;
+        this.voice.sessionId = session_id;
 
         this.updatePlayerVoiceData();
     }

package/build/structures/Player.js

@@ -1,12 +1,12 @@
 const { EventEmitter } = require("events");
 const { Connection } = require("./Connection");
 const { Queue } = require("./Queue");
-const {Filters} = require("./Filters");
+const { Filters } = require("./Filters");
 
 class Player extends EventEmitter {
     /**
      * @param {Object} aqua - The Aqua instance.
-     * @param {Object} node - The node instance.
+     * @param {Object} nodes - The node instances.
      * @param {Object} options - Configuration options for the player.
      * @param {string} options.guildId - The ID of the guild.
      * @param {string} options.textChannel - The ID of the text channel.
@@ -40,24 +40,33 @@ class Player extends EventEmitter {
         this.timestamp = 0;
         this.ping = 0;
         this.isAutoplay = false;
+
         this.setupEventListeners();
     }
 
+    /**
+     * Sets up event listeners for player events.
+     */
     setupEventListeners() {
-        this.on("playerUpdate", this.onPlayerUpdate);
+        this.on("playerUpdate", this.onPlayerUpdate.bind(this));
         this.on("event", this.handleEvent.bind(this));
     }
 
+    /**
+     * Handles player update events.
+     * @param {Object} packet - The packet containing the player update data.
+     */
     onPlayerUpdate(packet) {
         const { state } = packet;
         this.connected = state.connected;
         this.position = state.position;
         this.ping = state.ping;
         this.timestamp = state.time;
+
     }
 
     /**
-     * Get the previous track.
+     * Gets the previous track.
      * @returns {Object|null} The previous track or null if none exists.
      */
     get previous() {
@@ -65,7 +74,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Add a track to the previous tracks list.
+     * Adds a track to the previous tracks list.
      * @param {Object} track - The track object to add.
      */
     addToPreviousTrack(track) {
@@ -73,13 +82,12 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Play the next track in the queue.
+     * Plays the next track in the queue.
      * @returns {Promise<Player>} The player instance.
      * @throws {Error} If the player is not connected.
      */
     async play() {
         if (!this.connected) throw new Error("Player connection is not established. Please connect first.");
-
         this.current = this.queue.shift();
         if (!this.current) return this;
 
@@ -90,19 +98,12 @@ class Player extends EventEmitter {
         this.playing = true;
         this.position = 0;
 
-        // Log info for debugging
         this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
-
-        await this.nodes.rest.updatePlayer({
-            guildId: this.guildId,
-            data: {
-                track: { encoded: this.current.track },
-            },
-        });
+        await this.updatePlayer({ track: { encoded: this.current.track } });
         return this;
     }
     /**
-     * Connect to the voice channel.
+     * Connects the player to the voice channel.
      * @param {Object} [options=this] - Connection options.
      * @param {string} options.guildId - The ID of the guild.
      * @param {string} options.voiceChannel - The ID of the voice channel.
@@ -121,18 +122,20 @@ class Player extends EventEmitter {
         this.connected = true;
         this.aqua.emit("debug", this.guildId, `Player has connected to voice channel: ${voiceChannel}.`);
     }
+
     /**
-     * Disconnect the player from the voice channel.
+     * Disconnects the player from the voice channel and cleans up resources.
      * @returns {Promise<Player>} The player instance.
      */
     async destroy() {
         await this.updatePlayer({ track: null });
         this.connected = false;
+        this.clearData(); // Clear data when destroyed
         this.aqua.emit("debug", this.guildId, "Player has disconnected from voice channel.");
     }
 
     /**
-     * Pause or resume the player.
+     * Pauses or resumes the player.
      * @param {boolean} paused - Whether to pause the player.
      * @returns {Promise<Player>} The player instance.
      */
@@ -143,7 +146,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Seek to a specific position in the current track.
+     * Seeks to a specific position in the current track.
      * @param {number} position - The position in milliseconds to seek to.
      * @returns {Promise<Player>} The player instance.
      */
@@ -154,7 +157,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Stop playback and clear the current track.
+     * Stops playback and clears the current track.
      * @returns {Promise<Player>} The player instance.
      */
     async stop() {
@@ -163,7 +166,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Set the volume of the player.
+     * Sets the volume of the player.
      * @param {number} volume - The volume level (0-200).
      * @returns {Promise<Player>} The player instance.
      * @throws {Error} If the volume is out of bounds.
@@ -176,7 +179,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Set the loop mode for the player.
+     * Sets the loop mode for the player.
      * @param {string} mode - The loop mode ('none', 'track', 'queue').
      * @returns {Promise<Player>} The player instance.
      * @throws {Error} If the loop mode is invalid.
@@ -189,7 +192,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Send data to the player.
+     * Sends data to the player.
      * @param {Object} data - The data to send.
      * @returns {Promise<Player>} The player instance.
      */
@@ -199,7 +202,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Set the text channel for the player.
+     * Sets the text channel for the player.
      * @param {string} channel - The ID of the text channel.
      * @returns {Promise<Player>} The player instance.
      */
@@ -209,7 +212,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Set the voice channel for the player.
+     * Sets the voice channel for the player.
      * @param {string} channel - The ID of the voice channel.
      * @returns {Promise<Player>} The player instance.
      * @throws {TypeError} If the channel is not a string.
@@ -221,18 +224,12 @@ class Player extends EventEmitter {
             throw new ReferenceError(`Player is already connected to ${channel}.`);
         }
         this.voiceChannel = channel;
-        await this.connect({
-            deaf: this.deaf,
-            guildId: this.guildId,
-            voiceChannel: this.voiceChannel,
-            textChannel: this.textChannel,
-            mute: this.mute,
-        });
+        await this.connect({ deaf: this.deaf, guildId: this.guildId, voiceChannel: this.voiceChannel, mute: this.mute });
         return this;
     }
 
     /**
-     * Disconnect the player from the voice channel.
+     * Disconnects the player from the voice channel.
      * @returns {Promise<Player>} The player instance.
      */
     async disconnect() {
@@ -242,12 +239,13 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle events from the player.
+     * Handles events from the player.
      * @param {Object} payload - The event payload.
      */
     async handleEvent(payload) {
         const player = this.aqua.players.get(payload.guildId);
         if (!player) return;
+
         switch (payload.type) {
             case "TrackStartEvent":
                 this.trackStart(player, payload);
@@ -271,7 +269,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle track start events.
+     * Handles track start events.
      * @param {Object} player - The player instance.
      * @param {Object} payload - The event payload.
      */
@@ -282,7 +280,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle track end events.
+     * Handles track end events.
      * @param {Object} player - The player instance.
      * @param {Object} payload - The event payload.
      */
@@ -315,7 +313,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle track error events.
+     * Handles track error events.
      * @param {Object} player - The player instance.
      * @param {Object} payload - The event payload.
      */
@@ -325,7 +323,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle track stuck events.
+     * Handles track stuck events.
      * @param {Object} player - The player instance.
      * @param {Object} payload - The event payload.
      */
@@ -335,7 +333,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle socket closed events.
+     * Handles socket closed events.
      * @param {Object} player - The player instance.
      * @param {Object} payload - The event payload.
      */
@@ -354,7 +352,7 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Send data to the Aqua instance.
+     * Sends data to the Aqua instance.
      * @param {Object} data - The data to send.
      */
     send(data) {
@@ -362,34 +360,34 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Set a custom value in the player's data.
+     * Sets a custom value in the player's data.
      * @param {string} key - The key of the data.
      * @param {any} value - The value to set.
      */
     set(key, value) {
-        this.data[key] = value;
+        this.data.set(key, value); // Use WeakMap to set data
     }
 
     /**
-     * Get a custom value from the player's data.
+     * Gets a custom value from the player's data.
      * @param {string} key - The key of the data.
      * @returns {any} The value associated with the key.
      */
     get(key) {
-        return this.data[key];
+        return this.data.get(key); // Use WeakMap to get data
     }
 
     /**
-     * Clear all custom data set on the player.
+     * Clears all custom data set on the player.
      * @returns {Player} The player instance.
      */
     clearData() {
-        this.data = {}; // Clear all custom data efficiently
+        this.data = {} // Clear all custom data efficiently
         return this;
     }
 
     /**
-     * Update the player with new data.
+     * Updates the player with new data.
      * @param {Object} data - The data to update the player with.
      * @returns {Promise<void>}
      */
@@ -401,15 +399,23 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Handle unknown events from the node.
+     * Handles unknown events from the node.
      * @param {Object} payload - The event payload.
      */
     handleUnknownEvent(payload) {
         const error = new Error(`Node encountered an unknown event: '${payload.type}'`);
         this.aqua.emit("nodeError", this, error);
     }
+
+    /**
+     * Cleans up the player when idle.
+     * @returns {Promise<void>}
+     */
+    async cleanup() {
+        if (!this.playing && !this.paused && this.queue.isEmpty()) {
+            await this.destroy(); 
+        }
+    }
 }
 
 module.exports = { Player };
-
-

package/build/structures/Queue.js

@@ -26,9 +26,8 @@ class Queue extends Array {
      * @param {*} track - The track to add.
      */
     add(track) {
-        if (track) {
-            this.push(track);
-        }
+        this.push(track);
+        return this;
     }
 
     /**
@@ -79,6 +78,15 @@ class Queue extends Array {
         return this.shift(); // Removes and returns the first element
     }
 
+    // Check if the queue is empty
+    /**
+     * Check if the queue is empty.
+     * @returns {boolean} Whether the queue is empty.
+     */
+    isEmpty() {
+        return this.length === 0;
+    }
+
     /**
      * Add multiple tracks to the queue.
      * @param {Array} tracks - The tracks to add.
@@ -88,6 +96,8 @@ class Queue extends Array {
             this.push(...tracks);
         }
     }
+
 }
 
 module.exports = { Queue };
+

package/build/structures/Rest.js

@@ -9,6 +9,10 @@ class Rest {
         this.password = options.password;
         this.version = options.restVersion;
         this.calls = 0;
+        this.queue = []; 
+        this.maxQueueSize = options.maxQueueSize || 100; 
+        this.maxConcurrentRequests = options.maxConcurrentRequests || 5; 
+        this.activeRequests = 0; 
     }
 
     setSessionId(sessionId) {
@@ -20,24 +24,20 @@ class Rest {
             "Content-Type": "application/json",
             Authorization: this.password,
         };
-
         const requestOptions = {
             method,
             headers,
             body: body ? JSON.stringify(body) : null,
         };
-
         try {
             const response = await undiciFetch(`${this.url}${endpoint}`, requestOptions);
             this.calls++;
             const data = await this.parseResponse(response);
-
             this.aqua.emit("apiResponse", endpoint, response);
             this.aqua.emit(
                 "debug",
                 `[Rest] ${method} ${endpoint} ${body ? `body: ${JSON.stringify(body)}` : ""} -> Status Code: ${response.status} Response: ${nodeUtil.inspect(data)}`
             );
-
             return includeHeaders ? { data, headers: response.headers } : data;
         } catch (error) {
             throw new Error(`Network error during request: ${method} ${this.url}${endpoint}`, { cause: error });
@@ -50,18 +50,15 @@ class Rest {
 
     async updatePlayer(options) {
         const requestBody = { ...options.data };
-
         if ((requestBody.track && requestBody.track.encoded && requestBody.track.identifier) ||
             (requestBody.encodedTrack && requestBody.identifier)) {
             throw new Error(`Cannot provide both 'encoded' and 'identifier' for track in Update Player Endpoint`);
         }
-
         if (this.version === "v3" && options.data?.track) {
             const { track } = requestBody;
             delete requestBody.track;
             Object.assign(requestBody, track.encoded ? { encodedTrack: track.encoded } : { identifier: track.identifier });
         }
-
         return this.makeRequest("PATCH", `/${this.version}/sessions/${this.sessionId}/players/${options.guildId}?noReplace=false`, requestBody);
     }
 
@@ -85,7 +82,6 @@ class Rest {
         if (this.version === "v3") {
             return this.makeRequest("GET", `/${this.version}/stats`);
         }
-
         return this.makeRequest("GET", `/${this.version}/stats/all`);
     }
 
@@ -105,7 +101,6 @@ class Rest {
         if (response.status === 204) {
             return null;
         }
-
         try {
             const contentType = response.headers.get("Content-Type");
             return await response[contentType.includes("text/plain") ? "text" : "json"]();
@@ -114,6 +109,44 @@ class Rest {
             return null;
         }
     }
+
+    /**
+     * Adds a request to the queue and processes it.
+     * @param {function} requestFunction - The request function to execute.
+     */
+    async queueRequest(requestFunction) {
+        if (this.queue.length >= this.maxQueueSize) {
+            this.aqua.emit("debug", "[Rest] Queue is full, discarding oldest request.");
+            this.queue.shift(); 
+        }
+        this.queue.push(requestFunction);
+        this.processQueue();
+    }
+
+    /**
+     * Processes the queue of requests with concurrency control.
+     */
+    async processQueue() {
+        while (this.activeRequests < this.maxConcurrentRequests && this.queue.length > 0) {
+            const requestFunction = this.queue.shift(); 
+            this.activeRequests++; 
+            try {
+                await requestFunction(); 
+            } catch (error) {
+                this.aqua.emit("error", error);
+            } finally {
+                this.activeRequests--; 
+                this.processQueue();
+            }
+        }
+    }
+
+    /**
+     * Cleans up resources related to the queue.
+     */
+    cleanupQueue() {
+        this.queue = []; 
+    }
 }
 
 module.exports = { Rest };

package/build/structures/Track.js

@@ -16,12 +16,7 @@ class Track {
         this.info = data.info;
         this.requester = requester;
         this.nodes = nodes;
-
-        if (data.encoded) {
-            this.track = data.encoded;
-        } else {
-            this.track = Buffer.from(data.track, "base64").toString("utf8");
-        }
+        this.track = data.encoded || Buffer.from(data.track, "base64").toString("utf8");
     }
 
     /**
@@ -29,8 +24,7 @@ class Track {
      * @returns {string|null}
      */
     resolveThumbnail(thumbnail) {
-        if (!thumbnail) return null;
-        return thumbnail.startsWith("http") ? thumbnail : getImageUrl(thumbnail, this.nodes);
+        return thumbnail ? (thumbnail.startsWith("http") ? thumbnail : getImageUrl(thumbnail, this.nodes)) : null;
     }
 
     /**
@@ -40,16 +34,9 @@ class Track {
     async resolve(aqua) {
         const query = `${this.info.author} - ${this.info.title}`;
         const result = await aqua.resolve({ query, source: aqua.options.defaultSearchPlatform, requester: this.requester, node: this.nodes });
-
-        if (!result || !result.tracks.length) return null;
-
-        const matchedTrack = this.findBestMatch(result.tracks);
-        if (matchedTrack) {
-            this.updateTrackInfo(matchedTrack);
-            return this;
-        }
-        this.updateTrackInfo(result.tracks[0]);
-        return this;
+        const matchedTrack = result?.tracks?.length ? this.findBestMatch(result.tracks) || result.tracks[0] : null;
+        if (matchedTrack) this.updateTrackInfo(matchedTrack);
+        return matchedTrack ? this : null;
     }
 
     /**
@@ -57,23 +44,16 @@ class Track {
      * @returns {Track|null}
      */
     findBestMatch(tracks) {
-        const titleLower = this.info.title.toLowerCase();
-        const authorLower = this.info.author.toLowerCase();
-        const exactMatch = tracks.find(track =>
-            track.info.author.toLowerCase() === authorLower && track.info.title.toLowerCase() === titleLower
-        );
-        if (exactMatch) return exactMatch;
-        const authorMatch = tracks.find(track => track.info.author.toLowerCase() === authorLower);
-        if (authorMatch) return authorMatch;
-        const titleMatch = tracks.find(track => track.info.title.toLowerCase() === titleLower);
-        if (titleMatch) return titleMatch;
-        if (this.info.length) {
-            return tracks.find(track =>
-                track.info.length >= (this.info.length - 2000) && track.info.length <= (this.info.length + 2000)
-            );
-        }
-
-        return null;
+        const { title, author, length } = this.info;
+        const titleLower = title.toLowerCase();
+        const authorLower = author.toLowerCase();
+        return tracks.find(track => {
+            const { author, title, length: tLength } = track.info;
+            return (author.toLowerCase() === authorLower && title.toLowerCase() === titleLower) ||
+                   (author.toLowerCase() === authorLower) ||
+                   (title.toLowerCase() === titleLower) ||
+                   (length && tLength >= (length - 2000) && tLength <= (length + 2000));
+        });
     }
 
     /**
@@ -88,9 +68,7 @@ class Track {
      * @private
      */
     cleanup() {
-        this.rawData = null;
-        this.track = null;
-        this.info = null;
+        this.rawData = this.track = this.info = null;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
   "scripts": {