aqualink 1.7.0-beta6 → 1.8.1-beta1

package/README.md

@@ -11,14 +11,14 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 - Lowest CPU Usage
 - Very fast (mine take less than 1 second to load an song!)
 - 1 Player created = ~1 - 0,5 mb per player
-- Auto clean Up memory when song finishes / bot leave the vc
+- Auto clean Up memory when song finishes / bot leave the vc (Now Options supported!)
 - Plugin system
 - Lavalink v4 support (din't test v3)
-- Youtube and Spotify support
+- Youtube and Spotify support (Soundcloud, deezer, vimeo, etc also works...)
 - Minimal Requests to the lavalink server (helps the lavalink recourses!)
-- Easy player, node, aqua managing
+- Easy player, node, aqua manager 
 - Fast responses from rest and node
-- Playlist support (My mix playlists, youtube playlists, spotify playlists)
+- Playlist support (My mix playlists, youtube playlists, spotify playlists, etc)
 - Lyrics Support by Lavalink
   - https://github.com/topi314/LavaLyrics (RECOMMENDED)
   - https://github.com/DRSchlaubi/lyrics.kt (?)
@@ -29,50 +29,45 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 - Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
 
-# Real changelog for 1.7.0-beta1
-Note: Not features are widely tested / Not fully Complete
-
-- Reformated the `PLAYER` System (removed Documentation for now)
-  - Notable Changes:
-  - New WeakMap System (Properly handling, deleting, setting)
-  - Around 2x faster (by my tests, taked 0ms to resolve an song)
-  - Uses less recourses (reduced by around ~0,5mb, also less cpu instensive)
-
-- Fix Some errors in `REST`, Now destroyPlayer, etc, should work as expected.
-- Rewrited out the `TRACK` System
-  - Reduced object creation
-  - Use direct acess
-  - use direct destroy() instead of Object.assing()
-  - Separate _findMatchingTrack()
-  - Rewrite the search system, Removed useless caching, Improved speed, use traditional for ... of instead of find() - Experimental
-
-- Rewrited out the `NODE` System
-  - Implement the InfiniteReconnects Option (this will make the code try to connect to an node non-stop.)
-  - WeakMap has been replaced with statsCache (experimental)
-  - Optimized by using free, used and allocated direct.
-  - Backoff in reconnect logic (by using Math)
-  - Clear reconnectTimeoutId (prevent memory leaks)
-  - Improve the overall speed by a bit
-
-- Rewrited the `CONNECTION` System
-  - Improved the Connecting, Resolving, Reconnecting Speed (around 1,5x faster now)
-  - Improved checking
-  - Cached frequently used Code
-  - Object.assign Implemented for Batch updates
-  - Still in testing, pls report bugs
-
-- Some Additions for `AQUA`
-  - Implement the InfiniteReconnects Options
-  - Re-added our DOCS (Now autocomplete works again!)
-  - Add platforms + search system on DefaultPlatform
-
-  - Rewrited the updateVoiceState System
-  - Misc changes to createConnection
-  - Document + fix destroyPlayer
-
-- Remade some stuff in `FetchImage`
-  - Use promise.race since only first sucess is required. (will be tested, may revert to promise.any)
-  - Use map cuz its faster and more efficient than Objects.
+# Brick by brick, 1.8.0 Update (yay)
+
+- Misc changes on FetchImage (improves the overall checking and speed)
+
+- Rewrite `AQUA` module
+  - Remade the resolve logic (improves the speed by a lot)
+  - Fixes many memory usages related to nodes
+  - send is no longer required to be Applied (Applied by default now.)
+  - Remade some stuff with discord VoiceGateway
+
+- Remade `CONNECTION` module
+  - Way faster connections (Joining, reconnecting, connected, disconnect)
+  - Reduced memory overload by removing useless code
+  - Improved early Returns
+
+- Remade `NODE` module
+  - MANY fixes for the connection logic (fixes reconnection, etc)
+  - Fixed memory leaks in heartbeat system (hopefully, reduced memory by a lot.)
+  - Faster connection speed and checkings
+  - Remade the Options system, improve JSON parsing
+
+- Rewrite `PLAYER` module
+  - Many memory related fixes
+  - Improved the overall code speed by a lot
+  - Rewrote setLoop, play, shuffle, replay methods (fixes + performance)
+  - Added 2 new options: 
+
+      leaveOnEnd: false, // Optional
+
+      shouldDeleteMessage: true // Optional
+    
+  - Uses array for better performance and less memory allocation
+  - Rewrite the Events handling (speed and recourses fixes)
+
+- Updated `TRACK` module
+  - Better object handling for internal code.
+  - Removed an useless method
+
+Thats all for now, im lazy, help me fix code and improve this on github... i can't test properly 😭😭😭
 
 # How to install
 
@@ -115,15 +110,12 @@ const nodes = [
 ];
 
 const aqua = new Aqua(client, nodes, {
-    send: (payload) => {
-        const guild = client.guilds.cache.get(payload.d.guild_id);
-        if (guild) guild.shard.send(payload);
-    },
-    defaultSearchPlatform: "ytsearch",
-    restVersion: "v4"
+  defaultSearchPlatform: "ytsearch",
+  restVersion: "v4",
+  autoResume: false,
+  infiniteReconnects: true,
 });
 
-
 client.aqua = aqua;
 
 

package/build/handlers/fetchImage.js

@@ -1,19 +1,15 @@
 const { request } = require("undici");
-
 const sourceHandlers = new Map([
     ['spotify', uri => fetchThumbnail(`https://open.spotify.com/oembed?url=${uri}`)],
     ['youtube', identifier => fetchYouTubeThumbnail(identifier)]
 ]);
-
 const YOUTUBE_URL_TEMPLATE = quality => id => `https://img.youtube.com/vi/${id}/${quality}.jpg`;
 const YOUTUBE_QUALITIES = ['maxresdefault', 'hqdefault', 'mqdefault', 'default'].map(YOUTUBE_URL_TEMPLATE);
 
 async function getImageUrl(info) {
     if (!info?.sourceName || !info?.uri) return null;
-
     const handler = sourceHandlers.get(info.sourceName.toLowerCase());
     if (!handler) return null;
-
     try {
         return await handler(info.uri);
     } catch (error) {
@@ -31,18 +27,19 @@ async function fetchThumbnail(url) {
         const json = await body.json();
         return json.thumbnail_url || null;
     } catch (error) {
-        console.error('Error fetching thumbnail:', error);
+        console.error(`Error fetching thumbnail from ${url}:`, error);
         return null;
     }
 }
 
 async function fetchYouTubeThumbnail(identifier) {
-    const fetchPromises = YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
-
     try {
-        return await Promise.race(fetchPromises);
+        const thumbnail = await Promise.race(
+            YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)))
+        );
+        return thumbnail || null;
     } catch (error) {
-        console.error('Error fetching YouTube thumbnail:', error);
+        console.error('No valid YouTube thumbnail found:', error);
         return null;
     }
 }

