magmastream 2.10.3-dev.2 → 2.10.4

package/dist/structures/Rest.js

@@ -55,6 +55,36 @@ class Rest {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] Getting player on node: ${this.node.options.identifier} : ${Utils_1.JSONUtils.safe(result, 2)}`);
         return result;
     }
+    /**
+     * Retrieves all players that belong to the current session.
+     * @returns {Promise<LavaPlayer[]>} Returns the players.
+     */
+    async getPlayers() {
+        if (!this.sessionId) {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] Skipping getPlayers - no session ID on node ${this.node.options.identifier}`);
+            return [];
+        }
+        try {
+            const result = await this.get(`/v4/sessions/${this.sessionId}/players`);
+            return Array.isArray(result) ? result : (result?.players ?? []);
+        }
+        catch (err) {
+            const shouldFallback = err instanceof MagmastreamError_1.MagmaStreamError && err.code === Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED && err.message.includes("(400)");
+            if (!shouldFallback)
+                throw err;
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] getPlayers bulk endpoint failed on node ${this.node.options.identifier}; falling back to individual player fetches.`);
+            const players = this.manager.players.filter((player) => player.node.options.identifier === this.node.options.identifier);
+            const results = await Promise.all(players.map(async (player) => {
+                try {
+                    return await this.getPlayer(player.guildId);
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results.filter((player) => player !== null);
+        }
+    }
     /**
      * Sends a PATCH request to update player related data.
      * @param {RestPlayOptions} options The options to update the player with.
@@ -65,6 +95,7 @@ class Rest {
             this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] Skipping updatePlayer for guildId: ${options.guildId} - no session ID on node ${this.node.options.identifier}`);
             return null;
         }
+        this.assertUpdatePlayerSupported(options);
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] Updating player: ${options.guildId}: ${Utils_1.JSONUtils.safe(options, 2)}`);
         return await this.patch(`/v4/sessions/${this.sessionId}/players/${options.guildId}?noReplace=${options.noReplace ?? false}`, options.data);
     }
@@ -95,6 +126,184 @@ class Rest {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[REST] Updating session: ${this.sessionId}`);
         return await this.patch(`/v4/sessions/${this.sessionId}`, { resuming, timeout });
     }
