lavalink-client 2.4.5 → 2.4.6

package/README.md

@@ -808,3 +808,14 @@ if(previousTrack) {
   - Added the try to play the next track if there is no current track
     - *There was a problem trying to auto-reconnect on-Disconnect while the queue was empty, which caused the player to get destroyed by that and log the error in console "`There is no Track in the Queue, nor provided in the PlayOptions`"*
     - *Now you have to handle that case manually if you want to or set autoReconnectOnlyWithTracks to false (default)*
+
+
+## **Version 2.4.4 - Version 2.4.6**
+- `player.changeNode()` is fixed and works - thanks to @PandaIN95
+- The code got re-formatted and re-structured, no code-changes are needed to be made, but it's now cleaner & more readable in some areas
+- The same for the testbot Folder(s), also it imports lavalink-client directly, so you can just copy it and move on from it.
+- Some minor Fixess:
+  - Autoplay sometimes doesn't get called when previousAutoplay call failed.
+  - remove structuredClone so that it works in bun more stable
+  - Player Options Validation also allows single property objects
+  - Some typos were fixed

package/dist/cjs/structures/Constants.d.ts

@@ -49,6 +49,8 @@ export declare enum DestroyReasons {
     NodeReconnectFail = "NodeReconnectFail",
     Disconnected = "Disconnected",
     PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
     ReconnectAllNodes = "ReconnectAllNodes",

package/dist/cjs/structures/Constants.js

@@ -53,6 +53,8 @@ var DestroyReasons;
     DestroyReasons["NodeReconnectFail"] = "NodeReconnectFail";
     DestroyReasons["Disconnected"] = "Disconnected";
     DestroyReasons["PlayerReconnectFail"] = "PlayerReconnectFail";
+    DestroyReasons["PlayerChangeNodeFail"] = "PlayerChangeNodeFail";
+    DestroyReasons["PlayerChangeNodeFailNoEligibleNode"] = "PlayerChangeNodeFailNoEligibleNode";
     DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
     DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
     DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";

package/dist/cjs/structures/Node.d.ts

@@ -173,14 +173,20 @@ export declare class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
     /**
      * Disconnects the Node-Connection (Websocket)
      * @param disconnectReason Disconnect Reason to use when disconnecting Node

package/dist/cjs/structures/Node.js

@@ -412,32 +412,94 @@ class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason, deleteNode = true) {
+    destroy(destroyReason, deleteNode = true, movePlayers = false) {
         if (!this.connected)
             return;
         const players = this.NodeManager.LavalinkManager.players.filter(p => p.node.id === this.id);
-        if (players)
-            players.forEach(p => {
-                p.destroy(destroyReason || Constants_1.DestroyReasons.NodeDestroy);
+        if (players.size) {
+            const enableDebugEvents = this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents;
+            const handlePlayerOperations = () => {
+                if (movePlayers) {
+                    const nodeToMove = Array.from(this.NodeManager.leastUsedNodes("playingPlayers"))
+                        .find(n => n.connected && n.options.id !== this.id);
+                    if (nodeToMove) {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.changeNode(nodeToMove.options.id)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to move player ${player.guildId}: ${error.message}`);
+                            }
+                            return player.destroy(error.message ?? Constants_1.DestroyReasons.PlayerChangeNodeFail)
+                                .catch(destroyError => {
+                                if (enableDebugEvents) {
+                                    console.error(`Node > destroy() Failed to destroy player ${player.guildId} after move failure: ${destroyError.message}`);
+                                }
+                            });
+                        })));
+                    }
+                    else {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(Constants_1.DestroyReasons.PlayerChangeNodeFailNoEligibleNode)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                            }
+                        })));
+                    }
+                }
+                else {
+                    return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(destroyReason || Constants_1.DestroyReasons.NodeDestroy)
+                        .catch(error => {
+                        if (enableDebugEvents) {
+                            console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                        }
+                    })));
+                }
+            };
+            // Handle all player operations first, then clean up the socket
+            handlePlayerOperations().finally(() => {
+                this.socket.close(1000, "Node-Destroy");
+                this.socket.removeAllListeners();
+                this.socket = null;
+                this.reconnectAttempts = 1;
+                clearTimeout(this.reconnectTimeout);
+                if (deleteNode) {
+                    this.NodeManager.emit("destroy", this, destroyReason);
+                    this.NodeManager.nodes.delete(this.id);
+                    clearInterval(this.heartBeatInterval);
+                    clearTimeout(this.pingTimeout);
+                }
+                else {
+                    this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+                }
             });
-        this.socket.close(1000, "Node-Destroy");
-        this.socket.removeAllListeners();
-        this.socket = null;
-        this.reconnectAttempts = 1;
-        clearTimeout(this.reconnectTimeout);
-        if (deleteNode) {
-            this.NodeManager.emit("destroy", this, destroyReason);
-            this.NodeManager.nodes.delete(this.id);
         }
-        else {
-            this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+        else { // If no players, proceed with socket cleanup immediately
+            this.socket.close(1000, "Node-Destroy");
+            this.socket.removeAllListeners();
+            this.socket = null;
+            this.reconnectAttempts = 1;
+            clearTimeout(this.reconnectTimeout);
+            if (deleteNode) {
+                this.NodeManager.emit("destroy", this, destroyReason);
+                this.NodeManager.nodes.delete(this.id);
+                clearInterval(this.heartBeatInterval);
+                clearTimeout(this.pingTimeout);
+            }
+            else {
+                this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+            }
         }
         return;
     }
@@ -966,8 +1028,11 @@ class LavalinkNode {
         if (code === 1000 && reason === "Node-Disconnect")
             return; // manually disconnected and already emitted the event.
         this.NodeManager.emit("disconnect", this, { code, reason });
-        if (code !== 1000 || reason !== "Node-Destroy")
-            this.reconnect();
+        if (code !== 1000 || reason !== "Node-Destroy") {
+            if (this.NodeManager.nodes.has(this.id)) { // try to reconnect only when the node is still in the nodeManager.nodes list
+                this.reconnect();
+            }
+        }
     }
     /** @private util function for handling error events from websocket */
     error(error) {

package/dist/cjs/structures/NodeManager.d.ts

@@ -83,7 +83,18 @@ export declare class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
+    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
 }

package/dist/cjs/structures/NodeManager.js

@@ -196,13 +196,27 @@ class NodeManager extends events_1.EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node) {
+    deleteNode(node, movePlayers = false) {
         const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)
             throw new Error("Node was not found");
-        decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted);
+        if (movePlayers)
+            decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted, true, true);
+        else
+            decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted);
         this.nodes.delete(decodeNode.id);
         return;
     }

