magmastream 2.9.2-dev.1 → 2.9.2-dev.10

package/dist/structures/Player.js

@@ -11,6 +11,7 @@ const RedisQueue_1 = require("../statestorage/RedisQueue");
 const Enums_1 = require("./Enums");
 const ws_1 = require("ws");
 const JsonQueue_1 = require("../statestorage/JsonQueue");
+const MagmastreamError_1 = require("./MagmastreamError");
 class Player {
     options;
     /** The Queue for the Player. */
@@ -75,8 +76,12 @@ class Player {
         // If the Manager is not initiated, throw an error.
         if (!this.manager)
             this.manager = Utils_1.Structure.get("Player")._manager;
-        if (!this.manager)
-            throw new RangeError("Manager has not been initiated.");
+        if (!this.manager) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.GENERAL_INVALID_MANAGER,
+                message: "Manager instance is required.",
+            });
+        }
         this.clusterId = this.manager.options.clusterId || 0;
         // Check the player options for errors.
         (0, playerCheck_1.default)(options);
@@ -102,8 +107,13 @@ class Player {
         const node = this.manager.nodes.get(options.nodeIdentifier);
         this.node = node || this.manager.useableNode;
         // If no node is available, throw an error.
-        if (!this.node)
-            throw new RangeError("No available nodes.");
+        if (!this.node) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.MANAGER_NO_NODES,
+                message: "No available nodes for the player found.",
+                context: { guildId: this.guildId },
+            });
+        }
         // Initialize the queue with the guild ID and manager.
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Redis:
@@ -169,7 +179,11 @@ class Player {
     connect() {
         // Check if the voice channel has been set.
         if (!this.voiceChannelId) {
-            throw new RangeError("No voice channel has been set. You must use the `setVoiceChannelId()` method to set the voice channel before connecting.");
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
+                message: "No voice channel has been set. You must set the voice channel before connecting.",
+                context: { voiceChannelId: this.voiceChannelId },
+            });
         }
         // Set the player state to connecting.
         this.state = Enums_1.StateTypes.Connecting;
@@ -268,8 +282,12 @@ class Player {
      */
     setVoiceChannelId(channel) {
         // Validate the channel parameter
-        if (typeof channel !== "string")
-            throw new TypeError("Channel must be a non-empty string.");
+        if (typeof channel !== "string") {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
+                message: "Channel must be a non-empty string.",
+            });
+        }
         // Clone the current player state for comparison
         const oldPlayer = this ? { ...this } : null;
         // Update the player voice channel
@@ -300,8 +318,12 @@ class Player {
      */
     setTextChannelId(channel) {
         // Validate the channel parameter
-        if (typeof channel !== "string")
-            throw new TypeError("Channel must be a non-empty string.");
+        if (typeof channel !== "string") {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
+                message: "Channel must be a non-empty string.",
+            });
+        }
         // Clone the current player state for comparison
         const oldPlayer = this ? { ...this } : null;
         // Update the text channel property
@@ -328,8 +350,12 @@ class Player {
      */
     setNowPlayingMessage(message) {
         if (!message) {
-            throw new TypeError("You must provide the message of the now playing message.");
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_NOW_PLAYING_MESSAGE,
+                message: "You must provide the message of the now playing message.",
+            });
         }
+        this.set("nowPlayingMessage", message);
         this.nowPlayingMessage = message;
         return this.nowPlayingMessage;
     }
@@ -337,8 +363,14 @@ class Player {
         if (typeof optionsOrTrack !== "undefined" && Utils_1.TrackUtils.validate(optionsOrTrack)) {
             await this.queue.setCurrent(optionsOrTrack);
         }
-        if (!(await this.queue.getCurrent()))
-            throw new RangeError("No current track.");
+        if (!(await this.queue.getCurrent())) {
+            const error = new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_QUEUE_EMPTY,
+                message: "The queue is empty.",
+            });
+            console.error(error);
+            return this;
+        }
         const finalOptions = playOptions
             ? playOptions
             : ["startTime", "endTime", "noReplace"].every((v) => Object.keys(optionsOrTrack || {}).includes(v))
@@ -369,11 +401,21 @@ class Player {
      */
     setAutoplay(autoplayState, AutoplayUser, tries) {
         if (typeof autoplayState !== "boolean") {
-            throw new Error("autoplayState must be a boolean.");
+            const error = new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_AUTOPLAY,
+                message: "autoplayState must be a boolean.",
+            });
+            console.error(error);
+            return this;
         }
         if (autoplayState) {
             if (!AutoplayUser) {
-                throw new Error("AutoplayUser must be provided when enabling autoplay.");
+                const error = new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_AUTOPLAY,
+                    message: "AutoplayUser must be provided when enabling autoplay.",
+                });
+                console.error(error);
+                return this;
             }
             this.autoplayTries = tries && typeof tries === "number" && tries > 0 ? tries : 3; // Default to 3 if invalid
             this.isAutoplay = true;
