aqualink 1.3.0 → 1.4.0

package/README.md

@@ -25,16 +25,19 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 - Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
 
-# Yay, Version 1.3.0 is released ! aqualink so cool
-
-+ Updated NODE with more methods (lavalinkLoadPercentage, freePercentage, usedPercentage) + Optimizations
-+ Rewrited Aqua.js fully (rewrite events, options, and resolve)
-+ Rewrite FetchImage (way more faster, less recourse intensive, better looking)
-+ Convert REST to Convert to undici request (experimental, around 221.29 % faster, 12436.39 by difference (requests per min))
-^^ Also is faster and more memory efficient...
-+ Updated Player with one more method (added player.skip())
-+ Remade all the cache system (players joined to vc shall don't use ram, improved cache saving and speed almost)
-+ Remade the TRACK handler (improves track handling, speed, recourses usage and cleaning)
+# Yay, Version 1.4.0 is released ! aqualink so cool
+
+- Misc changes to TRACK handler (fixed some bugs, improved overall speed and caching)
+- Reworked some stuff from FetchImage (improves speed, made the requests dynamic, remove useless caching)
+- Rewrited Player.js (Detailed: Rewrite Events (use switch, new methods), Rewrite disconnect, stop and destroy, improve cleanUp system)
+
+^^ Also fixes a lot of bugs (example: create a connection first, needs an connection, and others i forgot)
+
+- Rewrite the REST system again (uses async, dynamic requests, and re-utilizes some stuff for better speed)
+- Remade NODE manager (this brings better speed, dynamic requests, better caching system, and faster connecting speeds)
+- Rewrited the AQUA manager (this makes the resolve 2x faster, uses better functions, auto clean up system, better overall manager and faster)
+- Misc Fixes: fixed the queue looping system, improved the finished handler, better error handler, more automations
+
 
 # How to install
 

package/build/handlers/fetchImage.js

@@ -1,39 +1,49 @@
-const undici = require("undici");
+const { request } = require("undici");
+
+const YOUTUBE_URLS = [
+    (id) => `https://img.youtube.com/vi/${id}/maxresdefault.jpg`,
+    (id) => `https://img.youtube.com/vi/${id}/hqdefault.jpg`,
+    (id) => `https://img.youtube.com/vi/${id}/mqdefault.jpg`,
+    (id) => `https://img.youtube.com/vi/${id}/default.jpg`,
+];
 
 async function getImageUrl(info) {
     if (!info || !info.sourceName || !info.uri) return null;
 
     switch (info.sourceName.toLowerCase()) {
         case "spotify":
-            return (await fetchFromUrl(`https://open.spotify.com/oembed?url=${info.uri}`))?.json().then(json => json.thumbnail_url || null);
-
-        case "soundcloud":
-            return (await fetchFromUrl(`https://soundcloud.com/oembed?format=json&url=${info.uri}`))?.json().then(json => json.thumbnail_url || null);
-
+            return await fetchThumbnail(`https://open.spotify.com/oembed?url=${info.uri}`);
         case "youtube":
-            const urls = [
-                `https://img.youtube.com/vi/${info.identifier}/maxresdefault.jpg`,
-                `https://img.youtube.com/vi/${info.identifier}/hqdefault.jpg`,
-                `https://img.youtube.com/vi/${info.identifier}/mqdefault.jpg`,
-                `https://img.youtube.com/vi/${info.identifier}/default.jpg`,
-            ];
-
-            const firstValidUrl = await Promise.any(urls.map(url => fetchFromUrl(url)));
-            return firstValidUrl ? firstValidUrl.url : null;
-
+            return await fetchYouTubeThumbnail(info.identifier);
         default:
             return null;
     }
 }
 
-async function fetchFromUrl(url) {
+async function fetchThumbnail(url) {
     try {
-        const response = await undici.fetch(url, { cache: "force-cache" });
-        return response.ok ? response : null;
+        const response = await request(url, { method: "GET" });
+        if (response.ok) {
+            const json = await response.json();
+            return json.thumbnail_url || null;
+        }
+        return null;
     } catch (error) {
         console.error(`Error fetching ${url}:`, error);
         return null;
     }
 }
 
-module.exports = { getImageUrl };
+async function fetchYouTubeThumbnail(identifier) {
+    const fetchPromises = YOUTUBE_URLS.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
+    const results = await Promise.allSettled(fetchPromises);
+
+    for (const result of results) {
+        if (result.status === "fulfilled" && result.value) {
+            return result.value; 
+        }
+    }
+    return null;
+}
+
+module.exports = { getImageUrl };

package/build/structures/Aqua.js

@@ -5,57 +5,36 @@ 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.
-     * @param {string} [options.shouldDeleteMessage='none'] - Should delete your message? (true, false)
-     */
     constructor(client, nodes, options) {
         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");
-
+        this.validateInputs(client, nodes, options);
         this.client = client;
         this.nodes = nodes;
         this.nodeMap = new Map();
         this.players = new Map();
         this.clientId = null;
         this.initiated = false;
-        this.sessionId = null;
-        this.shouldDeleteMessage = options.shouldDeleteMessage || "false";
-        this.defaultSearchPlatform = options.defaultSearchPlatform || "ytmsearch";
+        this.shouldDeleteMessage = options.shouldDeleteMessage || false;
+        this.defaultSearchPlatform = options.defaultSearchPlatform || "ytsearch";
         this.restVersion = options.restVersion || "v3";
         this.plugins = options.plugins || [];
         this.version = pkgVersion;
-        this.loadType = null;
-        this.tracks = [];
-        this.playlistInfo = null;
-        this.pluginInfo = null;
         this.options = options;
-        this.send = options.send || null;
+        this.send = options.send;
+    }
+
+    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 (typeof options.send !== "function") throw new Error("Send function is required to initialize Aqua");
     }
 
-    /**
-     * 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;
@@ -65,11 +44,6 @@ class Aqua extends EventEmitter {
         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);
@@ -78,215 +52,159 @@ 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);
+        if (node) {
+            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) {
         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" && packet.d.user_id === this.clientId) player.connection.setStateUpdate(packet.d);
+        if (player) {
+            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);
+                if (packet.d.status === "disconnected") {
+                    this.cleanupPlayer(player); // Cleanup when disconnected
+                }
+            }
+        }
     }
 
-    /**
-     * 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()))
-            .sort((a, b) => {
-                const aLoad = a.stats.cpu ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100 : 0;
-                const bLoad = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
-                return aLoad - bLoad;
-            });
-        return nodesByRegion;
+        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));
     }
 
-    /**
-     * 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) throw new Error("No nodes are available");
+    calculateLoad(node) {
+        return node.stats.cpu ? (node.stats.cpu.systemLoad / node.stats.cpu.cores) * 100 : 0;
+    }
 
+    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) : this.leastUsedNodes)[0];
+        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);
     }
 
-    /**
-     * 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);
+        player.on("destroy", () => this.cleanupPlayer(player)); // Listen for player destruction
         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);
-        player.clearData();
-        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);
-        player.clearData();
         if (player) {
+            player.clearData();
             player.destroy();
             this.players.delete(guildId);
+            this.emit("playerDestroy", player);
         }
     }
 
     /**
-     * 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.
+     * Resolve a track into an array of {@link Track} objects.
+     *
+     * @param {Object} options - The options for the resolve operation.
+     * @param {string} options.query - The query to search for.
+     * @param {string} [options.source] - The source to use for the search. Defaults to the bot's default search platform.
+     * @param {GuildMember} options.requester - The member who requested the track.
+     * @param {Node[]} [options.nodes] - The nodes to prioritize for the search. Defaults to all nodes.
+     * @returns {Promise<Track[]>} The resolved tracks.
      */
     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}`);
+        this.ensureInitialized();
+        const requestNode = this.getRequestNode(nodes);
+        const formattedQuery = this.formatQuery(query, source || this.defaultSearchPlatform);
+        try {
+            let response = await requestNode.rest.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`);
+            if (["empty", "NO_MATCHES"].includes(response.loadType)) {
+                response = 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");
         }
