muthera 1.0.2

package/src/index.d.ts

@@ -0,0 +1,407 @@
+import { EventEmitter } from "events";
+import { Collection } from "@discordjs/collection";
+
+export declare class Track {
+    constructor(data: any, requester: any, node: Node);
+
+    public track: String;
+    public info: {
+        identifier: String;
+        seekable: Boolean;
+        author: String;
+        length: Number;
+        stream: Boolean;
+        sourceName: String;
+        title: String;
+        uri: String;
+        thumbnail: String | null;
+        requester: any;
+    };
+
+    public resolve(muthera: muthera): Promise<Track>;
+}
+
+export interface RestOptions {
+    secure: Boolean;
+    host: String;
+    port: Number;
+    sessionId: String;
+    password: String;
+}
+
+interface RequestOptions {
+    guildId: String;
+    data: any;
+}
+
+interface RestResponse {
+
+}
+
+export declare class Rest extends EventEmitter {
+    constructor(muthera: muthera, options: RestOptions);
+    public muthera: muthera;
+    public url: String
+    public sessionId: RestOptions["sessionId"];
+    public password: RestOptions["password"];
+    public calls: Number;
+
+    public setSessionId(sessionId: String): void;
+    public makeRequest(method: String, endpoint: String, body?: any): Promise<RestResponse | null>;
+    public getPlayers(): Promise<RestResponse | null>;
+    public updatePlayer(options: RequestOptions): Promise<void>;
+    public destroyPlayer(guildId: String): Promise<RestResponse | null>;
+    public getTracks(identifier: String): Promise<void>;
+    public decodeTrack(track: String, node?: any): Promise<void>;
+    public decodeTracks(tracks: any[]): Promise<void>;
+    public getStats(): Promise<void>;
+    public getInfo(): Promise<void>;
+    public getRoutePlannerStatus(): Promise<void>;
+    public getRoutePlannerAddress(address: String): Promise<void>;
+    public parseResponse(req: any): Promise<RestResponse | null>;
+}
+
+export declare class Queue<T> extends Array<T>{
+    get size(): Number;
+    get first(): T | null;
+
+    add(track: T): this;
+    remove(index: Number): T;
+    clear(): void;
+    shuffle(): void;
+}
+
+export interface PlayerOptions {
+    guildId: String;
+    textChannel?: String;
+    voiceChannel?: String;
+    deaf?: Boolean;
+    mute?: Boolean;
+    volume?: Number;
+    loop?: String;
+}
+
+export type LoopOption = "none" | "track" | "queue";
+
+export declare class Player extends EventEmitter {
+    constructor(muthera: muthera, node: Node, options: PlayerOptions);
+    public muthera: muthera;
+    public node: Node;
+    public options: PlayerOptions;
+    public guildId: String;
+    public textChannel: String;
+    public voiceChannel: String;
+    public connection: Connection;
+    public deaf: Boolean;
+    public mute: Boolean;
+    public volume: Number;
+    public loop: String;
+    public data: {};
+    public queue: Queue<Track>;
+    public position: Number;
+    public current: Track;
+    public previous: Track | null;
+    public playing: Boolean;
+    public paused: Boolean;
+    public connected: Boolean;
+    public timestamp: Number;
+    public ping: Number;
+    public isAutoplay: Boolean;
+
+    public play(): Promise<Player>;
+
+    public autoplay(player: Player): Promise<Player>;
+
+    public connect(options?: {
+        guildId: String;
+        voiceChannel: String;
+        deaf?: Boolean;
+        mute?: Boolean;
+    }): void;
+
+    public stop(): Player;
+    public pause(toggle?: Boolean): Player;
+    public seek(position: Number): void;
+    public setVolume(volume: Number): Player;
+    public setLoop(mode: LoopOption): Player;
+    public setTextChannel(channel: String): Player;
+    public setVoiceChannel(channel: String, options?: {
+        mute?: Boolean;
+        deaf?: Boolean;
+    }): Player;
+
+    public disconnect(): Player;
+    public destroy(): void;
+    private handleEvent(payload: any): void;
+    private trackStart(player: Player, track: Track, payload: any): void;
+    private trackEnd(player: Player, track: Track, payload: any): void;
+    private trackError(player: Player, track: Track, payload: any): void;
+    private trackStuck(player: Player, track: Track, payload: any): void;
+    private socketClosed(player: Player, payload: any): void;
+    private set(key: String, value: any): void;
+    private get(key: String): any;
+    private send(data: any): void;
+}
+
+export type SearchPlatform = "ytsearch" | "ytmsearch" | "scsearch";
+export type nodeResponse = {
+    /**
+     * Array of Loaded Tracks
+     */
+    tracks: Array<Track>;
+    /**
+     * Load Type - "track", "playlist", "search", "error"
+     */
+    loadType: String
+    /**
+     * Playlist Info
+     */
+    playlistInfo?: {
+        name: String;
+        selectedTrack: Number;
+    };
+}
+
+export type mutheraOptions = {
+    send: (payload: {
+        op: Number;
+        d: {
+            guild_id: String;
+            channel_id: String;
+            self_deaf: Boolean;
+            self_mute: Boolean;
+        }
+    }) => void;
+    defaultSearchPlatform?: SearchPlatform;
+}
+
+type k = String;
+type v = any;
+
+export declare class muthera extends EventEmitter {
+    constructor(client: any, nodes: {
+        name?: String;
+        host: String;
+        port: Number;
+        password: String;
+        secure: Boolean;
+    }, options: mutheraOptions);
+    public client: any;
+    public nodes: Array<LavalinkNode>;
+    public nodeMap: Collection<k, Node>;
+    public players: Collection<k, Player>;
+    public options: mutheraOptions;
+    public clientId: String;
+    public initiated: Boolean;
+    public send: mutheraOptions["send"];
+    public defaultSearchPlatform: String;
+
+    public readonly leastUsedNodes: Array<LavalinkNode>;
+
+    public init(clientId: String): this;
+
+    public createNode(options: any): Node;
+
+    public destroyNode(identifier: String): void;
+
+    public updateVoiceState(packet: any): void;
+
+    public fetchRegion(region: String): Array<LavalinkNode>;
+
+    public createConnection(options: {
+        guildId: String;
+        voiceChannel: String;
+        textChannel: String;
+        deaf?: Boolean;
+    }): Player;
+
+    public createPlayer(node: Node, options: PlayerOptions): Player;
+
+    public removeConnection(guildId: String): void;
+
+    public resolve(params: {
+        query: String;
+        source?: String;
+        requester: any;
+    }): Promise<nodeResponse>;
+
+
+    public get(guildId: String): Player;
+
+    public on(event: "nodeConnect", listener: (node: Node) => void): this;
+    public on(event: "nodeReconnect", listener: (node: Node) => void): this;
+    public on(event: "nodeDisconnect", listener: (node: Node, reason: String) => void): this;
+    public on(event: "nodeCreate", listener: (node: Node) => void): this;
+    public on(event: "nodeDestroy", listener: (node: Node) => void): this;
+    public on(event: "nodeError", listener: (node: Node, error: Error) => void): this;
+
+    public on(event: "trackStart", listener: (player: Player, track: Track, payload: any) => void): this;
+    public on(event: "trackEnd", listener: (player: Player, track: Track, payload: any) => void): this;
+    public on(event: "trackError", listener: (player: Player, track: Track, payload: any) => void): this;
+    public on(event: "trackStuck", listener: (player: Player, track: Track, payload: any) => void): this;
+
+    public on(event: "socketClosed", listener: (player: Player, payload: any) => void): this;
+
+    public on(event: "playerCreate", listener: (player: Player) => void): this;
+    public on(event: "playerDisconnect", listener: (player: Player) => void): this;
+    public on(event: "playerMove", listener: (player: Player, oldChannel: String, newChannel: String) => void): this;
+    public on(event: "playerUpdate", listener: (player: Player, payload: any) => void): this;
+
+    public on(event: "queueEnd", listener: (player: Player) => void): this;
+    public on(event: "debug", listener: (message: String) => void): this;
+}
+
+export type LavalinkNode = {
+    /**
+     * The name of the node
+     */
+    name?: String;
+    /**
+     * The IP of the node
+     */
+    host: String;
+    /**
+     * The port of the node
+     */
+    port: Number;
+    /**
+     * The password of the node
+     */
+    password: String;
+    /**
+     * Is node connection secured by SSL ?
+     */
+    secure: Boolean;
+}
+
+export type NodeOptions = {
+    /**
+     * The send function of the node
+     */
+    send: (payload: {
+        op: Number;
+        d: {
+            guild_id: String;
+            channel_id: String;
+            self_deaf: Boolean;
+            self_mute: Boolean;
+        }
+    }) => void;
+    /**
+     * The resume key of the node
+     */
+    resumeKey?: String;
+    /**
+     * The session id of the node
+     */
+    sessionId?: String;
+    /**
+     * The resume timeout of the node
+     */
+    resumeTimeout?: Number;
+    /**
+     * The reconnect timeout of the node
+     */
+    reconnectTimeout?: Number;
+    /**
+     * The reconnect tries of the node
+     */
+    reconnectTries?: Number;
+}
+
+export declare class Node {
+    constructor(muthera: muthera, node: LavalinkNode, options: NodeOptions);
+    public muthera: muthera;
+
+    public name: LavalinkNode["name"];
+    public host: LavalinkNode["host"];
+    public port: LavalinkNode["port"];
+    public password: LavalinkNode["password"];
+    public secure: LavalinkNode["secure"];
+
+    public rest: Rest;
+    public wsUrl: String;
+    public restUrl: String;
+    private ws: null;
+
+    public send: NodeOptions["send"];
+    public resumeKey: NodeOptions["resumeKey"];
+    public sessionId: NodeOptions["sessionId"];
+    public region: String | null;
+    public resumeTimeout: NodeOptions["resumeTimeout"];
+    public reconnectTimeout: NodeOptions["reconnectTimeout"];
+    public reconnectTries: NodeOptions["reconnectTries"];
+
+    public reconnectAttempt: Number;
+    public reconnectAttempted: Number;
+
+    public connected: Boolean;
+    public reconnecting: Boolean;
+    public stats: {
+        players: 0,
+        playingPlayers: 0,
+        uptime: 0,
+        memory: {
+            free: 0,
+            used: 0,
+            allocated: 0,
+            reservable: 0,
+        },
+        cpu: {
+            cores: 0,
+            systemLoad: 0,
+            lavalinkLoad: 0,
+        },
+        frameStats: {
+            sent: 0,
+            nulled: 0,
+            deficit: 0,
+        },
+    };
+
+    public connect(): void;
+    public open(): void;
+    public error(event: any): void;
+    public message(msg: any): void;
+    public close(event: any, reason: String): void;
+    public reconnect(): void;
+    public disconnect(): void;
+    readonly penalties: Number;
+}
+
+export type Voice = {
+    /**
+     * The voice session id
+     */
+    sessionId: String,
+    /**
+     * The voice event
+     */
+    event: null,
+    /**
+     * The voice endpoint
+     */
+    endpoint: String
+}
+
+export declare class Connection {
+    constructor(player: Player);
+    public player: Player;
+    public sessionId: String;
+    public voice: Voice;
+    public region: String;
+    public self_deaf: Boolean;
+    public self_mute: Boolean;
+    public voiceChannel: String;
+
+    public setServerUpdate(data: { endpoint: String; token: String }): void;
+
+    public setStateUpdate(data: {
+        session_id: String;
+        channel_id: String;
+        self_deaf: Boolean;
+        self_mute: Boolean;
+    }): void;
+
+    private updatePlayerVoiceData(): void;
+}