package/dist/esm/structures/Constants.d.ts

@@ -49,6 +49,8 @@ export declare enum DestroyReasons {
     NodeReconnectFail = "NodeReconnectFail",
     Disconnected = "Disconnected",
     PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
     ReconnectAllNodes = "ReconnectAllNodes",

package/dist/esm/structures/Constants.js

@@ -50,6 +50,8 @@ export var DestroyReasons;
     DestroyReasons["NodeReconnectFail"] = "NodeReconnectFail";
     DestroyReasons["Disconnected"] = "Disconnected";
     DestroyReasons["PlayerReconnectFail"] = "PlayerReconnectFail";
+    DestroyReasons["PlayerChangeNodeFail"] = "PlayerChangeNodeFail";
+    DestroyReasons["PlayerChangeNodeFailNoEligibleNode"] = "PlayerChangeNodeFailNoEligibleNode";
     DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
     DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
     DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";

package/dist/esm/structures/Node.d.ts

@@ -173,14 +173,20 @@ export declare class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
     /**
      * Disconnects the Node-Connection (Websocket)
      * @param disconnectReason Disconnect Reason to use when disconnecting Node

package/dist/esm/structures/Node.js

@@ -408,32 +408,94 @@ export class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason, deleteNode = true) {
+    destroy(destroyReason, deleteNode = true, movePlayers = false) {
         if (!this.connected)
             return;
         const players = this.NodeManager.LavalinkManager.players.filter(p => p.node.id === this.id);
-        if (players)
-            players.forEach(p => {
-                p.destroy(destroyReason || DestroyReasons.NodeDestroy);
+        if (players.size) {
+            const enableDebugEvents = this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents;
+            const handlePlayerOperations = () => {
+                if (movePlayers) {
+                    const nodeToMove = Array.from(this.NodeManager.leastUsedNodes("playingPlayers"))
+                        .find(n => n.connected && n.options.id !== this.id);
+                    if (nodeToMove) {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.changeNode(nodeToMove.options.id)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to move player ${player.guildId}: ${error.message}`);
+                            }
+                            return player.destroy(error.message ?? DestroyReasons.PlayerChangeNodeFail)
+                                .catch(destroyError => {
+                                if (enableDebugEvents) {
+                                    console.error(`Node > destroy() Failed to destroy player ${player.guildId} after move failure: ${destroyError.message}`);
+                                }
+                            });
+                        })));
+                    }
+                    else {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(DestroyReasons.PlayerChangeNodeFailNoEligibleNode)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                            }
+                        })));
+                    }
+                }
+                else {
+                    return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(destroyReason || DestroyReasons.NodeDestroy)
+                        .catch(error => {
+                        if (enableDebugEvents) {
+                            console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                        }
+                    })));
+                }
+            };
+            // Handle all player operations first, then clean up the socket
+            handlePlayerOperations().finally(() => {
+                this.socket.close(1000, "Node-Destroy");
+                this.socket.removeAllListeners();
+                this.socket = null;
+                this.reconnectAttempts = 1;
+                clearTimeout(this.reconnectTimeout);
+                if (deleteNode) {
+                    this.NodeManager.emit("destroy", this, destroyReason);
+                    this.NodeManager.nodes.delete(this.id);
+                    clearInterval(this.heartBeatInterval);
+                    clearTimeout(this.pingTimeout);
+                }
+                else {
+                    this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+                }
             });
-        this.socket.close(1000, "Node-Destroy");
-        this.socket.removeAllListeners();
-        this.socket = null;
-        this.reconnectAttempts = 1;
-        clearTimeout(this.reconnectTimeout);
-        if (deleteNode) {
-            this.NodeManager.emit("destroy", this, destroyReason);
-            this.NodeManager.nodes.delete(this.id);
         }
-        else {
-            this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+        else { // If no players, proceed with socket cleanup immediately
+            this.socket.close(1000, "Node-Destroy");
+            this.socket.removeAllListeners();
+            this.socket = null;
+            this.reconnectAttempts = 1;
+            clearTimeout(this.reconnectTimeout);
+            if (deleteNode) {
+                this.NodeManager.emit("destroy", this, destroyReason);
+                this.NodeManager.nodes.delete(this.id);
+                clearInterval(this.heartBeatInterval);
+                clearTimeout(this.pingTimeout);
+            }
+            else {
+                this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+            }
         }
         return;
     }
@@ -962,8 +1024,11 @@ export class LavalinkNode {
         if (code === 1000 && reason === "Node-Disconnect")
             return; // manually disconnected and already emitted the event.
         this.NodeManager.emit("disconnect", this, { code, reason });
-        if (code !== 1000 || reason !== "Node-Destroy")
-            this.reconnect();
+        if (code !== 1000 || reason !== "Node-Destroy") {
+            if (this.NodeManager.nodes.has(this.id)) { // try to reconnect only when the node is still in the nodeManager.nodes list
+                this.reconnect();
+            }
+        }
     }
     /** @private util function for handling error events from websocket */
     error(error) {

package/dist/esm/structures/NodeManager.d.ts

@@ -83,7 +83,18 @@ export declare class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
+    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
 }

package/dist/esm/structures/NodeManager.js

@@ -193,13 +193,27 @@ export class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node) {
+    deleteNode(node, movePlayers = false) {
         const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)
             throw new Error("Node was not found");
-        decodeNode.destroy(DestroyReasons.NodeDeleted);
+        if (movePlayers)
+            decodeNode.destroy(DestroyReasons.NodeDeleted, true, true);
+        else
+            decodeNode.destroy(DestroyReasons.NodeDeleted);
         this.nodes.delete(decodeNode.id);
         return;
     }

package/dist/types/structures/Constants.d.ts

@@ -49,6 +49,8 @@ export declare enum DestroyReasons {
     NodeReconnectFail = "NodeReconnectFail",
     Disconnected = "Disconnected",
     PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
     ReconnectAllNodes = "ReconnectAllNodes",

package/dist/types/structures/Node.d.ts

@@ -173,14 +173,20 @@ export declare class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
     /**
      * Disconnects the Node-Connection (Websocket)
      * @param disconnectReason Disconnect Reason to use when disconnecting Node

package/dist/types/structures/NodeManager.d.ts

@@ -83,7 +83,18 @@ export declare class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
+    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lavalink-client",
-  "version": "2.4.5",
+  "version": "2.4.6",
   "description": "Easy, flexible and feature-rich lavalink@v4 Client. Both for Beginners and Proficients.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",