package/build/index.d.ts

@@ -0,0 +1,80 @@
+declare module "AquaLink" {
+    export class Aqua {
+    /**
+     * @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.
+     * @param {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
+     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely.
+     */
+        constructor(client: any, nodes: Array<any>, options?: { [key: string]: any });
+        init(clientId: string): this;
+        createNode(options: { [key: string]: any }): Node;
+        createPlayer(node: Node, options: { [key: string]: any }): Player;
+        destroyPlayer(guildId: string): Promise<void>;
+        resolve(options: { query: string, source?: string, requester?: any, nodes?: any }): Promise<any>;
+        updateVoiceState(data: { d: any, t: string }): void;
+    }
+
+    export class Connection {
+        constructor(player: Player);
+        setServerUpdate(data: { endpoint: string, token: string }): void;
+        setStateUpdate(data: { channel_id: string, session_id: string, self_deaf: boolean, self_mute: boolean }): void;
+    }
+
+    export class Filters {
+        constructor(player: Player, options?: { [key: string]: any });
+        setEqualizer(bands: Array<any>): Promise<void>;
+        setKaraoke(enabled: boolean, options?: { [key: string]: any }): Promise<void>;
+        clearFilters(): Promise<void>;
+    }
+
+    export class Node {
+        constructor(aqua: Aqua, connOptions: { [key: string]: any }, options?: { [key: string]: any });
+        connect(): Promise<void>;
+        getStats(): Promise<any>;
+        destroy(clean?: boolean): void;
+    }
+
+    export class Player {
+        constructor(aqua: Aqua, nodes: any, options?: { [key: string]: any });
+        play(): Promise<void>;
+        pause(paused: boolean): this;
+        skip(): Promise<void>;
+        destroy(): void;
+    }
+
+    export class Plugin {
+        constructor(name: string);
+        load(aqua: Aqua): void;
+        unload(aqua: Aqua): void;
+    }
+
+    export class Queue extends Array {
+        add(track: any): this;
+        remove(track: any): void;
+        clear(): void;
+        shuffle(): void;
+        peek(): any;
+        toArray(): Array<any>;
+        at(index: number): any;
+        dequeue(): any;
+        isEmpty(): boolean;
+    }
+
+    export class Rest {
+        constructor(aqua: Aqua, options: { [key: string]: any });
+        makeRequest(method: string, endpoint: string, body?: any): Promise<any>;
+        getPlayers(): Promise<any>;
+        destroyPlayer(guildId: string): Promise<void>;
+    }
+
+    export class Track {
+        constructor(data: { [key: string]: any }, requester: Player, nodes: Node);
+        resolve(aqua: Aqua): Promise<Track | null>;
+    }
+}