@@ -416,16 +458,26 @@ class Player {
      * player.setVolume(50);
      */
     async setVolume(volume) {
-        if (isNaN(volume))
-            throw new TypeError("Volume must be a number.");
+        if (isNaN(volume)) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_VOLUME,
+                message: "Volume must be a number.",
+            });
+        }
         if (this.options.applyVolumeAsFilter) {
             if (volume < 0 || volume > 500) {
-                throw new RangeError("Volume must be between 0 and 500 when using filter mode (100 = 100%).");
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_VOLUME,
+                    message: "Volume must be between 0 and 500 when using filter mode (100 = 100%).",
+                });
             }
         }
         else {
             if (volume < 0 || volume > 1000) {
-                throw new RangeError("Volume must be between 0 and 1000.");
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_VOLUME,
+                    message: "Volume must be between 0 and 1000.",
+                });
             }
         }
         const oldVolume = this.volume;
@@ -481,8 +533,12 @@ class Player {
      */
     setTrackRepeat(repeat) {
         // Ensure the repeat parameter is a boolean
-        if (typeof repeat !== "boolean")
-            throw new TypeError('Repeat can only be "true" or "false".');
+        if (typeof repeat !== "boolean") {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_REPEAT,
+                message: "Repeat must be a boolean.",
+            });
+        }
         // Clone the current player state for event emission
         const oldPlayer = this ? { ...this } : null;
         if (repeat) {
@@ -517,8 +573,12 @@ class Player {
      */
     setQueueRepeat(repeat) {
         // Ensure the repeat parameter is a boolean
-        if (typeof repeat !== "boolean")
-            throw new TypeError('Repeat can only be "true" or "false".');
+        if (typeof repeat !== "boolean") {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_REPEAT,
+                message: "Repeat must be a boolean.",
+            });
+        }
         // Get the current player state
         const oldPlayer = this ? { ...this } : null;
         // Update the player state
@@ -555,11 +615,17 @@ class Player {
     async setDynamicRepeat(repeat, ms) {
         // Validate the repeat parameter
         if (typeof repeat !== "boolean") {
-            throw new TypeError('Repeat can only be "true" or "false".');
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_REPEAT,
+                message: "Repeat must be a boolean.",
+            });
         }
         // Ensure the queue has more than one track for dynamic repeat
         if ((await this.queue.size()) <= 1) {
-            throw new RangeError("The queue size must be greater than 1.");
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_REPEAT,
+                message: "The queue size must be greater than 1.",
+            });
         }
         // Clone the current player state for comparison
         const oldPlayer = this ? { ...this } : null;
@@ -633,12 +699,25 @@ class Player {
     async stop(amount) {
         const oldPlayer = { ...this };
         let removedTracks = [];
+        const current = await this.queue.getCurrent(); // may be null
         if (typeof amount === "number" && amount > 1) {
-            if (amount > (await this.queue.size()))
-                throw new RangeError("Cannot skip more than the queue length.");
+            const queueSize = await this.queue.size();
+            if (amount > queueSize) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_QUEUE_EMPTY,
+                    message: "The amount of tracks to remove is greater than the queue size.",
+                });
+            }
             removedTracks = await this.queue.getSlice(0, amount - 1);
             await this.queue.modifyAt(0, amount - 1);
+            const toAdd = [];
+            if (current)
+                toAdd.push(current);
+            toAdd.push(...removedTracks);
+            await this.queue.addPrevious(toAdd);
         }