package/src/index.js

@@ -0,0 +1,9 @@
+const { Connection } = require("./structures/mutheraConnection");
+const { Node } = require("./structures/mutheraNode");
+const { Muthera } = require("./structures/Muthera");
+const { Player } = require("./structures/mutheraPlayer");
+const { Queue } = require("./structures/mutheraQueue");
+const { Rest } = require("./structures/mutheraRest");
+const { Track } = require("./structures/mutheraTrack");
+
+module.exports = { Connection, Node, Muthera, Player, Queue, Rest, Track };

package/src/structures/Muthera.js

@@ -0,0 +1,191 @@
+const { EventEmitter } = require("events");
+const { Node } = require("./mutheraNode");
+const { Player } = require("./mutheraPlayer");
+const { Track } = require("./mutheraTrack");
+const { Collection } = require("@discordjs/collection");
+
+class Muthera extends EventEmitter {
+  constructor(client, nodes, options) {
+    super();
+    if (!client)
+      throw new Error("Client option must be present to initialize muthera.");
+    if (!nodes)
+      throw new Error("Node option must be present to initialize muthera.");
+    if (!options.send)
+      throw new Error("Send function must be present to initialize muthera.");
+
+    this.client = client;
+    this.nodes = nodes;
+    this.nodeMap = new Collection();
+    this.players = new Collection();
+    this.options = options;
+    this.clientId = null;
+    this.initiated = false;
+    this.send = options.send || null;
+    this.defaultSearchPlatform = options.defaultSearchPlatform || "ytsearch";
+    this.tracks = [];
+    this.loadType = null;
+    this.playlistInfo = null;
+  }
+
+  get leastUsedNodes() {
+    return [...this.nodeMap.values()]
+      .filter((node) => node.connected)
+      .sort((a, b) => b.rest.calls - a.rest.calls);
+  }
+
+  init(clientId) {
+    if (this.initiated) return this;
+    this.clientId = clientId;
+    this.nodes.forEach((node) => this.createNode(node));
+    this.initiated = true;
+  }
+
+  createNode(options) {
+    const node = new Node(this, options, this.options);
+    this.nodeMap.set(options.name || options.host, node);
+    node.connect();
+
+    this.emit("nodeCreate", node);
+    return node;
+  }
+
+  destroyNode(identifier) {
+    const node = this.nodeMap.get(identifier);
+    if (!node) return;
+    node.disconnect();
+    this.nodeMap.delete(identifier);
+    this.emit("nodeDestroy", node);
+  }
+
+  updateVoiceState(packet) {
+    if (!["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(packet.t))
+      return;
+    const player = this.players.get(packet.d.guild_id);
+    if (!player) return;
+
+    if (packet.t === "VOICE_SERVER_UPDATE") {
+      player.connection.setServerUpdate(packet.d);
+    } else if (packet.t === "VOICE_STATE_UPDATE") {
+      if (packet.d.user_id !== this.clientId) return;
+      player.connection.setStateUpdate(packet.d);
+    }
+  }
+
+  fetchRegion(region) {
+    const nodesByRegion = [...this.nodeMap.values()]
+      .filter(
+        (node) =>
+          node.connected && node.regions?.includes(region?.toLowerCase())
+      )
+      .sort((a, b) => {
+        const aLoad = a.stats.cpu
+          ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100
+          : 0;
+        const bLoad = b.stats.cpu
+          ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100
+          : 0;
+        return aLoad - bLoad;
+      });
+
+    return nodesByRegion;
+  }
+
+  createConnection(options) {
+    if (!this.initiated)
+      throw new Error("You have to initialize muthera in your event.");
+
+    const player = this.players.get(options.guildId);
+    if (player) return player;
+
+    if (this.leastUsedNodes.length === 0)
+      throw new Error("No nodes are available.");
+
+    let node;
+    if (options.node) {
+      node = this.nodeMap.get(options.node);
+    } else {
+      node = this.nodeMap.get(this.leastUsedNodes[0].name);
+    }
+
+    if (!node) throw new Error("No nodes are available.");
+
+    return this.createPlayer(node, options);
+  }
+
+  createPlayer(node, options) {
+    const player = new Player(this, node, options);
+    this.players.set(options.guildId, player);
+
+    player.connect(options);
+
+    this.emit("playerCreate", player);
+    return player;
+  }
+
+  destroyPlayer(guildId) {
+    const player = this.players.get(guildId);
+    if (!player) return;
+    player.destroy();
+    this.players.delete(guildId);
+
+    this.emit("playerDestroy", player);
+  }
+
+  removeConnection(guildId) {
+    this.players.get(guildId)?.destroy();
+    this.players.delete(guildId);
+  }
+
+  async resolve({ query, source, requester }) {
+    try {
+      if (!this.initiated)
+        throw new Error("You have to initialize muthera in your event.");
+
+      const sources = source || this.defaultSearchPlatform;
+
+      const node = this.leastUsedNodes[0];
+      if (!node) throw new Error("No nodes are available.");
+
+      const regex = /^https?:\/\//;
+      const identifier = regex.test(query) ? query : `${sources}:${query}`;
+
+      let response = await node.rest.makeRequest(
+        `GET`,
+        `/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`
+      );
+
+      if (response.loadType === "track") {
+        this.tracks = [new Track(response.data, requester, node)];
+      } else if (response.loadType === "playlist") {
+        this.tracks = response.data.tracks.map(
+          (track) => new Track(track, requester, node)
+        );
+      } else if (
+        response.loadType === "error" ||
+        response.loadType === "empty"
+      ) {
+        this.tracks = null;
+      } else {
+        this.tracks = response.data.map(
+          (track) => new Track(track, requester, node)
+        );
+      }
+
+      this.playlistInfo = response.data.info ?? null;
+      this.loadType = response.loadType ?? null;
+      return this;
+    } catch (error) {
+      throw new Error(error);
+    }
+  }
+
+  get(guildId) {
+    const player = this.players.get(guildId);
+    if (!player)
+      throw new Error(`No player were found for guildId: ${guildId}.`);
+    return player;
+  }
+}
+
+module.exports = { Muthera };

package/src/structures/mutheraConnection.js

@@ -0,0 +1,66 @@
+class Connection {
+  /**
+   * @param {import ("../index").Player} player
+   */
+  constructor(player) {
+    this.player = player;
+    this.sessionId = null;
+    this.voice = {
+      event: null,
+      endpoint: null,
+      sessionId: null,
+    };
+    this.self_deaf = false;
+    this.self_mute = false;
+    this.region = null;
+    this.voiceChannel = player.voiceChannel;
+  }
+
+  setServerUpdate(data) {
+    const { endpoint, token } = data;
+
+    if (!endpoint) throw new Error("Invalid session. Please try again.");
+
+    this.voice.endpoint = endpoint;
+    this.voice.token = token;
+    this.region = endpoint.split(".").shift()?.replace(/[0-9]/g, "") || null;
+
+    setTimeout(() => {
+      this.player.pause(false)
+    }, 5000);
+
+    this.updatePlayerVoiceData();
+  }
+
+  setStateUpdate(data) {
+    const { session_id, channel_id, self_deaf, self_mute } = data;
+
+    if (
+      this.player.voiceChannel &&
+      channel_id &&
+      this.player.voiceChannel !== channel_id
+    ) {
+      this.player.muthera.emit("playerMove", this.player.voiceChannel, channel_id);
+      this.player.voiceChannel = channel_id;
+      this.voiceChannel = channel_id;
+    }
+
+    this.self_deaf = self_deaf;
+    this.self_mute = self_mute;
+    this.voice.sessionId = session_id || null;
+  }
+
+  updatePlayerVoiceData() {
+    this.player.muthera.emit(
+      "debug",
+      this.player.node.name,
+      `Update player data: ${JSON.stringify({ voice: this.voice })}`
+    );
+    this.player.node.rest.updatePlayer({
+      guildId: this.player.guildId,
+      data: { voice: this.voice },
+    });
+  }
+}
+
+module.exports = { Connection };