package/build/structures/Aqua.js

@@ -1,31 +1,24 @@
-const { EventEmitter } = require("events");
-const { Node } = require("./Node");
-const { Player } = require("./Player");
-const { Track } = require("./Track");
+"use strict";
+
+const { EventEmitter } = require("node:events");
+const  Node = require("./Node");
+const  Player  = require("./Player");
+const  Track  = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const URL_REGEX = /^https?:\/\//;
 
 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. Options include:
- *     - "youtube music": "ytmsearch"
- *     - "youtube": "ytsearch"
- *     - "spotify": "spsearch"
- *     - "jiosaavn": "jssearch"
- *     - "soundcloud": "scsearch"
- *     - "deezer": "dzsearch"
- *     - "tidal": "tdsearch"
- *     - "applemusic": "amsearch"
- *     - "bandcamp": "bcsearch"
- * @param {string} [options.restVersion="v4"] - Version of the REST API.
- * @param {Array<Object>} [options.plugins=[]] - Plugins to load.
- * @param {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
- * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely (default: false).
- */
+     * @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.
+     * @param {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
+     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely.
+     */
     constructor(client, nodes, options = {}) {
         super();
         this.validateInputs(client, nodes, options);
@@ -36,22 +29,21 @@ class Aqua extends EventEmitter {
         this.clientId = null;
         this.initiated = false;
         this.options = options;
-
         this.shouldDeleteMessage = this.getOption(options, 'shouldDeleteMessage', false);
         this.defaultSearchPlatform = this.getOption(options, 'defaultSearchPlatform', 'ytsearch');
-        this.leaveOnEnd =  this.getOption(options, 'leaveOnEnd', true);
+        this.leaveOnEnd = this.getOption(options, 'leaveOnEnd', true);
         this.restVersion = this.getOption(options, 'restVersion', 'v4');
         this.plugins = this.getOption(options, 'plugins', []);
         this.version = pkgVersion;
         this.send = options.send || this.defaultSendFunction;
         this.autoResume = this.getOption(options, 'autoResume', false);
         this.infiniteReconnects = this.getOption(options, 'infiniteReconnects', false);
-        
         this.setMaxListeners(0);
+        this._leastUsedCache = { nodes: [], timestamp: 0 };
     }
 
     getOption(options, key, defaultValue) {
-        return options.hasOwnProperty(key) ? options[key] : defaultValue;
+        return Object.prototype.hasOwnProperty.call(options, key) ? options[key] : defaultValue;
     }
 
     defaultSendFunction(payload) {
@@ -59,13 +51,23 @@ class Aqua extends EventEmitter {
         if (guild) guild.shard.send(payload);
     }
 
-    validateInputs(client, nodes, options) {
+    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})`);
+        if (!Array.isArray(nodes) || !nodes.length) {
+            throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
+        }
     }
 
     get leastUsedNodes() {
-        return [...this.nodeMap.values()].filter(node => node.connected).sort((a, b) => a.rest.calls - b.rest.calls);
+        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);
+        }
+        nodes.sort((a, b) => a.rest.calls - b.rest.calls);
+        this._leastUsedCache = { nodes, timestamp: now };
+        return nodes;
     }
 
     init(clientId) {
@@ -84,45 +86,56 @@ class Aqua extends EventEmitter {
 
     createNode(options) {
         const nodeId = options.name || options.host;
-        this.destroyNode(nodeId); // Ensure no duplicate nodes
+        this.destroyNode(nodeId);
         const node = new Node(this, options, this.options);
         this.nodeMap.set(nodeId, node);
-        node.connect()
-            .then(() => this.emit("nodeCreate", node))
-            .catch(error => {
-                this.nodeMap.delete(nodeId);
-                throw error;
-            });
+        this._leastUsedCache.timestamp = 0;
+        node.connect().then(() => {
+            this.emit("nodeCreate", node);
+        }).catch(error => {
+            this.nodeMap.delete(nodeId);
+            throw error;
+        });
         return node;
     }
 
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-
-        node.disconnect()
-            .then(() => {
-                node.removeAllListeners();
-                this.nodeMap.delete(identifier);
-                this.emit("nodeDestroy", node);
-            })
-            .catch(error => console.error(`Error destroying node ${identifier}:`, error));
+        node.disconnect().then(() => {
+            node.removeAllListeners();
+            this.nodeMap.delete(identifier);
+            this._leastUsedCache.timestamp = 0;
+            this.emit("nodeDestroy", node);
+        }).catch(error => console.error(`Error destroying node ${identifier}:`, error));
     }
 
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
-        if (player && (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId))) {
-            player.connection[t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate"](d);
-            if (d.status === "disconnected") this.cleanupPlayer(player);
+        if (!player) return;
+
+        if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
+            const updateMethod = t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
+            if (player.connection && typeof player.connection[updateMethod] === "function") {
+                player.connection[updateMethod](d);
+            }
+            if (d.channel_id === null) {
+                this.cleanupPlayer(player);
+            }
         }
     }
 
     fetchRegion(region) {
         if (!region) return this.leastUsedNodes;
         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));
+        const regionNodes = [];
+        for (const node of this.nodeMap.values()) {
+            if (node.connected && node.regions?.includes(lowerRegion)) {
+                regionNodes.push(node);
+            }
+        }
+        regionNodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
+        return regionNodes;
     }
 
     calculateLoad(node) {
@@ -133,10 +146,10 @@ class Aqua extends EventEmitter {
 
     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 && 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);
     }
@@ -154,9 +167,8 @@ class Aqua extends EventEmitter {
     async destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
-
         try {
-            await player.clearData(); // Assuming clearData is an async function
+            await player.clearData();
             player.removeAllListeners();
             this.players.delete(guildId);
             this.emit("playerDestroy", player);
@@ -169,6 +181,7 @@ 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)) {
@@ -176,7 +189,7 @@ class Aqua extends EventEmitter {
             }
             return this.constructorResponse(response, requester, requestNode);
         } catch (error) {
-            if (error.name === 'AbortError') {
+            if (error.name === "AbortError") {
                 throw new Error("Request timed out");
             }
             throw new Error(`Failed to resolve track: ${error.message}`);
@@ -187,7 +200,7 @@ class Aqua extends EventEmitter {
         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];
+        return (typeof nodes === "string" ? this.nodeMap.get(nodes) : nodes) ?? this.leastUsedNodes[0];
     }
 
     ensureInitialized() {
@@ -200,9 +213,11 @@ class Aqua extends EventEmitter {
 
     async handleNoMatches(rest, query) {
         try {
-            const youtubeResponse = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+            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 await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
+                const spotifyIdentifier = `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`;
+                return await rest.makeRequest("GET", spotifyIdentifier);
             }
             return youtubeResponse;
         } catch (error) {
@@ -216,7 +231,7 @@ class Aqua extends EventEmitter {
             exception: null,
             playlistInfo: null,
             pluginInfo: response.pluginInfo ?? {},
-            tracks: [],
+            tracks: []
         };
 
         if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
@@ -224,7 +239,8 @@ class Aqua extends EventEmitter {
             return baseResponse;
         }
 
-        const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
+        const trackFactory = trackData => new Track(trackData, requester, requestNode);
+
         switch (response.loadType) {
             case "track":
                 if (response.data) {
@@ -235,7 +251,7 @@ class Aqua extends EventEmitter {
                 if (response.data?.info) {
                     baseResponse.playlistInfo = {
                         name: response.data.info.name ?? response.data.info.title,
-                        ...response.data.info,
+                        ...response.data.info
                     };
                 }
                 baseResponse.tracks = (response.data?.tracks ?? []).map(trackFactory);
@@ -253,46 +269,11 @@ class Aqua extends EventEmitter {
         return player;
     }
 
-    cleanupIdle() {
-        const now = Date.now();
-        for (const [guildId, player] of this.players) {
-            if (!player.playing && !player.paused && player.queue.isEmpty() && (now - player.lastActivity) > this.options.idleTimeout) {
-                this.cleanupPlayer(player);
-            }
-        }
-    }
-
     cleanupPlayer(player) {
-        if (!player) return;
-        try {
-            player.clearData();
-            player.removeAllListeners();
-            player.destroy();
+        if (player && this.players.has(player.guildId)) {
             this.players.delete(player.guildId);
-            this.emit("playerDestroy", player);
-        } catch (error) {
-            console.error(`Error during player cleanup: ${error.message}`);
-        }
-    }
-
-    cleanup() {
-        for (const player of this.players.values()) {
-            this.cleanupPlayer(player);
-        }
-        for (const node of this.nodeMap.values()) {
-            this.destroyNode(node.name || node.host);
         }
-        this.nodeMap.clear();
-        this.players.clear();
-        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;
-        this.removeAllListeners();
     }
 }
 
-module.exports = { Aqua };
+module.exports = Aqua