poru 1.1.2 → 1.2.3

package/README.md

@@ -85,9 +85,6 @@ client.once("ready", () => {
   console.log(`Logged in as ${client.user.tag}`);
 });
 
-// this event used to make connections upto date with lavalink
-client.on("raw",async d => await client.poru.packetUpdate(d));
-
 // Finally login at the END of your code
 client.login("your bot token here");
 

package/package.json

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

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.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/Track.js

@@ -1,13 +1,12 @@
 class Track {
     constructor(data) {
       this.track = data.track
-      this.info = {
+      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,

package/src/platform/Spotify.js

@@ -0,0 +1,258 @@
+const fetch = (...args) => import('node-fetch').then(({
+    default: fetch
+}) => fetch(...args));
+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 = playlist.tracks.items.map(x => this.buildUnresolved(x.track));
+
+
+            return this.buildResponse(
+                "PLAYLIST_LOADED",
+                (await Promise.all(unresolvedPlaylistTracks.map(x => x.then((a) => a.resolve())))).filter(Boolean),
+                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 = album.tracks.map(x => this.buildUnresolved(x));
+        return this.buildResponse(
+            "PLAYLIST_LOADED",
+            (await Promise.all(unresolvedPlaylistTracks.map(x => x.then((a) => a.resolve())))).filter(Boolean),
+            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 = data.tracks.map(x => this.buildUnresolved(x));
+
+        return this.buildResponse(
+            "PLAYLIST_LOADED",
+            (await Promise.all(unresolvedPlaylistTracks.map(x => x.then((a) => a.resolve())))).filter(Boolean),
+            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 = this.buildUnresolved(data);
+
+        return this.buildResponse(
+            "TRACK_LOADED",
+            [await unresolvedTrack.then((a) => a.resolve())]
+        );
+        }catch(e){
+            return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
+        }
+    }
+
+    async fetchByWords(query) {
+            try{
+        const data = await this.requestData(`/search/?q="${query}"&type=artist,album,track`)
+       
+        const unresolvedTrack = this.buildUnresolved(data.tracks.items[0]);
+
+        return this.buildResponse(
+            "TRACK_LOADED",
+            [await unresolvedTrack.then((a) => a.resolve())]
+        );
+            }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");
+   //     if (!track.artists) throw new ReferenceError("The track artists array was not provided");
+        if (!track.name) throw new ReferenceError("The track name was not provided");
+        if (!Array.isArray(track.artists)) throw new TypeError(`The track artists must be an array, received type ${typeof track.artists}`);
+        if (typeof track.name !== "string") throw new TypeError(`The track name must be a string, received type ${typeof track.name}`);
+
+        const _this = this;
+        return {
+            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,
+            },
+            resolve() {
+                return _this.buildTrack(this)
+            }
+        }
+
+
+
+    }
+
+    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';