aqualink 1.7.0-beta5 → 1.8.0

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/structures/Aqua.js

@@ -6,28 +6,18 @@ 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.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)
      * @param {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
-     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely (default: false).
+     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely.
      */
-    constructor(client, nodes, options) {
+    constructor(client, nodes, options = {}) {
         super();
         this.validateInputs(client, nodes, options);
         this.client = client;
@@ -36,26 +26,46 @@ class Aqua extends EventEmitter {
         this.players = new Map();
         this.clientId = null;
         this.initiated = false;
-        this.shouldDeleteMessage = options.shouldDeleteMessage || false;
-        this.defaultSearchPlatform = options.defaultSearchPlatform || "ytsearch";
-        this.restVersion = options.restVersion || "v4";
-        this.plugins = options.plugins || [];
-        this.version = pkgVersion;
         this.options = options;
-        this.send = options.send;
-        this.autoResume = options.autoResume || false;
-        this.infiniteReconnects = options.infiniteReconnects || false;
+        this.shouldDeleteMessage = this.getOption(options, 'shouldDeleteMessage', false);
+        this.defaultSearchPlatform = this.getOption(options, 'defaultSearchPlatform', 'ytsearch');
+        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 Object.prototype.hasOwnProperty.call(options, key) ? options[key] : defaultValue;
+    }
+
+    defaultSendFunction(payload) {
+        const guild = this.client.guilds.cache.get(payload.d.guild_id);
+        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 (typeof options?.send !== "function") throw new Error("Send function is required to initialize Aqua");
+        if (!Array.isArray(nodes) || !nodes.length) {
+            throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
+        }
     }
 
     get leastUsedNodes() {
-        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) {
@@ -74,45 +84,55 @@ 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.status === "disconnected") {
+                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) {
@@ -123,10 +143,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);
     }
@@ -144,9 +164,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);
@@ -159,6 +178,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)) {
@@ -166,7 +186,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}`);
@@ -177,7 +197,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() {
@@ -190,9 +210,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) {
@@ -206,7 +228,7 @@ class Aqua extends EventEmitter {
             exception: null,
             playlistInfo: null,
             pluginInfo: response.pluginInfo ?? {},
-            tracks: [],
+            tracks: []
         };
 
         if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
@@ -214,7 +236,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) {
@@ -225,7 +248,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);
@@ -243,45 +266,10 @@ 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();
     }
 }
 

package/build/structures/Connection.js

@@ -1,100 +1,74 @@
 class Connection {
   constructor(player) {
-    this.player = player;
-    this.voice = {
-      sessionId: null,
-      endpoint: null,
-      token: null
-    };
-    this.region = null;
-    this.selfDeaf = false;
-    this.selfMute = false;
-    this.voiceChannel = player.voiceChannel;
-    this.guildId = player.guildId;
-    this.aqua = player.aqua;
-    this.nodes = player.nodes;
+      this.playerRef = new WeakRef(player);
+      const { voiceChannel, guildId, aqua, nodes } = player;
+      this.voice = {
+          sessionId: null,
+          endpoint: null,
+          token: null
+      };
+      this.region = null;
+      this.selfDeaf = false;
+      this.selfMute = false;
+      this.voiceChannel = voiceChannel;
+      this.guildId = guildId;
+      this.aqua = aqua;
+      this.nodes = nodes;
   }
 
   setServerUpdate(data) {
-    if (!data?.endpoint) {
-      throw new Error("Missing 'endpoint' property");
-    }
+      const { endpoint, token } = data || {};
+      if (!endpoint) {
+          throw new Error("Missing 'endpoint' property");
+      }
+      const regionMatch = endpoint.match(/^([a-zA-Z]+)/);
+      if (!regionMatch) return;
+      const newRegion = regionMatch[1];
 
-    const endpoint = data.endpoint;
-    const regionMatch = endpoint.match(/^([a-zA-Z]+)/);
-    if (!regionMatch) return;
-
-    const newRegion = regionMatch[1];
-    if (this.region !== newRegion) {
-      this.voice.endpoint = endpoint;
-      this.voice.token = data.token;
-      
-      const prevRegion = this.region;
-      this.region = newRegion;
-
-      this.aqua.emit(
-        "debug",
-        `[Player ${this.guildId} - CONNECTION] ${
-          prevRegion 
-            ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
-            : `Voice Server: ${newRegion}`
-        }`
-      );
-    }
-
-    this._updatePlayerVoiceData();
+      if (this.region !== newRegion) {
+          this.voice.endpoint = endpoint;
+          this.voice.token = token;
+          const prevRegion = this.region;
+          this.region = newRegion;
+          this.aqua.emit(
+              "debug",
+              `[Player ${this.guildId} - CONNECTION] ${
+                  prevRegion
+                      ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
+                      : `Voice Server: ${newRegion}`
+              }`
+          );
+      }
+      this._updatePlayerVoiceData();
   }
 
   setStateUpdate(data) {
-    const { channel_id: channelId, session_id: sessionId, self_deaf: selfDeaf, self_mute: selfMute } = data;
-
-    if (!channelId || !sessionId) {
-      this._cleanup();
-      return;
-    }
+      const { channel_id: channelId, session_id: sessionId, self_deaf: selfDeaf, self_mute: selfMute } = data || {};
+      if (!channelId || !sessionId) return;
 
-    if (this.voiceChannel !== channelId) {
-      this.aqua.emit("playerMove", this.voiceChannel, channelId);
-      this.voiceChannel = channelId;
-    }
-
-    this.selfDeaf = selfDeaf;
-    this.selfMute = selfMute;
-    this.voice.sessionId = sessionId;
+      if (this.voiceChannel !== channelId) {
+          this.aqua.emit("playerMove", this.voiceChannel, channelId);
+          this.voiceChannel = channelId;
+      }
+      this.selfDeaf = selfDeaf;
+      this.selfMute = selfMute;
+      this.voice.sessionId = sessionId;
   }
 
   async _updatePlayerVoiceData() {
-    try {
-      await this.nodes.rest.updatePlayer({
-        guildId: this.guildId,
-        data: {
-          voice: this.voice,
-          volume: this.player.volume
-        }
-      });
-    } catch (err) {
-      this.aqua.emit("apiError", "updatePlayer", err);
-    }
-  }
-
-  _cleanup() {
-    const { aqua, player, voiceChannel } = this;
-    
-    aqua.emit("playerLeave", voiceChannel);
-    
-    player.voiceChannel = null;
-    this.voiceChannel = null;
-    player.destroy();
-    
-    aqua.emit("playerDestroy", player);
-    this.player = null;
-    this.voice = null;
-    this.region = null;
-    this.selfDeaf = null;
-    this.selfMute = null;
-    this.guildId = null;
-    this.aqua = null;
-    this.nodes = null;
+      const player = this.playerRef.deref();
+      if (!player) return;
+      try {
+          await this.nodes.rest.updatePlayer({
+              guildId: this.guildId,
+              data: {
+                  voice: this.voice,
+                  volume: player.volume
+              }
+          });
+      } catch (err) {
+          this.aqua.emit("apiError", "updatePlayer", err);
+      }
   }
 }