magmastream 2.9.2-dev.1 → 2.9.2-dev.2

package/dist/statestorage/RedisQueue.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisQueue = void 0;
 const Enums_1 = require("../structures/Enums");
 const Utils_1 = require("../structures/Utils");
+const MagmastreamError_1 = require("../structures/MagmastreamError");
 /**
  * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
  */
@@ -26,9 +27,11 @@ class RedisQueue {
         this.guildId = guildId;
         this.manager = manager;
         this.redis = manager.redis;
-        this.redisPrefix = manager.options.stateStorage.redisConfig.prefix?.endsWith(":")
-            ? manager.options.stateStorage.redisConfig.prefix
-            : `${manager.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
+        const rawPrefix = manager.options.stateStorage.redisConfig.prefix;
+        let clean = typeof rawPrefix === "string" ? rawPrefix.trim() : "";
+        if (!clean.endsWith(":"))
+            clean = clean || "magmastream";
+        this.redisPrefix = `${clean}:`;
     }
     // #region Public
     /**
@@ -37,75 +40,126 @@ class RedisQueue {
      * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
      */
     async add(track, offset) {
-        const isArray = Array.isArray(track);
-        const tracks = isArray ? track : [track];
-        const serialized = tracks.map((t) => this.serialize(t));
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        // If there's no current track, pop one from the list
-        if (!(await this.getCurrent())) {
-            const current = serialized.shift();
-            if (current) {
-                await this.setCurrent(this.deserialize(current));
+        try {
+            const isArray = Array.isArray(track);
+            const tracks = isArray ? track : [track];
+            // Serialize tracks
+            const serialized = tracks.map((t) => this.serialize(t));
+            const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+            // Set current track if none exists
+            if (!(await this.getCurrent())) {
+                const current = serialized.shift();
+                if (current) {
+                    await this.setCurrent(this.deserialize(current));
+                }
             }
-        }
-        if (typeof offset === "number" && !isNaN(offset)) {
-            const queue = await this.redis.lrange(this.queueKey, 0, -1);
-            queue.splice(offset, 0, ...serialized);
-            await this.redis.del(this.queueKey);
-            if (queue.length > 0) {
-                await this.redis.rpush(this.queueKey, ...queue);
+            // Insert at offset or append
+            try {
+                if (typeof offset === "number" && !isNaN(offset)) {
+                    const queue = await this.redis.lrange(this.queueKey, 0, -1);
+                    queue.splice(offset, 0, ...serialized);
+                    await this.redis.del(this.queueKey);
+                    if (queue.length > 0) {
+                        await this.redis.rpush(this.queueKey, ...queue);
+                    }
+                }
+                else if (serialized.length > 0) {
+                    await this.redis.rpush(this.queueKey, ...serialized);
+                }
             }
-        }
-        else if (serialized.length > 0) {
-            await this.redis.rpush(this.queueKey, ...serialized);
-        }
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Added ${tracks.length} track(s) to queue`);
-        if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
-            if (!Array.isArray(track)) {
-                const AutoplayUser = (await this.manager.players.get(this.guildId).get("Internal_AutoplayUser"));
-                if (AutoplayUser && AutoplayUser.id === track.requester.id) {
-                    this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-                        changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-                        details: {
-                            type: "queue",
-                            action: "autoPlayAdd",
-                            tracks: Array.isArray(track) ? track : [track],
-                        },
-                    });
-                    return;
+            catch (err) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                    message: `Failed to add tracks to Redis queue for guild ${this.guildId}: ${err.message}`,
+                });
+            }
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Added ${tracks.length} track(s) to queue`);
+            // Autoplay logic
+            if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
+                if (!Array.isArray(track)) {
+                    const AutoplayUser = (await this.manager.players.get(this.guildId).get("Internal_AutoplayUser"));
+                    if (AutoplayUser && AutoplayUser.id === track.requester.id) {
+                        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                            details: {
+                                type: "queue",
+                                action: "autoPlayAdd",
+                                tracks: [track],
+                            },
+                        });
+                        return;
+                    }
                 }
             }
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "add",
+                    tracks,
+                },
+            });
+        }
+        catch (err) {
+            if (err instanceof MagmastreamError_1.MagmaStreamError)
+                throw err;
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Unexpected error in add() for guild ${this.guildId}: ${err.message}`,
+            });
         }
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "add",
-                tracks,
-            },
-        });
     }
     /**
      * Adds a track or tracks to the previous tracks.
      * @param track The track or tracks to add.
      */
     async addPrevious(track) {
-        const tracks = Array.isArray(track) ? track : [track];
-        if (!tracks.length)
-            return;
-        const serialized = tracks.map(this.serialize);
-        if (!serialized.length)
-            return;
-        await this.redis.lpush(this.previousKey, ...serialized.reverse());
-        const max = this.manager.options.maxPreviousTracks;
-        await this.redis.ltrim(this.previousKey, 0, max - 1);
+        try {
+            const tracks = Array.isArray(track) ? track : [track];
+            if (!tracks.length) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                    message: `No tracks provided for addPrevious in guild ${this.guildId}`,
+                });
+            }
+            const serialized = tracks.map(this.serialize);
+            try {
+                // Push newest to TAIL
+                await this.redis.rpush(this.previousKey, ...serialized);
+                // Keep only the most recent maxPreviousTracks (trim from HEAD)
+                const max = this.manager.options.maxPreviousTracks;
+                await this.redis.ltrim(this.previousKey, -max, -1);
+            }
+            catch (err) {
+                throw new MagmastreamError_1.MagmaStreamError({
+                    code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                    message: `Failed to add previous tracks to Redis for guild ${this.guildId}: ${err.message}`,
+                });
+            }
+        }
+        catch (err) {
+            if (err instanceof MagmastreamError_1.MagmaStreamError)
+                throw err;
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Unexpected error in addPrevious() for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * Clears the queue.
      */
     async clear() {
         const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        await this.redis.del(this.queueKey);
+        try {
+            await this.redis.del(this.queueKey);
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to clear queue for guild ${this.guildId}: ${err.message}`,
+            });
+        }
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
             changeType: Enums_1.PlayerStateEventTypes.QueueChange,
             details: {
@@ -120,41 +174,75 @@ class RedisQueue {
      * Clears the previous tracks.
      */
     async clearPrevious() {
-        await this.redis.del(this.previousKey);
+        try {
+            await this.redis.del(this.previousKey);
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to clear previous tracks for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * Removes the first track from the queue.
      */
     async dequeue() {
-        const raw = await this.redis.lpop(this.queueKey);
-        return raw ? this.deserialize(raw) : undefined;
+        try {
+            const raw = await this.redis.lpop(this.queueKey);
+            return raw ? this.deserialize(raw) : undefined;
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to dequeue track for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * @returns The total duration of the queue in milliseconds.
      * This includes the duration of the currently playing track.
      */
     async duration() {
-        const tracks = await this.redis.lrange(this.queueKey, 0, -1);
-        const currentDuration = (await this.getCurrent())?.duration || 0;
-        const total = tracks.reduce((acc, raw) => {
-            try {
-                const parsed = this.deserialize(raw);
-                return acc + (parsed.duration || 0);
-            }
-            catch {
-                return acc;
-            }
-        }, currentDuration);
-        return total;
+        try {
+            const tracks = await this.redis.lrange(this.queueKey, 0, -1);
+            const currentDuration = (await this.getCurrent())?.duration || 0;
+            const total = tracks.reduce((acc, raw) => {
+                try {
+                    const parsed = this.deserialize(raw);
+                    return acc + (parsed.duration || 0);
+                }
+                catch (err) {
+                    // Skip invalid tracks but log
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Skipping invalid track during duration calculation for guild ${this.guildId}: ${err.message}`);
+                    return acc;
+                }
+            }, currentDuration);
+            return total;
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to calculate total queue duration for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * Adds a track to the front of the queue.
      * @param track The track or tracks to add.
      */
     async enqueueFront(track) {
-        const serialized = Array.isArray(track) ? track.map(this.serialize) : [this.serialize(track)];
-        // Redis: LPUSH adds to front, reverse to maintain order if multiple tracks
-        await this.redis.lpush(this.queueKey, ...serialized.reverse());
+        try {
+            const serialized = Array.isArray(track) ? track.map(this.serialize) : [this.serialize(track)];
+            // Redis: LPUSH adds to front, reverse to maintain order if multiple tracks
+            await this.redis.lpush(this.queueKey, ...serialized.reverse());
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to enqueue track to front for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * Whether all tracks in the queue match the specified condition.
@@ -187,29 +275,61 @@ class RedisQueue {
      * @returns The current track.
      */
     async getCurrent() {
-        const raw = await this.redis.get(this.currentKey);
-        return raw ? this.deserialize(raw) : null;
+        try {
+            const raw = await this.redis.get(this.currentKey);
+            return raw ? this.deserialize(raw) : null;
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to get current track for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * @returns The previous tracks.
      */
     async getPrevious() {
-        const raw = await this.redis.lrange(this.previousKey, 0, -1);
-        return raw.map(this.deserialize);
+        try {
+            const raw = await this.redis.lrange(this.previousKey, 0, -1);
+            return raw.map(this.deserialize);
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to get previous tracks for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * @returns The tracks in the queue from the start to the end.
      */
     async getSlice(start = 0, end = -1) {
-        const raw = await this.redis.lrange(this.queueKey, start, end === -1 ? -1 : end - 1);
-        return raw.map(this.deserialize);
+        try {
+            const raw = await this.redis.lrange(this.queueKey, start, end === -1 ? -1 : end - 1);
+            return raw.map(this.deserialize);
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to get slice of queue for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * @returns The tracks in the queue.
      */
     async getTracks() {
-        const raw = await this.redis.lrange(this.queueKey, 0, -1);
-        return raw.map(this.deserialize);
+        try {
+            const raw = await this.redis.lrange(this.queueKey, 0, -1);
+            return raw.map(this.deserialize);
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to get tracks for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     /**
      * Maps the tracks in the queue.
@@ -227,104 +347,145 @@ class RedisQueue {
      * @returns The removed tracks.
      */
     async modifyAt(start, deleteCount = 0, ...items) {
-        const queue = await this.redis.lrange(this.queueKey, 0, -1);
-        const removed = queue.splice(start, deleteCount, ...items.map(this.serialize));
-        await this.redis.del(this.queueKey);
-        if (queue.length > 0) {
-            await this.redis.rpush(this.queueKey, ...queue);
+        try {
+            const queue = await this.redis.lrange(this.queueKey, 0, -1);
+            const removed = queue.splice(start, deleteCount, ...items.map(this.serialize));
+            await this.redis.del(this.queueKey);
+            if (queue.length > 0) {
+                await this.redis.rpush(this.queueKey, ...queue);
+            }
+            return removed.map(this.deserialize);
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to modify queue at index ${start} for guild ${this.guildId}: ${err.message}`,
+            });
         }
-        return removed.map(this.deserialize);
     }
     /**
      * Removes the newest track.
      * @returns The newest track.
      */
     async popPrevious() {
-        const raw = await this.redis.lpop(this.previousKey); // get newest track (index 0)
-        return raw ? this.deserialize(raw) : null;
+        try {
+            // Pop the newest track from the TAIL
+            const raw = await this.redis.rpop(this.previousKey);
+            return raw ? this.deserialize(raw) : null;
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to pop previous track for guild ${this.guildId}: ${err.message}`,
+            });
+        }
     }
     async remove(startOrPos = 0, end) {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        const queue = await this.redis.lrange(this.queueKey, 0, -1);
-        let removed = [];
-        if (typeof end === "number") {
-            if (startOrPos >= end || startOrPos >= queue.length) {
-                throw new RangeError("Invalid range.");
+        try {
+            const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+            const queue = await this.redis.lrange(this.queueKey, 0, -1);
+            let removed = [];
+            if (typeof end === "number") {
+                if (startOrPos >= end || startOrPos >= queue.length) {
+                    throw new RangeError("Invalid range.");
+                }
+                removed = queue.slice(startOrPos, end);
+                queue.splice(startOrPos, end - startOrPos);
             }
-            removed = queue.slice(startOrPos, end);
-            queue.splice(startOrPos, end - startOrPos);
-        }
-        else {
-            removed = queue.splice(startOrPos, 1);
+            else {
+                removed = queue.splice(startOrPos, 1);
+            }
+            await this.redis.del(this.queueKey);
+            if (queue.length > 0) {
+                await this.redis.rpush(this.queueKey, ...queue);
+            }
+            const deserialized = removed.map(this.deserialize);
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removed.length} track(s) from position ${startOrPos}${end ? ` to ${end}` : ""}`);
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "remove",
+                    tracks: deserialized,
+                },
+            });
+            return deserialized;
         }
-        await this.redis.del(this.queueKey);
-        if (queue.length > 0) {
-            await this.redis.rpush(this.queueKey, ...queue);
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to remove track for guild ${this.guildId}: ${error.message}`,
+            });
         }
-        const deserialized = removed.map(this.deserialize);
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removed.length} track(s) from position ${startOrPos}${end ? ` to ${end}` : ""}`);
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "remove",
-                tracks: deserialized,
-            },
-        });
-        return deserialized;
     }
     /**
      * Shuffles the queue round-robin style.
      */
     async roundRobinShuffle() {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
-        const deserialized = rawTracks.map(this.deserialize);
-        const userMap = new Map();
-        for (const track of deserialized) {
-            const userId = track.requester.id;
-            if (!userMap.has(userId))
-                userMap.set(userId, []);
-            userMap.get(userId).push(track);
-        }
-        // Shuffle each user's tracks
-        for (const tracks of userMap.values()) {
-            for (let i = tracks.length - 1; i > 0; i--) {
-                const j = Math.floor(Math.random() * (i + 1));
-                [tracks[i], tracks[j]] = [tracks[j], tracks[i]];
+        try {
+            const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+            const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
+            const deserialized = rawTracks.map(this.deserialize);
+            const userMap = new Map();
+            for (const track of deserialized) {
+                const userId = track.requester.id;
+                if (!userMap.has(userId))
+                    userMap.set(userId, []);
+                userMap.get(userId).push(track);
             }
-        }
-        const users = [...userMap.keys()];
-        const queues = users.map((id) => userMap.get(id));
-        const shuffledQueue = [];
-        while (queues.some((q) => q.length > 0)) {
-            for (const q of queues) {
-                const track = q.shift();
-                if (track)
-                    shuffledQueue.push(track);
+            // Shuffle each user's tracks
+            for (const tracks of userMap.values()) {
+                for (let i = tracks.length - 1; i > 0; i--) {
+                    const j = Math.floor(Math.random() * (i + 1));
+                    [tracks[i], tracks[j]] = [tracks[j], tracks[i]];
+                }
+            }
+            const users = [...userMap.keys()];
+            const queues = users.map((id) => userMap.get(id));
+            const shuffledQueue = [];
+            while (queues.some((q) => q.length > 0)) {
+                for (const q of queues) {
+                    const track = q.shift();
+                    if (track)
+                        shuffledQueue.push(track);
+                }
             }
+            await this.redis.del(this.queueKey);
+            await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "roundRobin",
+                },
+            });
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
+        }
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to roundRobinShuffle the queue for guild ${this.guildId}: ${error.message}`,
+            });
         }
-        await this.redis.del(this.queueKey);
-        await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "roundRobin",
-            },
-        });
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
     }
     /**
      * Sets the current track.
      * @param track The track to set.
      */
     async setCurrent(track) {
-        if (track) {
-            await this.redis.set(this.currentKey, this.serialize(track));
+        try {
+            if (track) {
+                await this.redis.set(this.currentKey, this.serialize(track));
+            }
+            else {
+                await this.redis.del(this.currentKey);
+            }
         }
-        else {
-            await this.redis.del(this.currentKey);
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to setCurrent the queue for guild ${this.guildId}: ${error.message}`,
+            });
         }
     }
     /**
@@ -332,43 +493,67 @@ class RedisQueue {
      * @param track The track to set.
      */
     async setPrevious(track) {
-        const tracks = Array.isArray(track) ? track : [track];
-        if (!tracks.length)
-            return;
-        await this.redis
-            .multi()
-            .del(this.previousKey)
-            .rpush(this.previousKey, ...tracks.map(this.serialize))
-            .exec();
+        try {
+            const tracks = Array.isArray(track) ? track : [track];
+            if (!tracks.length)
+                return;
+            await this.redis
+                .multi()
+                .del(this.previousKey)
+                .rpush(this.previousKey, ...tracks.map(this.serialize))
+                .exec();
+        }
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to setPrevious the queue for guild ${this.guildId}: ${error.message}`,
+            });
+        }
     }
     /**
      * Shuffles the queue.
      */
     async shuffle() {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        const queue = await this.redis.lrange(this.queueKey, 0, -1);
-        for (let i = queue.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [queue[i], queue[j]] = [queue[j], queue[i]];
+        try {
+            const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+            const queue = await this.redis.lrange(this.queueKey, 0, -1);
+            for (let i = queue.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [queue[i], queue[j]] = [queue[j], queue[i]];
+            }
+            await this.redis.del(this.queueKey);
+            if (queue.length > 0) {
+                await this.redis.rpush(this.queueKey, ...queue);
+            }
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "shuffle",
+                },
+            });
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
         }