+    }
 
-        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}`;
-        let response = await requestNode.rest.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`);
+    ensureInitialized() {
+        if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
+    }
 
-        // Fallback attempts if response loadType indicates no matches
-        if (["empty", "NO_MATCHES"].includes(response.loadType)) {
-            response = await this.handleNoMatches(requestNode.rest, query);
+    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];
+    }
 
-        return this.constructorResponse(response, requester, requestNode);
+    formatQuery(query, source) {
+        return /^https?:\/\//.test(query) ? query : `${source}:${query}`;
     }
 
-    /**
-     * 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)) {
-            response = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+        try {
+            const spotifyResponse = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
+            if (["empty", "NO_MATCHES"].includes(spotifyResponse.loadType)) {
+                return await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+            }
+            return spotifyResponse;
+        } catch (error) {
+            console.error("Error handling no matches:", error);
+            throw new Error("Failed to handle no matches");
         }
-        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.
-     * @returns {Object} The constructed response.
-     */
     constructorResponse(response, requester, requestNode) {
+        const baseResponse = {
+            loadType: response.loadType,
+            exception: null,
+            playlistInfo: null,
+            pluginInfo: response.pluginInfo || {},
+            tracks: [],
+        };
         switch (response.loadType) {
             case "track":
                 if (response.data) {
-                    return {
-                        loadType: response.loadType,
-                        exception: null,
-                        playlistInfo: null,
-                        pluginInfo: response.pluginInfo || {},
-                        tracks: [new Track(response.data, requester, requestNode)],
-                    };
+                    baseResponse.tracks.push(new Track(response.data, requester, requestNode));
                 }
                 break;
             case "playlist":
-                return {
-                    loadType: response.loadType,
-                    exception: null,
-                    playlistInfo: {
-                        name: response.data?.info?.name || response.data?.info?.title,
-                        ...response.data?.info,
-                    },
-                    pluginInfo: response.pluginInfo || {},
-                    tracks: response.data?.tracks?.map(track => new Track(track, requester, requestNode)) || [],
+                baseResponse.playlistInfo = {
+                    name: response.data?.info?.name || response.data?.info?.title,
+                    ...response.data?.info,
                 };
+                baseResponse.tracks = response.data?.tracks?.map(track => new Track(track, requester, requestNode)) || [];
+                break;
             case "search":
-                return {
-                    loadType: response.loadType,
-                    exception: null,
-                    playlistInfo: null,
-                    pluginInfo: response.pluginInfo || {},
-                    tracks: response.data?.map(track => new Track(track, requester, requestNode)),
-                };
+                baseResponse.tracks = response.data?.map(track => new Track(track, requester, requestNode)) || [];
+                break;
         }
-
-        return {
-            loadType: response.loadType,
-            exception: response.loadType === "error" ? response.loadType.data : (response.loadType === "LOAD_FAILED" ? response.loadType.exception : null),
-            playlistInfo: null,
-            pluginInfo: response.pluginInfo || {},
-            tracks: [],
-        };
+        if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
+            baseResponse.exception = response.loadType.data || response.loadType.exception;
+        }
+        return baseResponse;
     }
 