+        // This will trigger trackEnd for the current track; since we already added current,
+        // addPrevious will ignore duplicates.
         this.node.rest.updatePlayer({
             guildId: this.guildId,
             data: {
@@ -663,8 +742,12 @@ class Player {
      */
     async pause(pause) {
         // Validate the pause parameter to ensure it's a boolean.
-        if (typeof pause !== "boolean")
-            throw new RangeError('Pause can only be "true" or "false".');
+        if (typeof pause !== "boolean") {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_PAUSE,
+                message: "Pause must be a boolean.",
+            });
+        }
         // If the pause state is already as desired or there are no tracks, return early.
         if (this.paused === pause || !this.queue.totalSize)
             return this;
@@ -698,19 +781,33 @@ class Player {
      * @throws {Error} If there are no previous tracks in the queue.
      * @emits {PlayerStateUpdate} - With {@link PlayerStateEventTypes.TrackChange} as the change type.
      */
-    async previous() {
-        // Get and remove the most recent previous track
+    async previous(addBackToQueue = true) {
+        // Pop the most recent previous track (from tail)
         const lastTrack = await this.queue.popPrevious();
         if (!lastTrack) {
             await this.queue.clearPrevious();
-            throw new Error("No previous track available.");
+            const error = new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_PREVIOUS_EMPTY,
+                message: "Previous queue is empty.",
+            });
+            console.error(error);
+            return this;
         }
         // Capture the current state of the player before making changes.
         const oldPlayer = { ...this };
-        // Set skip flag so trackEnd doesn't add current to previous
+        // Prevent re-adding the current track
         this.set("skipFlag", true);
-        await this.play(lastTrack);
-        // Emit state update
+        // Add the current track to the queue if addBackToQueue is true
+        if (addBackToQueue) {
+            const currentPlayingTrack = await this.queue.getCurrent();
+            if (currentPlayingTrack) {
+                await this.queue.add(currentPlayingTrack, 0);
+            }
+            await this.play(lastTrack);
+        }
+        else {
+            await this.play(lastTrack);
+        }
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
             changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
@@ -734,7 +831,10 @@ class Player {
         position = Number(position);
         // Check if the position is valid.
         if (isNaN(position)) {
-            throw new RangeError("Position must be a number.");
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_SEEK,
+                message: "Position must be a number.",
+            });
         }
         // Get the old player state.
         const oldPlayer = this ? { ...this } : null;
@@ -798,8 +898,14 @@ class Player {
      */
     async moveNode(identifier) {
         const node = this.manager.nodes.get(identifier);
-        if (!node)
-            throw new Error(`Node with identifier ${identifier} not found`);
+        if (!node) {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Tried to move to non-existent node: ${identifier}`);
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.MANAGER_NODE_NOT_FOUND,
+                message: "Node not found.",
+                context: { identifier },
+            });
+        }
         if (this.state !== Enums_1.StateTypes.Connected) {
             return this;
         }
@@ -814,7 +920,12 @@ class Player {
             const token = this.voiceState?.event?.token;
             const endpoint = this.voiceState?.event?.endpoint;
             if (!sessionId || !token || !endpoint) {
-                throw new Error(`Voice state is not properly initialized for player ${this.guildId}. The bot might not be connected to a voice channel.`);
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Voice state is not properly initialized for player ${this.guildId}. The bot might not be connected to a voice channel.`);
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_STATE_INVALID,
+                    message: `Voice state is not properly initialized. The bot might not be connected to a voice channel.`,
+                    context: { guildId: this.guildId },
+                });
             }
             await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
             this.manager.players.delete(this.guildId);
@@ -826,8 +937,17 @@ class Player {
             });
             await this.filters.updateFilters();
         }
-        catch (error) {
-            throw new Error(`Failed to move player to node ${identifier}: ${error}`);
+        catch (err) {
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
+                ? err
+                : new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_MOVE_FAILED,
+                    message: "Error moving player to node.",
+                    cause: err,
+                    context: { guildId: this.guildId },
+                });
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, error);
+            console.error(error);
         }
     }
     /**
@@ -839,12 +959,24 @@ class Player {
      * @returns {Promise<Player>} - The new player instance.
      */
     async switchGuild(newOptions, force = false) {
-        if (!newOptions.guildId)
-            throw new Error("guildId is required");
-        if (!newOptions.voiceChannelId)
-            throw new Error("Voice channel ID is required");
-        if (!newOptions.textChannelId)
-            throw new Error("Text channel ID is required");
+        if (!newOptions.guildId) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
+                message: "guildId is required for switchGuild",
+            });
+        }
+        if (!newOptions.voiceChannelId) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
+                message: "voiceChannelId is required for switchGuild",
+            });
+        }
+        if (!newOptions.textChannelId) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
+                message: "textChannelId is required for switchGuild",
+            });
+        }
         // Check if a player already exists for the new guild
         let newPlayer = this.manager.getPlayer(newOptions.guildId);
         // If the player already exists and force is false, return the existing player
