lavalink-client 2.3.1 → 2.3.4

package/README.md

@@ -189,28 +189,10 @@ client.lavalink = new LavalinkManager({
 
 ## How to do resuming
 
-```js
-// 1. while the player is playing, make sure to enable it:
-const durationToKeepPlayingInMS = 600_000;
-await player.node.updateSession(true, durationToKeepPlayingInMS);
-```
-
-```js
-// 2. make sure to have an eventlistener for resuming events somewhere
-client.lavalink.nodeManager.on("resumed", (node, payload, fetchedPlayers) => {
-  // create players:
-  for(const fetchedPlayer of fetchedPlayers) {
-    const player = client.lavalink.createPlayer({
-       guildId: fetchedPlayer.guildId,
-    });
-    player.setVolume(fetchedPlayer.volume);
-    // and apply other things (e.g. paused, voice, filters, state, ...) (stuff like vc channel, text channel you need to store somewhere)
-    await player.queue.utils.sync(); // only works with a queuestore
-    // you can now overwride the player.queue.current track from the fetchedPlayer, or use the one from the queue.uztils.sync function
-    // continue with your resuming code...
-  }
-})
-```
+1. You need to enable resuming on a __connected__ Lavalink node : **` node.updateSession(true, 360e3) `**
+2. The NodeManager#resumed event will emit when the node resumes, you retrieves all fetchedPlayers (fetched by the client), and thus all you need to do is re-create all player instances (and possibly the queues too)
+  - For that is the queuestore useful
+  - To save the playerData you can utilize smt like playerUpdate event.
 
 ## Resuming full Example
 Full code sample: can be found on the [Testbot in here](https://github.com/Tomato6966/lavalink-client/blob/main/testBot/Utils/handleResuming.ts)
@@ -504,3 +486,34 @@ if(previousTrack) {
   - *This is technically better than skipping to a track but i wanted to point it out.*
     - You can play with clientTrack like this: `player.play({ clientTrack: searchResult.tracks[0] })`
     - You can play with just track like this: `player.play({ track: { encoded: "base64string..." }, requester: interaction.user })`
+
+
+## **Version 2.3.1**
+
+- Fixed Export, where types of Manager weren't exported correctly
+- Fixed Dist Folder containing old, left over not needed files
+
+## **Version 2.3.2**
+- Added Missing function calls for the QueueWatcher of tracksRemoved within the queue.remove() function:
+- Added new DestroyReasons:
+    - TrackStuckMaxTracksErroredPerTime
+    - TrackErrorMaxTracksErroredPerTime
+- Added new Prevention Systems for CrashbackLoop recognitions:
+    - `this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime`:
+        - object: `{ threshold: number, maxAmount: number }` (set threshold to 0 or maxAmount to -1 to disable)
+        - Default: `{ threshold: 10_000, maxAmount: 3 }`
+        - If there are trackError or trackStuck Events > maxAmount within the given treshhold, the player will be destroyed prevent more errors and thus potential ratelimits.
+    - `this.NodeManager.LavalinkManager.options.playerOptions.minAutoPlayMs`:
+        - number: `10_000` (default)
+        - If there is an AutoplayFunction, and it get's executed before that threshold, than it won't trigger the autoplay function again. *(this is ignored for when the player is skipped)*
+        - This prevents autoplays from happeneing on a crashbackloop
+        - Set to `0` to disable
+- **Added new Event "debug":**
+    - `LavalinkManager#debug(event:DebugEvents, data:{ state: "log" | "warn" | "error", message:string, functionLayer:string, error?:Error })`
+    - This function Event will emit, when the following option is set to **` true `**: `LavalinkManager.options.advancedOptions.enableDebugEvents`
+    - You can use the **` DebugEvents `**  Enum to listen to specific events and only show those you care
+    - You can filter for the **` data.state `** to only show the certain log-level state
+    - The **` functionLayer `** string will show you where the debug event was triggered from
+    - The **` message `** string will show what is debugged
+    - The **` error `** object will show you the error that happened, if there was one.
+    - *This took quite some time to code, and i am sure there are still many logs you might want, feel free to open an issue or commit with an PR, if you think something is missing!*

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -1,4 +1,45 @@
 import type { AudioOutputs, ChannelMixFilter, EQBand } from "./Types/Filters";
+export declare enum DebugEvents {
+    SetSponsorBlock = "SetSponsorBlock",
+    DeleteSponsorBlock = "DeleteSponsorBlock",
+    TrackEndReplaced = "TrackEndReplaced",
+    AutoplayNoSongsAdded = "AutoplayNoSongsAdded",
+    AutoplayThresholdSpamLimiter = "AutoplayThresholdSpamLimiter",
+    TriggerQueueEmptyInterval = "TriggerQueueEmptyInterval",
+    QueueEnded = "QueueEnded",
+    TrackStartNewSongsOnly = "TrackStartNewSongsOnly",
+    TrackStartNoTrack = "TrackStartNoTrack",
+    ResumingFetchingError = "ResumingFetchingError",
+    PlayerUpdateNoPlayer = "PlayerUpdateNoPlayer",
+    PlayerUpdateFilterFixApply = "PlayerUpdateFilterFixApply",
+    PlayerUpdateSuccess = "PlayerUpdateSuccess",
+    HeartBeatTriggered = "HeartBeatTriggered",
+    NoSocketOnDestroy = "NoSocketOnDestroy",
+    SocketTerminateHeartBeatTimeout = "SocketTerminateHeartBeatTimeout",
+    TryingConnectWhileConnected = "TryingConnectWhileConnected",
+    LavaSearchNothingFound = "LavaSearchNothingFound",
+    SearchNothingFound = "SearchNothingFound",
+    ValidatingBlacklistLinks = "ValidatingBlacklistLinks",
+    ValidatingWhitelistLinks = "ValidatingWhitelistLinks",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime",
+    PlayerDestroyingSomewhereElse = "PlayerDestroyingSomewhereElse",
+    PlayerCreateNodeNotFound = "PlayerCreateNodeNotFound",
+    PlayerPlayQueueEmptyTimeoutClear = "PlayerPlayQueueEmptyTimeoutClear",
+    PlayerPlayWithTrackReplace = "PlayerPlayWithTrackReplace",
+    PlayerPlayUnresolvedTrack = "PlayerPlayUnresolvedTrack",
+    PlayerPlayUnresolvedTrackFailed = "PlayerPlayUnresolvedTrackFailed",
+    PlayerVolumeAsFilter = "PlayerVolumeAsFilter",
+    BandcampSearchLokalEngine = "BandcampSearchLokalEngine",
+    PlayerChangeNode = "PlayerChangeNode",
+    BuildTrackError = "BuildTrackError",
+    TransformRequesterFunctionFailed = "TransformRequesterFunctionFailed",
+    GetClosestTrackFailed = "GetClosestTrackFailed",
+    PlayerDeleteInsteadOfDestroy = "PlayerDeleteInsteadOfDestroy",
+    FailedToConnectToNodes = "FailedToConnectToNodes",
+    NoAudioDebug = "NoAudioDebug",
+    PlayerAutoReconnect = "PlayerAutoReconnect"
+}
 export declare enum DestroyReasons {
     QueueEmpty = "QueueEmpty",
     NodeDestroy = "NodeDestroy",
@@ -9,7 +50,9 @@ export declare enum DestroyReasons {
     PlayerReconnectFail = "PlayerReconnectFail",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
-    ReconnectAllNodes = "ReconnectAllNodes"
+    ReconnectAllNodes = "ReconnectAllNodes",
+    TrackErrorMaxTracksErroredPerTime = "TrackErrorMaxTracksErroredPerTime",
+    TrackStuckMaxTracksErroredPerTime = "TrackStuckMaxTracksErroredPerTime"
 }
 export declare const validSponsorBlocks: string[];
 /**  The audio Outputs Data map declaration */

package/dist/cjs/structures/Constants.js

@@ -1,6 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EQList = exports.audioOutputsData = exports.validSponsorBlocks = exports.DestroyReasons = void 0;
+exports.EQList = exports.audioOutputsData = exports.validSponsorBlocks = exports.DestroyReasons = exports.DebugEvents = void 0;
+var DebugEvents;
+(function (DebugEvents) {
+    DebugEvents["SetSponsorBlock"] = "SetSponsorBlock";
+    DebugEvents["DeleteSponsorBlock"] = "DeleteSponsorBlock";
+    DebugEvents["TrackEndReplaced"] = "TrackEndReplaced";
+    DebugEvents["AutoplayNoSongsAdded"] = "AutoplayNoSongsAdded";
+    DebugEvents["AutoplayThresholdSpamLimiter"] = "AutoplayThresholdSpamLimiter";
+    DebugEvents["TriggerQueueEmptyInterval"] = "TriggerQueueEmptyInterval";
+    DebugEvents["QueueEnded"] = "QueueEnded";
+    DebugEvents["TrackStartNewSongsOnly"] = "TrackStartNewSongsOnly";
+    DebugEvents["TrackStartNoTrack"] = "TrackStartNoTrack";
+    DebugEvents["ResumingFetchingError"] = "ResumingFetchingError";
+    DebugEvents["PlayerUpdateNoPlayer"] = "PlayerUpdateNoPlayer";
+    DebugEvents["PlayerUpdateFilterFixApply"] = "PlayerUpdateFilterFixApply";
+    DebugEvents["PlayerUpdateSuccess"] = "PlayerUpdateSuccess";
+    DebugEvents["HeartBeatTriggered"] = "HeartBeatTriggered";
+    DebugEvents["NoSocketOnDestroy"] = "NoSocketOnDestroy";
+    DebugEvents["SocketTerminateHeartBeatTimeout"] = "SocketTerminateHeartBeatTimeout";
+    DebugEvents["TryingConnectWhileConnected"] = "TryingConnectWhileConnected";
+    DebugEvents["LavaSearchNothingFound"] = "LavaSearchNothingFound";
+    DebugEvents["SearchNothingFound"] = "SearchNothingFound";
+    DebugEvents["ValidatingBlacklistLinks"] = "ValidatingBlacklistLinks";
+    DebugEvents["ValidatingWhitelistLinks"] = "ValidatingWhitelistLinks";
+    DebugEvents["TrackErrorMaxTracksErroredPerTime"] = "TrackErrorMaxTracksErroredPerTime";
+    DebugEvents["TrackStuckMaxTracksErroredPerTime"] = "TrackStuckMaxTracksErroredPerTime";
+    DebugEvents["PlayerDestroyingSomewhereElse"] = "PlayerDestroyingSomewhereElse";
+    DebugEvents["PlayerCreateNodeNotFound"] = "PlayerCreateNodeNotFound";
+    DebugEvents["PlayerPlayQueueEmptyTimeoutClear"] = "PlayerPlayQueueEmptyTimeoutClear";
+    DebugEvents["PlayerPlayWithTrackReplace"] = "PlayerPlayWithTrackReplace";
+    DebugEvents["PlayerPlayUnresolvedTrack"] = "PlayerPlayUnresolvedTrack";
+    DebugEvents["PlayerPlayUnresolvedTrackFailed"] = "PlayerPlayUnresolvedTrackFailed";
+    DebugEvents["PlayerVolumeAsFilter"] = "PlayerVolumeAsFilter";
+    DebugEvents["BandcampSearchLokalEngine"] = "BandcampSearchLokalEngine";
+    DebugEvents["PlayerChangeNode"] = "PlayerChangeNode";
+    DebugEvents["BuildTrackError"] = "BuildTrackError";
+    DebugEvents["TransformRequesterFunctionFailed"] = "TransformRequesterFunctionFailed";
+    DebugEvents["GetClosestTrackFailed"] = "GetClosestTrackFailed";
+    DebugEvents["PlayerDeleteInsteadOfDestroy"] = "PlayerDeleteInsteadOfDestroy";
+    DebugEvents["FailedToConnectToNodes"] = "FailedToConnectToNodes";
+    DebugEvents["NoAudioDebug"] = "NoAudioDebug";
+    DebugEvents["PlayerAutoReconnect"] = "PlayerAutoReconnect";
+})(DebugEvents || (exports.DebugEvents = DebugEvents = {}));
 var DestroyReasons;
 (function (DestroyReasons) {
     DestroyReasons["QueueEmpty"] = "QueueEmpty";
@@ -13,6 +55,8 @@ var DestroyReasons;
     DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
     DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
     DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";
+    DestroyReasons["TrackErrorMaxTracksErroredPerTime"] = "TrackErrorMaxTracksErroredPerTime";
+    DestroyReasons["TrackStuckMaxTracksErroredPerTime"] = "TrackStuckMaxTracksErroredPerTime";
 })(DestroyReasons || (exports.DestroyReasons = DestroyReasons = {}));
 ;
 exports.validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];

package/dist/cjs/structures/LavalinkManager.js

@@ -92,9 +92,15 @@ class LavalinkManager extends events_1.EventEmitter {
                 volumeDecrementer: options?.playerOptions?.volumeDecrementer ?? 1,
                 requesterTransformer: options?.playerOptions?.requesterTransformer ?? null,
                 useUnresolvedData: options?.playerOptions?.useUnresolvedData ?? false,
+                minAutoPlayMs: options?.playerOptions?.minAutoPlayMs ?? 10000,
+                maxErrorsPerTime: {
+                    threshold: options?.playerOptions?.maxErrorsPerTime?.threshold ?? 35000,
+                    maxAmount: options?.playerOptions?.maxErrorsPerTime?.maxAmount ?? 3
+                }
             },
             linksWhitelist: options?.linksWhitelist ?? [],
             linksBlacklist: options?.linksBlacklist ?? [],
+            linksAllowed: options?.linksAllowed ?? true,
             autoSkip: options?.autoSkip ?? true,
             autoSkipOnResolveError: options?.autoSkipOnResolveError ?? true,
             emitNewSongsOnly: options?.emitNewSongsOnly ?? false,
@@ -104,6 +110,7 @@ class LavalinkManager extends events_1.EventEmitter {
                 queueStore: options?.queueOptions?.queueStore ?? new Queue_1.DefaultQueueStore(),
             },
             advancedOptions: {
+                enableDebugEvents: options?.advancedOptions?.enableDebugEvents ?? false,
                 maxFilterFixDuration: options?.advancedOptions?.maxFilterFixDuration ?? 600000,
                 debugOptions: {
                     logCustomSearches: options?.advancedOptions?.debugOptions?.logCustomSearches ?? false,
@@ -307,8 +314,13 @@ class LavalinkManager extends events_1.EventEmitter {
         if (oldPlayer.voiceChannelId === "string" && oldPlayer.connected && !oldPlayer.get("internal_destroywithoutdisconnect")) {
             if (!this.options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError)
                 throw new Error(`Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player ${JSON.stringify(oldPlayer.toJSON?.())}`);
-            else
-                console.error("Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player", oldPlayer.toJSON?.());
+            else if (this.options?.advancedOptions?.enableDebugEvents) {
+                this.emit("debug", Constants_1.DebugEvents.PlayerDeleteInsteadOfDestroy, {
+                    state: "warn",
+                    message: "Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player",
+                    functionLayer: "LavalinkManager > deletePlayer()",
+                });
+            }
         }
         return this.players.delete(guildId);
     }
@@ -361,8 +373,13 @@ class LavalinkManager extends events_1.EventEmitter {
         }
         if (success > 0)
             this.initiated = true;
-        else
-            console.error("Could not connect to at least 1 Node");
+        else if (this.options?.advancedOptions?.enableDebugEvents) {
+            this.emit("debug", Constants_1.DebugEvents.FailedToConnectToNodes, {
+                state: "error",
+                message: "Failed to connect to at least 1 Node",
+                functionLayer: "LavalinkManager > init()",
+            });
+        }
         return this;
     }
     /**
@@ -382,11 +399,25 @@ class LavalinkManager extends events_1.EventEmitter {
      */
     async sendRawData(data) {
         if (!this.initiated) {
+            if (this.options?.advancedOptions?.enableDebugEvents) {
+                this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                    state: "log",
+                    message: "Manager is not initated yet",
+                    functionLayer: "LavalinkManager > sendRawData()",
+                });
+            }
             if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                 console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, manager is not initated yet");
             return;
         }
         if (!("t" in data)) {
+            if (this.options?.advancedOptions?.enableDebugEvents) {
+                this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                    state: "error",
+                    message: "No 't' in payload-data of the raw event:",
+                    functionLayer: "LavalinkManager > sendRawData()",
+                });
+            }
             if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                 console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no 't' in payload-data of the raw event:", data);
             return;
@@ -404,22 +435,50 @@ class LavalinkManager extends events_1.EventEmitter {
         if (["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) {
             const update = ("d" in data ? data.d : data);
             if (!update) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                        state: "warn",
+                        message: `No Update data found in payload :: ${JSON.stringify(data, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no update data found in payload:", data);
                 return;
             }
             if (!("token" in update) && !("session_id" in update)) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                        state: "error",
+                        message: `No 'token' nor 'session_id' found in payload :: ${JSON.stringify(data, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no 'token' nor 'session_id' found in payload:", data);
                 return;
             }
             const player = this.getPlayer(update.guild_id);
             if (!player) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                        state: "warn",
+                        message: `No Lavalink Player found via key: 'guild_id' of update-data :: ${JSON.stringify(update, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, No Lavalink Player found via key: 'guild_id' of update-data:", update);
                 return;
             }
             if (player.get("internal_destroystatus") === true) {
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                        state: "warn",
+                        message: `Player is in a destroying state. can't signal the voice states`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, Player is in a destroying state. can't signal the voice states");
                 return;
@@ -437,12 +496,24 @@ class LavalinkManager extends events_1.EventEmitter {
                         }
                     }
                 });
+                if (this.options?.advancedOptions?.enableDebugEvents) {
+                    this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                        state: "log",
+                        message: `Sent updatePlayer for voice token session :: ${JSON.stringify({ voice: { token: update.token, endpoint: update.endpoint, sessionId: player.voice?.sessionId, }, update }, null, 2)}`,
+                        functionLayer: "LavalinkManager > sendRawData()",
+                    });
+                }
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, Sent updatePlayer for voice token session", { voice: { token: update.token, endpoint: update.endpoint, sessionId: player.voice?.sessionId, } });
                 return;
             }
             /* voice state update */
             if (update.user_id !== this.options?.client.id) {
+                this.emit("debug", Constants_1.DebugEvents.NoAudioDebug, {
+                    state: "warn",
+                    message: `voice update user is not equal to provided client id of the LavalinkManager.options.client.id :: user: "${update.user_id}" manager client id: "${this.options?.client.id}"`,
+                    functionLayer: "LavalinkManager > sendRawData()",
+                });
                 if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, voice update user is not equal to provided client id of the manageroptions#client#id", "user:", update.user_id, "manager client id:", this.options?.client.id);
                 return;
@@ -461,7 +532,11 @@ class LavalinkManager extends events_1.EventEmitter {
                 if (this.options?.playerOptions?.onDisconnect?.autoReconnect === true) {
                     try {
                         const positionPrevios = player.position;
-                        console.debug("Auto reconnect", positionPrevios, player.lastPosition);
+                        this.emit("debug", Constants_1.DebugEvents.PlayerAutoReconnect, {
+                            state: "log",
+                            message: `Auto reconnecting player because LavalinkManager.options.playerOptions.onDisconnect.autoReconnect is true`,
+                            functionLayer: "LavalinkManager > sendRawData()",
+                        });
                         await player.connect();
                         // replay the current playing stream
                         await player.play({