-        await this.redis.del(this.queueKey);
-        if (queue.length > 0) {
-            await this.redis.rpush(this.queueKey, ...queue);
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to shuffle the queue for guild ${this.guildId}: ${error.message}`,
+            });
         }
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "shuffle",
-            },
-        });
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
     }
     /**
      * @returns The size of the queue.
      */
     async size() {
-        return await this.redis.llen(this.queueKey);
+        try {
+            return await this.redis.llen(this.queueKey);
+        }
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to get the size of the queue for guild ${this.guildId}: ${error.message}`,
+            });
+        }
     }
     /**
      * @returns Whether any tracks in the queue match the specified condition.
@@ -388,34 +573,42 @@ class RedisQueue {
      * Shuffles the queue, but keeps the tracks of the same user together.
      */
     async userBlockShuffle() {
-        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
-        const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
-        const deserialized = rawTracks.map(this.deserialize);
-        const userMap = new Map();
-        for (const track of deserialized) {
-            const userId = track.requester.id;
-            if (!userMap.has(userId))
-                userMap.set(userId, []);
-            userMap.get(userId).push(track);
-        }
-        const shuffledQueue = [];
-        while (shuffledQueue.length < deserialized.length) {
-            for (const [, tracks] of userMap) {
-                const track = tracks.shift();
-                if (track)
-                    shuffledQueue.push(track);
+        try {
+            const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+            const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
+            const deserialized = rawTracks.map(this.deserialize);
+            const userMap = new Map();
+            for (const track of deserialized) {
+                const userId = track.requester.id;
+                if (!userMap.has(userId))
+                    userMap.set(userId, []);
+                userMap.get(userId).push(track);
             }
+            const shuffledQueue = [];
+            while (shuffledQueue.length < deserialized.length) {
+                for (const [, tracks] of userMap) {
+                    const track = tracks.shift();
+                    if (track)
+                        shuffledQueue.push(track);
+                }
+            }
+            await this.redis.del(this.queueKey);
+            await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                details: {
+                    type: "queue",
+                    action: "userBlock",
+                },
+            });
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+        }
+        catch (error) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.QUEUE_REDIS_ERROR,
+                message: `Failed to userBlockShuffle the queue for guild ${this.guildId}: ${error.message}`,
+            });
         }
-        await this.redis.del(this.queueKey);
-        await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
-        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
-            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
-            details: {
-                type: "queue",
-                action: "userBlock",
-            },
-        });
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
     }
     // #endregion Public
     // #region Private