poru 1.1.2 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poru",
-  "version": "1.1.2",
+  "version": "1.1.6",
   "description": "A stable and powefull lavalink client with so many features",
   "main": "index.js",
   "scripts": {

package/src/Player.js

@@ -56,6 +56,9 @@ class Player extends EventEmitter {
             return nulll;
         }
         this.currentTrack = this.queue.shift();
+        if(!this.currentTrack.track){
+          this.currentTrack = await this.currentTrack.resolve(this.manager);
+        }
         this.playing = true;
         this.timestamp = Date.now();
         this.node.send({

package/src/Poru.js

@@ -6,13 +6,13 @@ const Player = require("./Player");
 const Node = require("./Node");
 const Response = require("./guild/Response");
 const config = require("./config.json")
-
+const Spotify = require("./platform/Spotify")
 class Poru extends EventEmitter {
     constructor(client, nodes, options = {}) {
         super();
         if (!client) throw new Error("[Poru Error] you did't provide a valid client");
         if (!nodes) throw new Error("[Poru Error] you did't provide a lavalink nodes");
-        if(!options) throw new Error("[Poru Error] options must be provided!")
+        if (!options) throw new Error("[Poru Error] options must be provided!")
         this.client = client;
         this._nodes = nodes;
         this.nodes = new Map();
@@ -29,7 +29,7 @@ class Poru extends EventEmitter {
 
     //create a node and connect it with lavalink
     addNode(options) {
-        const node = new Node(this, options,this.options);
+        const node = new Node(this, options, this.options);
         if (options.name) {
             this.nodes.set(options.name || options.host, node);
             node.connect();
@@ -41,16 +41,16 @@ class Poru extends EventEmitter {
     }
 
     //remove node and destroy web socket connection
-    removeNode(identifier){
+    removeNode(identifier) {
         const node = this.nodes.get(identifier);
         if (!node) return;
         node.destroy();
         this.nodes.delete(identifier)
-      }
+    }
     //create  connection with discord voice channel
     createConnection(data = {}) {
         const player = this.players.get(data.guild.id || data.guild);
-        if (player){
+        if (player) {
             return player;
         }
         this.sendData({
@@ -74,47 +74,56 @@ class Poru extends EventEmitter {
             const guild = client.guilds.cache.get(data.d.guild_id);
             if (guild) guild.shard.send(data);
         }
-        client.on("raw",async packet =>{
+        client.on("raw", async packet => {
             await this.#packetUpdate(packet);
         })
+        
         this._nodes.forEach((node) => this.addNode(node));
+
+
+ if (this.options.spotify && this.options.spotify.clientID && this.options.spotify.clientSecret) {
+            this.spotify = new Spotify(this, {
+                clientID: this.options.clientID,
+                clientSecret: this.options.clientSecret 
+                })
+        }
         console.log(`Thanks for using Poru`)
     }
 
     setServersUpdate(data) {
-            let guild = data.guild_id
-            this.voiceServers.set(guild, data);
-            const server = this.voiceServers.get(guild);
-            const state = this.voiceStates.get(guild);
-            if (!server) return false;
-            const player = this.players.get(guild);
-            if (!player) return false;
-    
-            player.connect({
-                sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
-                event: server,
-            });
-    
-            return true;
-         } 
+        let guild = data.guild_id
+        this.voiceServers.set(guild, data);
+        const server = this.voiceServers.get(guild);
+        const state = this.voiceStates.get(guild);
+        if (!server) return false;
+        const player = this.players.get(guild);
+        if (!player) return false;
+
+        player.connect({
+            sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
+            event: server,
+        });
+
+        return true;
+    }
 
     setStateUpdate(data) {
         if (data.user_id !== this.user) return;
         if (data.channel_id) {
             const guild = data.guild_id;
-     
+
             this.voiceStates.set(data.guild_id, data);
             const server = this.voiceServers.get(guild);
             const state = this.voiceStates.get(guild);
             if (!server) return false;
             const player = this.players.get(guild);
             if (!player) return false;
-    
+
             player.connect({
                 sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
                 event: server,
             });
-    
+
             return true;
         }
         this.voiceServers.delete(data.guild_id);
@@ -122,15 +131,15 @@ class Poru extends EventEmitter {
     }
 
     #packetUpdate(packet) {
-    if (!['VOICE_STATE_UPDATE', 'VOICE_SERVER_UPDATE'].includes(packet.t)) return;
+        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"){ 
-                   this.setServersUpdate(packet.d);
+        if (packet.t === "VOICE_SERVER_UPDATE") {
+            this.setServersUpdate(packet.d);
         }
-         if (packet.t === "VOICE_STATE_UPDATE"){
-             this.setStateUpdate(packet.d);
+        if (packet.t === "VOICE_STATE_UPDATE") {
+            this.setStateUpdate(packet.d);
         }
     }
 
@@ -156,7 +165,7 @@ class Poru extends EventEmitter {
         if (!node) throw new Error("[Poru Error] No nodes are avalible");
 
         // eslint-disable-next-line new-cap
-        const player = new Player(this,node, data);
+        const player = new Player(this, node, data);
         this.players.set(guild, player);
         player.connect()
         return player;
@@ -168,13 +177,16 @@ class Poru extends EventEmitter {
     async resolve(track, source) {
         const node = this.leastUsedNodes[0];
         if (!node) throw new Error("No nodes are available.");
+        if(this.spotify &&  this.spotify.check(track)){
+             return await this.spotify.resolve(track);
+        }
         const regex = /^https?:\/\//;
         if (!regex.test(track)) {
             // eslint-disable-next-line no-param-reassign
             track = `${source || "yt"}search:${track}`;
         }
         const result = await this.#fetch(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
-     
+
         if (!result) throw new Error("[Poru Error] No tracks found.");
         return new Response(result);
     }
@@ -192,7 +204,7 @@ class Poru extends EventEmitter {
         return fetch(`http${node.secure ? "s" : ""}://${node.host}:${node.port}/${endpoint}?${param}`, {
             headers: {
                 Authorization: node.password,
-               
+
             },
         })
             .then((r) => r.json())

package/src/guild/Filter.js

@@ -141,7 +141,6 @@ class Filters {
       }
 
     updateFilters(){
-        console.log(this.node.send)
         const { volume, equalizer, karaoke, timescale, tremolo, vibrato, rotation, distortion, channelMix, lowPass } = this;
         this.node.send({
             op:"filters",
@@ -165,4 +164,4 @@ class Filters {
 
 
 
-module.exports = Filters;
+module.exports = Filters;

package/src/guild/Track.js

@@ -1,20 +1,61 @@
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 class Track {
-    constructor(data) {
-      this.track = data.track
-      this.info = {
-        identifier : data.info.identifier,
-        isSeekable : data.info.isSeekable,
-        author : data.info.author,
-        length : data.info.length,
-        isStream : data.info.isStream,
-        position : data.info.position,
-        sourceName:data.info.sourceName,
-        title : data.info.title,
-        uri : data.info.uri,
-        image : `https://i.ytimg.com/vi/${data.info.identifier}/maxresdefault.jpg` || null
-    
+  constructor(data) {
+    this.track = data.track
+    this.info = {
+      identifier: data.info.identifier,
+      isSeekable: data.info.isSeekable,
+      author: data.info.author,
+      length: data.info.length,
+      isStream: data.info.isStream,
+      sourceName: data.info.sourceName,
+      title: data.info.title,
+      uri: data.info.uri,
+      image: `https://i.ytimg.com/vi/${data.info.identifier}/maxresdefault.jpg` || null
+
+    }
+  }
+
+  async resolve(manager) {
+
+    const query = [this.info.author, this.info.title].filter((x) => !!x).join(' - ');
+
+
+    const result = await manager.resolve(query);
+    if (!result || !result.tracks.length) return;
+
+    if (this.info.author) {
+      const author = [this.info.author, `${this.info.author} - Topic`];
+      const officialAudio = result.tracks.find(
+        (track) =>
+          author.some((name) => new RegExp(`^${escapeRegExp(name)}$`, 'i').test(track.info.author)) ||
+          new RegExp(`^${escapeRegExp(this.info.title)}$`, 'i').test(track.info.title),
+      );
+      if (officialAudio) {
+        this.info.identifier = officialAudio.info.identifier
+        this.image =`https://i.ytimg.com/vi/${this.info.identifier}/maxresdefault.jpg`
+        this.track = officialAudio.track;
+        return this
       }
+    }
+    if (this.info.length) {
+      const sameDuration = result.tracks.find(
+        (track) =>
+          track.info.length >= (this.info.length ? this.length : 0) - 2000 &&
+          track.info.length <= (this.info.length ? this.length : 0) + 2000,
+      );
+      if (sameDuration) {
+        this.info.identifier = sameDuration.info.identifier
+        this.image =`https://i.ytimg.com/vi/${this.info.identifier}/maxresdefault.jpg`
+        this.track = sameDuration.track;
+        return this
       }
+    }
+    this.info.identifier = result.tracks[0].info.identifier
+    this.image =`https://i.ytimg.com/vi/${this.info.identifier}/maxresdefault.jpg`
+    this.track = result.tracks[0].track;
+    return this
+  }
 }
 
 module.exports = Track;

package/src/platform/Spotify.js

@@ -0,0 +1,253 @@
+const fetch = (...args) => import('node-fetch').then(({
+    default: fetch
+}) => fetch(...args));
+const Track = require("../guild/Track")
+class Spotify {
+    constructor(manager) {
+        this.manager = manager;
+        this.baseURL = "https://api.spotify.com/v1"
+        this.spotifyPattern = /^(?:https:\/\/open\.spotify\.com\/(?:user\/[A-Za-z0-9]+\/)?|spotify:)(album|playlist|track|artist)(?:[/:])([A-Za-z0-9]+).*$/
+        this.clientID = manager.options.spotify.clientID;
+        this.clientSecret = manager.options.spotify.clientSecret
+        this.authorization = Buffer
+            .from(`${this.clientID}:${this.clientSecret}`)
+            .toString("base64");
+        this.interval = 0;
+    }
+
+    check(url) {
+        return this.spotifyPattern.test(url);
+    }
+
+    async requestToken() {
+        if (this.nextRequest) return;
+
+        try {
+            const data = await fetch("https://accounts.spotify.com/api/token?grant_type=client_credentials", {
+                method: "POST",
+                headers: {
+                    Authorization: `Basic ${this.authorization}`,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                }
+            })
+
+            const body = await data.json();
+
+            this.token = `Bearer ${body.access_token}`;
+            this.interval = body.expires_in * 1000
+        } catch (e) {
+            if (e.status === 400) {
+                throw new Error("Invalid Spotify client.")
+            }
+        }
+    }
+
+    async renew() {
+        if (Date.now() >= this.interval) {
+            await this.requestToken();
+        }
+    }
+
+    async requestData(endpoint) {
+        await this.renew();
+
+        const req = await fetch(`${this.baseURL}${/^\//.test(endpoint) ? endpoint : `/${endpoint}`}`, {
+            headers: { Authorization: this.token }
+        })
+        const data = await req.json()
+        return data
+    }
+
+
+    async resolve(url) {
+        if (!this.token) await this.requestToken()
+        const [, type, id] = await this.spotifyPattern.exec(url) ?? [];
+
+        switch (type) {
+
+            case "playlist":
+                {
+                    return this.fetchPlaylist(id)
+                }
+            case "track":
+                {
+                    return this.fetchTrack(id)
+                }
+            case "album":
+                {
+                    return this.fetchAlbum(id)
+                }
+            case "artist":
+                {
+                    return this.fetchArtist(id);
+                }
+
+            default: {
+                return this.manager.resolve(url)
+            }
+        }
+
+    }
+
+    async fetchPlaylist(id) {
+        try {
+            const playlist = await this.requestData(`/playlists/${id}`)
+            await this.fetchPlaylistTracks(playlist);
+            const unresolvedPlaylistTracks = await Promise.all(playlist.tracks.items.map(x => this.buildUnresolved(x.track)))
+
+
+            return this.buildResponse(
+                "PLAYLIST_LOADED",
+                unresolvedPlaylistTracks,
+                playlist.name
+            );
+
+        } catch (e) {
+            return this.buildResponse(e.status === 404 ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
+        }
+    }
+
+    async fetchAlbum(id) {
+        try {
+            const album = await this.requestData(`/albums/${id}`)
+
+            const unresolvedPlaylistTracks = await Promise.all(album.tracks.items.map(x => this.buildUnresolved(x)));
+            return this.buildResponse(
+                "PLAYLIST_LOADED",
+                unresolvedPlaylistTracks,
+                album.name
+            );
+
+        } catch (e) {
+            return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
+        }
+    }
+
+    async fetchArtist(id) {
+        try {
+            const artist = await this.requestData(`/artists/${id}`)
+
+            const data = await this.requestData(`/artists/${id}/top-tracks?market=US`)
+            const unresolvedPlaylistTracks = await Promise.all(data.tracks.map(x => this.buildUnresolved(x)));
+
+            return this.buildResponse(
+                "PLAYLIST_LOADED",
+                unresolvedPlaylistTracks,
+                artist.name
+            );
+        } catch (e) {
+            return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
+        }
+
+    }
+
+    async fetchTrack(id) {
+        try {
+            const data = await this.requestData(`/tracks/${id}`)
+            const unresolvedTrack = await this.buildUnresolved(data);
+            return this.buildResponse(
+                "TRACK_LOADED",
+                [unresolvedTrack]
+            );
+        } catch (e) {
+            return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
+        }
+    }
+
+    async fetch(query) {
+        try {
+
+            if (this.check(query)) return this.resolve(query)
+
+            const data = await this.requestData(`/search/?q="${query}"&type=artist,album,track`)
+
+            const unresolvedTrack = await this.buildUnresolved(data.tracks.items[0]);
+
+            return this.buildResponse(
+                "TRACK_LOADED",
+                [unresolvedTrack]
+            );
+        } catch (e) {
+            return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
+        }
+    }
+
+    async fetchPlaylistTracks(spotifyPlaylist) {
+        let nextPage = spotifyPlaylist.tracks.next;
+        let pageLoaded = 1;
+        while (nextPage) {
+            if (!nextPage) break;
+            const req = await fetch(nextPage, {
+                headers: { Authorization: this.token }
+            })
+            const body = await req.json()
+            if (body.error) break;
+            spotifyPlaylist.tracks.items.push(...body.items);
+
+            nextPage = body.next;
+            pageLoaded++;
+        }
+    }
+
+
+
+    async buildUnresolved(track) {
+        if (!track) throw new ReferenceError("The Spotify track object was not provided");
+
+        return new Track({
+            track: "",
+            info: {
+                sourceName: 'spotify',
+                identifier: track.id,
+                isSeekable: true,
+                author: track.artists[0] ? track.artists[0].name : 'Unknown',
+                length: track.duration_ms,
+                isStream: false,
+                title: track.name,
+                uri: `https://open.spotify.com/track/${track.id}`,
+                image: track.album?.images[0]?.url,
+            },
+        })
+
+
+
+    }
+
+    async fetchMetaData(track) {
+
+        const fetch = await this.manager.resolve(`${track.info.title} ${track.info.author}`)
+        return fetch.tracks[0];
+    }
+
+    async buildTrack(unresolvedTrack) {
+        const lavaTrack = await this.fetchMetaData(unresolvedTrack);
+        if (lavaTrack) {
+            unresolvedTrack.track = lavaTrack.track;
+            unresolvedTrack.info.identifier = lavaTrack.info.identifier
+            return unresolvedTrack
+        }
+    }
+
+
+    compareValue(value) {
+        return typeof value !== 'undefined' ? value !== null : typeof value !== 'undefined';
+    }
+
+
+    buildResponse(loadType, tracks, playlistName, exceptionMsg) {
+
+        return Object.assign({
+            loadType,
+            tracks,
+            playlistInfo: playlistName ? { name: playlistName } : {}
+        }, exceptionMsg ? { exception: { message: exceptionMsg, severity: "COMMON" } } : {});
+    }
+
+
+}
+
+
+
+
+
+module.exports = Spotify

package/typings/index.d.ts

@@ -1,3 +1,5 @@
+import { EventEmitter } from "ws";
+
 declare module'Poru' {
 
     import { EventEmitter } from 'events';