+    /**
+     * Decodes a single Lavalink track.
+     * @param {string} encodedTrack The encoded track string.
+     * @returns {Promise<TrackData>} The decoded track.
+     */
+    async decodeTrack(encodedTrack) {
+        if (typeof encodedTrack !== "string" || encodedTrack.length === 0) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+                message: "Cannot decode an empty track.",
+            });
+        }
+        return await this.get(`/v4/decodetrack?encodedTrack=${encodeURIComponent(encodedTrack)}`);
+    }
+    /**
+     * Decodes multiple Lavalink tracks.
+     * @param {string[]} encodedTracks The encoded track strings.
+     * @returns {Promise<TrackData[]>} The decoded tracks.
+     */
+    async decodeTracks(encodedTracks) {
+        if (!Array.isArray(encodedTracks) || encodedTracks.length === 0) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+                message: "Cannot decode an empty track list.",
+            });
+        }
+        const result = await this.post("/v4/decodetracks", encodedTracks);
+        return Array.isArray(result) ? result : (result?.tracks ?? []);
+    }
+    /**
+     * Retrieves this node's Lavalink info.
+     * @returns {Promise<LavalinkInfo>} The node info.
+     */
+    async getInfo() {
+        return await this.get("/v4/info");
+    }
+    /**
+     * Retrieves this node's current stats.
+     * @returns {Promise<NodeStats>} The node stats.
+     */
+    async getStats() {
+        const stats = await this.get("/v4/stats");
+        if (!stats?.cpu)
+            return stats;
+        return {
+            ...stats,
+            cpu: {
+                ...stats.cpu,
+                lavalinkLoad: stats.cpu.lavalinkLoad ?? stats.cpu.nodelinkLoad ?? 0,
+            },
+        };
+    }
+    /** Returns NodeLink connection diagnostics. */
+    async getNodeLinkConnection() {
+        this.assertNodeLink("get connection diagnostics");
+        return await this.get("/v4/connection");
+    }
+    /** Encodes one track info payload using NodeLink. */
+    async encodeNodeLinkTrack(track) {
+        this.assertNodeLink("encode a track");
+        return await this.get(`/v4/encodetrack?track=${encodeURIComponent(JSON.stringify(track))}`);
+    }
+    /** Encodes multiple track info payloads using NodeLink. */
+    async encodeNodeLinkTracks(tracks) {
+        this.assertNodeLink("encode tracks");
+        if (!Array.isArray(tracks) || tracks.length === 0) {
+            throw new MagmastreamError_1.MagmaStreamError({ code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED, message: "Cannot encode an empty NodeLink track list." });
+        }
+        return await this.post("/v4/encodedtracks", tracks);
+    }
+    /** Loads NodeLink meaning/background information for an encoded track. */
+    async getNodeLinkMeaning(encodedTrack, language = "en") {
+        this.assertNodeLink("load track meaning");
+        this.assertEncodedTrack(encodedTrack);
+        return await this.get(`/v4/meaning?encodedTrack=${encodeURIComponent(encodedTrack)}&lang=${encodeURIComponent(language)}`);
+    }
+    /** Resolves NodeLink's direct stream URL and format metadata. */
+    async getNodeLinkTrackStream(encodedTrack, itag) {
+        this.assertNodeLink("resolve a direct track stream");
+        this.assertEncodedTrack(encodedTrack);
+        const query = `/v4/trackstream?encodedTrack=${encodeURIComponent(encodedTrack)}${itag === undefined ? "" : `&itag=${encodeURIComponent(String(itag))}`}`;
+        return await this.get(query);
+    }
+    /** Opens NodeLink's raw PCM stream response. The caller consumes response.body. */
+    async loadNodeLinkPcmStream(encodedTrack, options = {}) {
+        this.assertNodeLink("load a raw PCM stream");
+        this.assertEncodedTrack(encodedTrack);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.node.options.apiRequestTimeoutMs);
+        let response;
+        try {
+            response = await (0, undici_1.fetch)(`${this.url}/v4/loadstream`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: this.password },
+                body: JSON.stringify({ encodedTrack, volume: options.volume ?? 100, position: options.position ?? 0, filters: options.filters ?? {} }),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (response.status >= 200 && response.status < 300)
+            return response;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+            message: `Request to node ${this.node.options.identifier} failed (${response.status}): ${response.statusText}`,
+        });
+    }
+    /**
+     * Retrieves the route planner status.
+     * @returns {Promise<RoutePlannerStatus>} The route planner status.
+     */
+    async getRoutePlannerStatus() {
+        return await this.get("/v4/routeplanner/status");
+    }
+    /**
+     * Unmarks a failed route planner address.
+     * @param {string} address The address to free.
+     * @returns {Promise<void>} Void.
+     */
+    async freeRoutePlannerAddress(address) {
+        if (typeof address !== "string" || address.length === 0) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+                message: "Cannot free an empty route planner address.",
+            });
+        }
+        await this.post("/v4/routeplanner/free/address", { address });
+    }
+    /**
+     * Unmarks all failed route planner addresses.
+     * @returns {Promise<void>} Void.
+     */
+    async freeAllRoutePlannerAddresses() {
+        await this.post("/v4/routeplanner/free/all");
+    }
+    assertUpdatePlayerSupported(options) {
+        if (this.node.isNodeLink)
+            return;
+        const nodeLinkOnlyFields = [];
+        const data = options.data;
+        if (data.nextTrack !== undefined)
+            nodeLinkOnlyFields.push("nextTrack");
+        if (data.loudnessNormalizer !== undefined)
+            nodeLinkOnlyFields.push("loudnessNormalizer");
+        if (data.fading !== undefined)
+            nodeLinkOnlyFields.push("fading");
+        if (data.track?.audioTrackId !== undefined)
+            nodeLinkOnlyFields.push("track.audioTrackId");
+        if (data.track?.language !== undefined)
+            nodeLinkOnlyFields.push("track.language");
+        const filters = data.filters;
+        for (const filterName of ["lowpass", "highpass", "echo", "reverb", "chorus", "compressor", "flanger", "phaser", "phonograph", "spatial", "tape"]) {
+            if (filters?.[filterName] !== undefined)
+                nodeLinkOnlyFields.push(`filters.${filterName}`);
+        }
+        if (!nodeLinkOnlyFields.length)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: `NodeLink-only update fields cannot be sent to Lavalink node "${this.node.options.identifier}": ${nodeLinkOnlyFields.join(", ")}.`,
+            context: { identifier: this.node.options.identifier, fields: nodeLinkOnlyFields, guildId: options.guildId },
+        });
+    }
+    assertNodeLink(action) {
+        if (this.node.isNodeLink)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.NODE_PROTOCOL_ERROR,
+            message: `NodeLink is required to ${action} on node "${this.node.options.identifier}".`,
+            context: { identifier: this.node.options.identifier },
+        });
+    }
+    assertEncodedTrack(encodedTrack) {
+        if (typeof encodedTrack === "string" && encodedTrack.length > 0)
+            return;
+        throw new MagmastreamError_1.MagmaStreamError({ code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED, message: "Encoded track must be a non-empty string." });
+    }
     /**
      * Sends a request to the specified endpoint and returns the response data.
      * @param {string} method The HTTP method to use for the request.
@@ -132,7 +341,7 @@ class Rest {
             return data;
         }
         if (status === 404) {
-            if (data?.message === "Guild not found") {
+            if (data?.message === "Guild not found" || data?.message === "Player not found") {
                 return [];
             }
             if (data?.message === "Session not found") {