lavalink-client 2.2.2 → 2.3.0

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

@@ -1,162 +1,18 @@
-/// <reference types="node" />
-import internal from "stream";
-import { NodeManager } from "./NodeManager";
-import { DestroyReasonsType, Player } from "./Player";
-import { Track } from "./Track";
-import { Base64, InvalidLavalinkRestRequest, LavalinkPlayer, LavaSearchQuery, LavaSearchResponse, PlayerUpdateInfo, RoutePlanner, SearchQuery, SearchResult, Session } from "./Utils";
-/** Ability to manipulate fetch requests */
-export type ModifyRequest = (options: RequestInit & {
-    path: string;
-    extraQueryUrlParams?: URLSearchParams;
-}) => void;
-export declare const validSponsorBlocks: string[];
-export type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
-/**
- * Node Options for creating a lavalink node
- */
-export interface LavalinkNodeOptions {
-    /** The Lavalink Server-Ip / Domain-URL */
-    host: string;
-    /** The Lavalink Connection Port */
-    port: number;
-    /** The Lavalink Password / Authorization-Key */
-    authorization: string;
-    /** Does the Server use ssl (https) */
-    secure?: boolean;
-    /** RESUME THE PLAYER? by providing a sessionid on the node-creation */
-    sessionId?: string;
-    /** Add a Custom ID to the node, for later use */
-    id?: string;
-    /** Voice Regions of this Node */
-    regions?: string[];
-    /** The retryAmount for the node. */
-    retryAmount?: number;
-    /** The retryDelay for the node. */
-    retryDelay?: number;
-    /** signal for cancelling requests - default: AbortSignal.timeout(options.requestSignalTimeoutMS || 10000) - put <= 0 to disable */
-    requestSignalTimeoutMS?: number;
-}
-/**
- * Memory Stats object from lavalink
- */
-export interface MemoryStats {
-    /** The free memory of the allocated amount. */
-    free: number;
-    /** The used memory of the allocated amount. */
-    used: number;
-    /** The total allocated memory. */
-    allocated: number;
-    /** The reservable memory. */
-    reservable: number;
-}
-/**
- * CPU Stats object from lavalink
- */
-export interface CPUStats {
-    /** The core amount the host machine has. */
-    cores: number;
-    /** The system load. */
-    systemLoad: number;
-    /** The lavalink load. */
-    lavalinkLoad: number;
-}
-/**
- * FrameStats Object from lavalink
- */
-export interface FrameStats {
-    /** The amount of sent frames. */
-    sent?: number;
-    /** The amount of nulled frames. */
-    nulled?: number;
-    /** The amount of deficit frames. */
-    deficit?: number;
-}
-/**
- * BaseNodeStats object from Lavalink
- */
-export interface BaseNodeStats {
-    /** The amount of players on the node. */
-    players: number;
-    /** The amount of playing players on the node. */
-    playingPlayers: number;
-    /** The uptime for the node. */
-    uptime: number;
-    /** The memory stats for the node. */
-    memory: MemoryStats;
-    /** The cpu stats for the node. */
-    cpu: CPUStats;
-    /** The frame stats for the node. */
-    frameStats: FrameStats;
-}
-/**
- * Interface for nodeStats from lavalink
- */
-export interface NodeStats extends BaseNodeStats {
-    /** The frame stats for the node. */
-    frameStats: FrameStats;
-}
-/**
- * Entire lavalink information object from lavalink
- */
-export interface LavalinkInfo {
-    /** The version of this Lavalink server */
-    version: VersionObject;
-    /** The millisecond unix timestamp when this Lavalink jar was built */
-    buildTime: number;
-    /** The git information of this Lavalink server */
-    git: GitObject;
-    /** The JVM version this Lavalink server runs on */
-    jvm: string;
-    /** The Lavaplayer version being used by this server */
-    lavaplayer: string;
-    /** The enabled source managers for this server */
-    sourceManagers: string[];
-    /** The enabled filters for this server */
-    filters: string[];
-    /** The enabled plugins for this server */
-    plugins: PluginObject[];
-}
-/**
- * Lavalink's version object from lavalink
- */
-export interface VersionObject {
-    /** The full version string of this Lavalink server */
-    semver: string;
-    /** The major version of this Lavalink server */
-    major: number;
-    /** The minor version of this Lavalink server */
-    minor: number;
-    /** The patch version of this Lavalink server */
-    patch: internal;
-    /** The pre-release version according to semver as a . separated list of identifiers */
-    preRelease?: string;
-    /** The build metadata according to semver as a . separated list of identifiers */
-    build?: string;
-}
-/**
- * Git information object from lavalink
- */
-export interface GitObject {
-    /** The branch this Lavalink server was built on */
-    branch: string;
-    /** The commit this Lavalink server was built on */
-    commit: string;
-    /** The millisecond unix timestamp for when the commit was created */
-    commitTime: string;
-}
-/**
- * Lavalink's plugins object from lavalink's plugin
- */
-export interface PluginObject {
-    /** The name of the plugin */
-    name: string;
-    /** The version of the plugin */
-    version: string;
-}
+import type { Player } from "./Player";
+import type { DestroyReasonsType } from "./Types/Player";
+import type { Track } from "./Types/Track";
+import type { Base64, InvalidLavalinkRestRequest, LavalinkPlayer, LavaSearchQuery, LavaSearchResponse, PlayerUpdateInfo, RoutePlanner, SearchQuery, SearchResult, Session } from "./Types/Utils";
+import type { NodeManager } from "./NodeManager";
+import type { BaseNodeStats, LavalinkInfo, LavalinkNodeOptions, ModifyRequest, NodeStats, SponsorBlockSegment } from "./Types/Node";
 /**
  * Lavalink Node creator class
  */
 export declare class LavalinkNode {
+    private heartBeatPingTimestamp;
+    private heartBeatPongTimestamp;
+    get heartBeatPing(): number;
+    private heartBeatInterval?;
+    private pingTimeout?;
     /** The provided Options of the Node */
     options: LavalinkNodeOptions;
     /** The amount of rest calls the node has made. */
@@ -300,6 +156,7 @@ export declare class LavalinkNode {
      * ```
      */
     connect(sessionId?: string): void;
+    private heartBeat;
     /**
      * Get the id of the node
      *
@@ -332,6 +189,7 @@ export declare class LavalinkNode {
      * ```
      */
     get connected(): boolean;
+    isAlive: boolean;
     /**
      * Returns the current ConnectionStatus
      *
@@ -356,7 +214,7 @@ export declare class LavalinkNode {
      * const playersOfLavalink = await node?.fetchAllPlayers();
      * ```
      */
-    fetchAllPlayers(): Promise<LavalinkPlayer[]>;
+    fetchAllPlayers(): Promise<LavalinkPlayer[] | InvalidLavalinkRestRequest>;
     /**
      * Gets specific Player Information
      * @returns lavalink player object if player exists on lavalink
@@ -517,6 +375,7 @@ export declare class LavalinkNode {
     private message;
     /** @private middleware util function for handling all kind of events from websocket */
     private handleEvent;
+    private getTrackOfPayload;
     /** @private util function for handling trackStart event */
     private trackStart;
     /** @private util function for handling trackEnd event */

package/dist/esm/structures/Node.js

@@ -1,12 +1,18 @@
 import { isAbsolute } from "path";
 import WebSocket from "ws";
-import { DestroyReasons } from "./Player";
+import { DestroyReasons, validSponsorBlocks } from "./Constants";
 import { NodeSymbol, queueTrackEnd } from "./Utils";
-export const validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];
 /**
  * Lavalink Node creator class
  */
 export class LavalinkNode {
+    heartBeatPingTimestamp = 0;
+    heartBeatPongTimestamp = 0;
+    get heartBeatPing() {
+        return this.heartBeatPongTimestamp - this.heartBeatPingTimestamp;
+    }
+    heartBeatInterval;
+    pingTimeout;
     /** The provided Options of the Node */
     options;
     /** The amount of rest calls the node has made. */
@@ -66,8 +72,11 @@ export class LavalinkNode {
         this.options = {
             secure: false,
             retryAmount: 5,
-            retryDelay: 30e3,
+            retryDelay: 10e3,
             requestSignalTimeoutMS: 10000,
+            heartBeatInterval: 30000,
+            closeOnError: true,
+            enablePingOnStatsCheck: true,
             ...options
         };
         this.NodeManager = manager;
@@ -146,6 +155,8 @@ export class LavalinkNode {
      * ```
      */
     async request(endpoint, modify, parseAsText = false) {
+        if (!this.connected)
+            throw new Error("The node is not connected to the Lavalink Server!, Please call node.connect() first!");
         const { request, options } = await this.rawRequest(endpoint, modify);
         if (["DELETE", "PUT"].includes(options.method))
             return;
@@ -230,7 +241,7 @@ export class LavalinkNode {
         if (Query.source)
             this.NodeManager.LavalinkManager.utils.validateSourceString(this, Query.source);
         if (/^https?:\/\//.test(Query.query))
-            return await this.search({ query: Query.query, source: Query.source }, requestUser);
+            return this.search({ query: Query.query, source: Query.source }, requestUser);
         if (!["spsearch", "sprec", "amsearch", "dzsearch", "dzisrc", "ytmsearch", "ytsearch"].includes(Query.source))
             throw new SyntaxError(`Query.source must be a source from LavaSrc: "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "ytmsearch" | "ytsearch"`);
         if (!this.info.plugins.find(v => v.name === "lavasearch-plugin"))
@@ -292,7 +303,7 @@ export class LavalinkNode {
     async destroyPlayer(guildId) {
         if (!this.sessionId)
             throw new Error("The Lavalink-Node is either not ready, or not up to date!");
-        return await this.request(`/sessions/${this.sessionId}/players/${guildId}`, r => { r.method = "DELETE"; });
+        return this.request(`/sessions/${this.sessionId}/players/${guildId}`, r => { r.method = "DELETE"; });
     }
     /**
      * Connect to the Lavalink Node
@@ -324,6 +335,17 @@ export class LavalinkNode {
         this.socket.on("close", (code, reason) => this.close(code, reason?.toString()));
         this.socket.on("message", this.message.bind(this));
         this.socket.on("error", this.error.bind(this));
+        // this.socket.on("ping", () => this.heartBeat("ping")); // lavalink doesn'T send ping periodically, therefore we use the stats message
+    }
+    heartBeat() {
+        if (this.pingTimeout)
+            clearTimeout(this.pingTimeout);
+        this.pingTimeout = setTimeout(() => {
+            if (!this.socket)
+                return console.error("Node-Ping-Acknowledge-Timeout - Socket not available - maybe reconnecting?");
+            this.isAlive = false;
+            this.socket.terminate();
+        }, 65000); // the stats endpoint get's sent every 60s. se wee add a 5s buffer to make sure we don't miss any stats message
     }
     /**
      * Get the id of the node
@@ -384,6 +406,7 @@ export class LavalinkNode {
             return false;
         return this.socket.readyState === WebSocket.OPEN;
     }
+    isAlive = false;
     /**
      * Returns the current ConnectionStatus
      *
@@ -415,11 +438,7 @@ export class LavalinkNode {
     async fetchAllPlayers() {
         if (!this.sessionId)
             throw new Error("The Lavalink-Node is either not ready, or not up to date!");
-        const players = await this.request(`/sessions/${this.sessionId}/players`);
-        if (!Array.isArray(players))
-            return [];
-        else
-            return players;
+        return this.request(`/sessions/${this.sessionId}/players`) || [];
     }
     /**
      * Gets specific Player Information
@@ -434,7 +453,7 @@ export class LavalinkNode {
     async fetchPlayer(guildId) {
         if (!this.sessionId)
             throw new Error("The Lavalink-Node is either not ready, or not up to date!");
-        return await this.request(`/sessions/${this.sessionId}/players/${guildId}`);
+        return this.request(`/sessions/${this.sessionId}/players/${guildId}`);
     }
     /**
      * Updates the session with and enables/disables resuming and timeout
@@ -460,7 +479,7 @@ export class LavalinkNode {
             enabled: typeof resuming === "boolean" ? resuming : false,
             timeout: typeof resuming === "boolean" && resuming === true ? timeout : null,
         };
-        return await this.request(`/sessions/${this.sessionId}`, r => {
+        return this.request(`/sessions/${this.sessionId}`, r => {
             r.method = "PATCH";
             r.headers = { Authorization: this.options.authorization, 'Content-Type': 'application/json' };
             r.body = JSON.stringify(data);
@@ -706,6 +725,7 @@ export class LavalinkNode {
      * ```
      */
     reconnect(instaReconnect = false) {
+        this.NodeManager.emit("reconnectinprogress", this);
         if (instaReconnect) {
             if (this.reconnectAttempts >= this.options.retryAmount) {
                 const error = new Error(`Unable to connect after ${this.options.retryAmount} attempts.`);
@@ -734,6 +754,29 @@ export class LavalinkNode {
     }
     /** @private util function for handling opening events from websocket */
     async open() {
+        this.isAlive = true;
+        // trigger heartbeat-ping timeout - this is to check wether the client lost connection without knowing it
+        if (this.options.enablePingOnStatsCheck)
+            this.heartBeat();
+        if (this.heartBeatInterval)
+            clearInterval(this.heartBeatInterval);
+        if (this.options.heartBeatInterval > 0) {
+            // everytime a pong happens, set this.isAlive to true
+            this.socket.on("pong", () => {
+                this.heartBeatPongTimestamp = performance.now();
+                this.isAlive = true;
+            });
+            // every x ms send a ping to lavalink to retrieve a pong later on
+            this.heartBeatInterval = setInterval(() => {
+                if (!this.socket)
+                    return console.error("Node-Heartbeat-Interval - Socket not available - maybe reconnecting?");
+                if (!this.isAlive)
+                    this.close(500, "Node-Heartbeat-Timeout");
+                this.isAlive = false;
+                this.heartBeatPingTimestamp = performance.now();
+                this.socket.ping();
+            }, this.options.heartBeatInterval || 30000);
+        }
         if (this.reconnectTimeout)
             clearTimeout(this.reconnectTimeout);
         // reset the reconnect attempts amount
@@ -747,6 +790,12 @@ export class LavalinkNode {
     }
     /** @private util function for handling closing events from websocket */
     close(code, reason) {
+        if (this.pingTimeout)
+            clearTimeout(this.pingTimeout);
+        if (this.heartBeatInterval)
+            clearInterval(this.heartBeatInterval);
+        if (code === 1006 && !reason)
+            reason = "Socket got terminated due to no ping connection";
         this.NodeManager.emit("disconnect", this, { code, reason });
         if (code !== 1000 || reason !== "Node-Destroy")
             this.reconnect();
@@ -756,6 +805,14 @@ export class LavalinkNode {
         if (!error)
             return;
         this.NodeManager.emit("error", this, error);
+        if (this.options.closeOnError) {
+            if (this.heartBeatInterval)
+                clearInterval(this.heartBeatInterval);
+            if (this.pingTimeout)
+                clearTimeout(this.pingTimeout);
+            this.socket?.close(500, "Node-Error - Force Reconnect");
+        }
+        ;
     }
     /** @private util function for handling message events from websocket */
     async message(d) {
@@ -769,6 +826,8 @@ export class LavalinkNode {
         this.NodeManager.emit("raw", this, payload);
         switch (payload.op) {
             case "stats":
+                if (this.options.enablePingOnStatsCheck)
+                    this.heartBeat(); // lavalink doesn'T send "ping" periodically, therefore we use the stats message to check for a ping
                 delete payload.op;
                 this.stats = { ...payload };
                 break;
@@ -798,7 +857,13 @@ export class LavalinkNode {
                 this.sessionId = payload.sessionId;
                 this.resuming.enabled = payload.resumed;
                 if (payload.resumed === true) {
-                    this.NodeManager.emit("resumed", this, payload, await this.fetchAllPlayers());
+                    try {
+                        this.NodeManager.emit("resumed", this, payload, await this.fetchAllPlayers());
+                    }
+                    catch (e) {
+                        console.error("Failed to fetch players for resumed event, falling back without players array", e);
+                        this.NodeManager.emit("resumed", this, payload, []);
+                    }
                 }
                 break;
             default:
@@ -808,7 +873,7 @@ export class LavalinkNode {
     }
     /** @private middleware util function for handling all kind of events from websocket */
     async handleEvent(payload) {
-        if (!payload.guildId)
+        if (!payload?.guildId)
             return;
         const player = this.NodeManager.LavalinkManager.getPlayer(payload.guildId);
         if (!player)
@@ -847,39 +912,51 @@ export class LavalinkNode {
         }
         return;
     }
+    async getTrackOfPayload(payload) {
+        return "track" in payload
+            ? this.NodeManager.LavalinkManager.utils.buildTrack(payload.track, undefined)
+            : null;
+    }
     /** @private util function for handling trackStart event */
-    trackStart(player, track, payload) {
+    async trackStart(player, track, payload) {
         player.playing = true;
         player.paused = false;
         // don't emit the event if previous track == new track aka track loop
         if (this.NodeManager.LavalinkManager.options?.emitNewSongsOnly === true && player.queue.previous[0]?.info?.identifier === track?.info?.identifier)
             return;
-        return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
+        if (!player.queue.current) {
+            player.queue.current = await this.getTrackOfPayload(payload);
+            if (player.queue.current)
+                await player.queue.utils.save();
+        }
+        return this.NodeManager.LavalinkManager.emit("trackStart", player, player.queue.current, payload);
     }
     /** @private util function for handling trackEnd event */
     async trackEnd(player, track, payload) {
+        const trackToUse = track || await this.getTrackOfPayload(payload);
+        // If a track was forcibly played
+        if (payload.reason === "replaced") {
+            return this.NodeManager.LavalinkManager.emit("trackEnd", player, trackToUse, payload);
+        }
         // If there are no songs in the queue
         if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
             return this.queueEnd(player, track, payload);
-        // If a track was forcibly played
-        if (payload.reason === "replaced")
-            return this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
         // If a track had an error while starting
         if (["loadFailed", "cleanup"].includes(payload.reason)) {
             await queueTrackEnd(player);
             // if no track available, end queue
             if (!player.queue.current)
-                return this.queueEnd(player, track, payload);
+                return this.queueEnd(player, trackToUse, payload);
             // fire event
-            this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
+            this.NodeManager.LavalinkManager.emit("trackEnd", player, trackToUse, payload);
             // play track if autoSkip is true
             return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
         }
         // remove tracks from the queue
         if (player.repeatMode !== "track" || player.get("internal_skipped"))
             await queueTrackEnd(player);
-        else if (player.queue.current && !player.queue.current?.pluginInfo?.clientData?.previousTrack) { // If there was a current Track already and repeatmode === true, add it to the queue.
-            player.queue.previous.unshift(player.queue.current);
+        else if (trackToUse && !trackToUse?.pluginInfo?.clientData?.previousTrack) { // If there was a current Track already and repeatmode === true, add it to the queue.
+            player.queue.previous.unshift(trackToUse);
             if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
                 player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
             await player.queue.utils.save();
@@ -887,60 +964,65 @@ export class LavalinkNode {
         player.set("internal_skipped", false);
         // if no track available, end queue
         if (!player.queue.current)
-            return this.queueEnd(player, track, payload);
+            return this.queueEnd(player, trackToUse, payload);
         // fire event
-        this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
+        this.NodeManager.LavalinkManager.emit("trackEnd", player, trackToUse, payload);
         // play track if autoSkip is true
         return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
     /** @private util function for handling trackStuck event */
     async trackStuck(player, track, payload) {
-        this.NodeManager.LavalinkManager.emit("trackStuck", player, track, payload);
+        this.NodeManager.LavalinkManager.emit("trackStuck", player, track || await this.getTrackOfPayload(payload), payload);
         // If there are no songs in the queue
         if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
-            return this.queueEnd(player, track, payload);
+            return this.queueEnd(player, track || await this.getTrackOfPayload(payload), payload);
         // remove the current track, and enqueue the next one
         await queueTrackEnd(player);
         // if no track available, end queue
         if (!player.queue.current)
-            return this.queueEnd(player, track, payload);
+            return this.queueEnd(player, track || await this.getTrackOfPayload(payload), payload);
         // play track if autoSkip is true
         return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
     /** @private util function for handling trackError event */
     async trackError(player, track, payload) {
-        this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
+        this.NodeManager.LavalinkManager.emit("trackError", player, track || await this.getTrackOfPayload(payload), payload);
         return; // get's handled by trackEnd
         // If there are no songs in the queue
         if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
-            return this.queueEnd(player, track, payload);
+            return this.queueEnd(player, track || await this.getTrackOfPayload(payload), payload);
         // remove the current track, and enqueue the next one
         await queueTrackEnd(player);
         // if no track available, end queue
         if (!player.queue.current)
-            return this.queueEnd(player, track, payload);
+            return this.queueEnd(player, track || await this.getTrackOfPayload(payload), payload);
         // play track if autoSkip is true
         return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
     /** @private util function for handling socketClosed event */
     socketClosed(player, payload) {
-        return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
+        this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
+        // i don't think this is needed.
+        // this.socket = null;
+        // // causing a socket reconnect
+        // this.connect();
+        return;
     }
     /** @private util function for handling SponsorBlock Segmentloaded event */
-    SponsorBlockSegmentLoaded(player, track, payload) {
-        return this.NodeManager.LavalinkManager.emit("SegmentsLoaded", player, track, payload);
+    async SponsorBlockSegmentLoaded(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("SegmentsLoaded", player, track || await this.getTrackOfPayload(payload), payload);
     }
     /** @private util function for handling SponsorBlock SegmentSkipped event */
-    SponsorBlockSegmentSkipped(player, track, payload) {
-        return this.NodeManager.LavalinkManager.emit("SegmentSkipped", player, track, payload);
+    async SponsorBlockSegmentSkipped(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("SegmentSkipped", player, track || await this.getTrackOfPayload(payload), payload);
     }
     /** @private util function for handling SponsorBlock Chaptersloaded event */
-    SponsorBlockChaptersLoaded(player, track, payload) {
-        return this.NodeManager.LavalinkManager.emit("ChaptersLoaded", player, track, payload);
+    async SponsorBlockChaptersLoaded(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("ChaptersLoaded", player, track || await this.getTrackOfPayload(payload), payload);
     }
     /** @private util function for handling SponsorBlock Chaptersstarted event */
-    SponsorBlockChapterStarted(player, track, payload) {
-        return this.NodeManager.LavalinkManager.emit("ChapterStarted", player, track, payload);
+    async SponsorBlockChapterStarted(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("ChapterStarted", player, track || await this.getTrackOfPayload(payload), payload);
     }
     /**
      * Get the current sponsorblocks for the sponsorblock plugin