@@ -943,14 +1075,8 @@ class Player {
      * Retrieves the current lyrics for the playing track.
      * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
      * @returns {Promise<Lyrics>} - The lyrics of the current track.
-     * @throws {RangeError} - If the 'lavalyrics-plugin' is not available on the Lavalink node.
      */
     async getCurrentLyrics(skipTrackSource = false) {
-        // Check if the 'lavalyrics-plugin' is available on the node
-        const hasLyricsPlugin = this.node.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin");
-        if (!hasLyricsPlugin) {
-            throw new RangeError(`There is no lavalyrics-plugin available in the Lavalink node: ${this.node.options.identifier}`);
-        }
         // Fetch the lyrics for the current track from the Lavalink node
         let result = (await this.node.getLyrics(await this.queue.getCurrent(), skipTrackSource));
         // If no lyrics are found, return a default empty lyrics object
@@ -971,8 +1097,13 @@ class Player {
      * @throws {Error} - If the node is not a NodeLink.
      */
     async setupVoiceReceiver() {
-        if (!this.node.isNodeLink)
-            throw new Error("This function is only available for NodeLinks");
+        if (!this.node.isNodeLink) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                message: `The node is not a NodeLink, cannot setup voice receiver.`,
+                context: { identifier: this.node.options.identifier },
+            });
+        }
         if (this.voiceReceiverWsClient)
             await this.removeVoiceReceiver();
         const headers = {
@@ -994,8 +1125,13 @@ class Player {
      * @throws {Error} - If the node is not a NodeLink.
      */
     async removeVoiceReceiver() {
-        if (!this.node.isNodeLink)
-            throw new Error("This function is only available for NodeLinks");
+        if (!this.node.isNodeLink) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+                message: `The node is not a NodeLink, cannot remove voice receiver.`,
+                context: { identifier: this.node.options.identifier },
+            });
+        }
         if (this.voiceReceiverWsClient) {
             this.voiceReceiverWsClient.close(1000, "destroy");
             this.voiceReceiverWsClient.removeAllListeners();
@@ -1021,8 +1157,13 @@ class Player {
      */
     async reconnectVoiceReceiver() {
         this.voiceReceiverReconnectTimeout = setTimeout(async () => {
-            if (this.voiceReceiverAttempt > this.voiceReceiverReconnectTries)
-                throw new Error("Failed to reconnect to voice receiver");
+            if (this.voiceReceiverAttempt > this.voiceReceiverReconnectTries) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.PLAYER_VOICE_RECEIVER_ERROR,
+                    message: `Failed to reconnect to voice receiver for player ${this.guildId}`,
+                    context: { identifier: this.node.options.identifier },
+                });
+            }
             this.voiceReceiverWsClient?.removeAllListeners();
             this.voiceReceiverWsClient = null;
             this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Reconnecting to voice receiver for player ${this.guildId}`);

package/dist/structures/Rest.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const Enums_1 = require("./Enums");
 const Utils_1 = require("./Utils");
+const MagmastreamError_1 = require("./MagmastreamError");
 /** Handles the requests sent to the Lavalink REST API. */
 class Rest {
     /** The Node that this Rest instance is connected to. */
@@ -38,12 +39,12 @@ class Rest {
         return this.sessionId;
     }
     /**
-     * Retrieves all the players that are currently running on the node.
+     * Retrieves one the player that is currently running on the node.
      * @returns {Promise<unknown>} Returns the result of the GET request.
      */
-    async getAllPlayers() {
+    async getPlayer(guildId) {
         // Send a GET request to the Lavalink Node to retrieve all the players.
-        const result = await this.get(`/v4/sessions/${this.sessionId}/players`);
+        const result = (await this.get(`/v4/sessions/${this.sessionId}/players/${guildId}`));
         // Log the result of the request.
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] Getting all players on node: ${this.node.options.identifier} : ${Utils_1.JSONUtils.safe(result, 2)}`);
         // Return the result of the request.
@@ -93,7 +94,7 @@ class Rest {
      * @returns {Promise<unknown>} The response data of the request.
      */
     async request(method, endpoint, body) {
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] ${method} api call for endpoint: ${endpoint} with data: ${Utils_1.JSONUtils.safe(body, 2)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] ${method} request to ${endpoint} with body: ${Utils_1.JSONUtils.safe(body, 2)}`);
         const config = {
             method,
             url: this.url + endpoint,
@@ -108,19 +109,29 @@ class Rest {
             const response = await (0, axios_1.default)(config);
             return response.data;
         }
-        catch (error) {
+        catch (err) {
+            const error = err;
             if (!error.response) {
-                console.error(`[REST] No response from node: ${error.message}`);
-                return null;
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+                    message: `No response from node ${this.node.options.identifier}: ${error.message}`,
+                });
             }
-            if (error.response.data?.message === "Guild not found") {
+            const data = error.response.data;
+            if (data?.message === "Guild not found") {
                 return [];
             }
-            else if (error.response.status === 404) {
-                await this.node.destroy();
-                await this.node.manager.createNode(this.node.options).connect();
+            if (error.response.status === 401) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.REST_UNAUTHORIZED,
+                    message: `Unauthorized access to node ${this.node.options.identifier}`,
+                });
             }
-            return null;
+            const dataMessage = typeof data === "string" ? data : data?.message ? data.message : Utils_1.JSONUtils.safe(data, 2);
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+                message: `Request to node ${this.node.options.identifier} failed with status ${error.response.status}: ${dataMessage}`,
+            });
         }
     }
     /**