-
-    /**
-     * 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()) {
@@ -296,6 +214,15 @@ class Aqua extends EventEmitter {
             }
         }
     }
+
+    cleanupPlayer(player) {
+        if (player) {
+            player.clearData();
+            player.destroy();
+            this.players.delete(player.guildId);
+            this.emit("playerDestroy", player);
+        }
+    }
 }
 
-module.exports = { Aqua };
+module.exports = { Aqua };

package/build/structures/Node.js

@@ -26,7 +26,7 @@ class Node {
         this.resumeKey = options.resumeKey || null;
         this.resumeTimeout = options.resumeTimeout || 60;
         this.autoResume = options.autoResume || false;
-        this.reconnectTimeout = options.reconnectTimeout || 5000;
+        this.reconnectTimeout = options.reconnectTimeout || 2000;
         this.reconnectTries = options.reconnectTries || 3;
         this.reconnectAttempted = 0;
         this.lastStatsRequest = 0; // Track the last time stats were requested
@@ -42,17 +42,21 @@ class Node {
                 used: 0,
                 allocated: 0,
                 reservable: 0,
+                freePercentage: 0,
+                usedPercentage: 0,
             },
             cpu: {
                 cores: 0,
                 systemLoad: 0,
                 lavalinkLoad: 0,
+                lavalinkLoadPercentage: 0,
             },
             frameStats: {
                 sent: 0,
                 nulled: 0,
                 deficit: 0,
             },
+            ping: 0,
         };
     }
 
@@ -61,7 +65,9 @@ class Node {
     }
 
     async connect() {
-        if (this.ws) this.ws.close();
+        if (this.ws) {
+            this.ws.close();
+        }
         this.aqua.emit('debug', this.name, `Attempting to connect...`);
         this.ws = new WebSocket(this.wsUrl, { headers: this.constructHeaders() });
         this.setupWebSocketListeners();
@@ -93,15 +99,13 @@ class Node {
             this.aqua.emit('debug', `Failed to fetch info: ${err.message}`);
             this.info = null;
         }
-
         if (!this.info && !this.aqua.bypassChecks.nodeFetchInfo) {
             throw new Error(`Failed to fetch node info.`);
         }
-
         if (this.autoResume) {
             this.resumePlayers();
         }
-        this.lastStats = 0;
+        this.lastStatsRequest = Date.now();
     }
 
     async getStats() {
@@ -109,7 +113,6 @@ class Node {
         if (now - this.lastStatsRequest < 5000) {
             return this.stats; // Return cached stats if requested too soon
         }
-
         try {
             const response = await this.rest.makeRequest("GET", `/v4/stats`);
             const stats = await response.json();
@@ -137,7 +140,13 @@ class Node {
     onMessage(msg) {
         if (Array.isArray(msg)) msg = Buffer.concat(msg);
         if (msg instanceof ArrayBuffer) msg = Buffer.from(msg);
-        const payload = JSON.parse(msg.toString());
+        let payload;
+        try {
+            payload = JSON.parse(msg.toString());
+        } catch (err) {
+            this.aqua.emit('debug', `Failed to parse message: ${err.message}`);
+            return;
+        }
         if (!payload.op) return;
         this.aqua.emit("raw", "Node", payload);
         this.aqua.emit("debug", this.name, `Received update: ${JSON.stringify(payload)}`);
@@ -147,8 +156,7 @@ class Node {
     handlePayload(payload) {
         switch (payload.op) {
             case "stats":
-                this.stats = { ...this.stats, ...payload };
-                this.lastStats = Date.now();
+                this.updateStats(payload);
                 break;
             case "ready":
                 this.initializeSessionId(payload.sessionId);
@@ -161,6 +169,35 @@ class Node {
         }
     }
 
+    updateStats(payload) {
+        this.stats = {
+            ...this.stats,
+            players: payload.players || 0,
+            playingPlayers: payload.playingPlayers || 0,
+            uptime: payload.uptime || 0,
+            memory: {
+                free: payload.memory?.free || 0,
+                used: payload.memory?.used || 0,
+                allocated: payload.memory?.allocated || 0,
+                reservable: payload.memory?.reservable || 0,
+                freePercentage: payload.memory ? (payload.memory.free / payload.memory.allocated) * 100 : 0,
+                usedPercentage: payload.memory ? (payload.memory.used / payload.memory.allocated) * 100 : 0,
+            },
+            cpu: {
+                cores: payload.cpu?.cores || 0,
+                systemLoad: payload.cpu?.systemLoad || 0,
+                lavalinkLoad: payload.cpu?.lavalinkLoad || 0,
+                lavalinkLoadPercentage: payload.cpu ? (payload.cpu.lavalinkLoad / payload.cpu.cores) * 100 : 0,
+            },
+            frameStats: {
+                sent: payload.frameStats?.sent || 0,
+                nulled: payload.frameStats?.nulled || 0,
+                deficit: payload.frameStats?.deficit || 0,
+            },
+            ping: payload.ping || 0,
+        };
+    }
+
     initializeSessionId(sessionId) {
         if (this.sessionId !== sessionId) {
             this.rest.setSessionId(sessionId);
@@ -179,7 +216,6 @@ class Node {
             this.aqua.emit("nodeError", this, new Error(`Unable to connect after ${this.reconnectTries} attempts.`));
             return this.destroy();
         }
-
         setTimeout(() => {
             this.aqua.emit("nodeReconnect", this);
             this.connect();
@@ -188,8 +224,6 @@ class Node {
 
     destroy(clean = false) {
         if (clean) {
-            this.ws?.removeAllListeners();
-            this.ws = null;
             this.aqua.emit("nodeDestroy", this);
             this.aqua.nodes.delete(this.name);
             return;
@@ -198,9 +232,6 @@ class Node {
         this.aqua.players.forEach((player) => {
             if (player.node === this) player.destroy();
         });
-        this.ws?.close(1000, "destroy");
-        this.ws?.removeAllListeners();
-        this.ws = null;
         this.aqua.emit("nodeDestroy", this);
         this.aqua.nodeMap.delete(this.name);
         this.connected = false;
@@ -208,8 +239,7 @@ class Node {
 
     disconnect() {
         if (!this.connected) return;
-        this.aqua.players.forEach((player) => { if (player.node === this) { player.move() } });
-        this.ws.close(1000, "disconnect");
+        this.aqua.players.forEach((player) => { if (player.node === this) { player.move(); } });
         this.aqua.emit("nodeDisconnect", this);
         this.connected = false;
     }
@@ -229,4 +259,4 @@ class Node {
     }
 }
 
-module.exports = { Node };
+module.exports = { Node };