From af639159d1647ffb7b4c5c5f7ad035fe8766b6dc Mon Sep 17 00:00:00 2001 From: sofushn Date: Sat, 7 Sep 2024 13:09:45 +0200 Subject: [PATCH 1/2] feat: allow running without spotify --- src/commands/play.ts | 8 +- src/inversify.config.ts | 16 +-- src/services/add-query-to-queue.ts | 70 +----------- src/services/config.ts | 4 +- src/services/get-songs.ts | 102 ++++++++++++++++-- src/services/youtube-api.ts | 2 +- ...get-youtube-and-spotify-suggestions-for.ts | 84 ++++++++------- 7 files changed, 160 insertions(+), 126 deletions(-) diff --git a/src/commands/play.ts b/src/commands/play.ts index 25aef1c5..7851eb7c 100644 --- a/src/commands/play.ts +++ b/src/commands/play.ts @@ -1,7 +1,7 @@ import {AutocompleteInteraction, ChatInputCommandInteraction} from 'discord.js'; import {URL} from 'url'; import {SlashCommandBuilder} from '@discordjs/builders'; -import {inject, injectable} from 'inversify'; +import {inject, injectable, optional} from 'inversify'; import Spotify from 'spotify-web-api-node'; import Command from './index.js'; import {TYPES} from '../types.js'; @@ -36,12 +36,12 @@ export default class implements Command { public requiresVC = true; - private readonly spotify: Spotify; + private readonly spotify?: Spotify; private readonly cache: KeyValueCacheProvider; private readonly addQueryToQueue: AddQueryToQueue; - constructor(@inject(TYPES.ThirdParty) thirdParty: ThirdParty, @inject(TYPES.KeyValueCache) cache: KeyValueCacheProvider, @inject(TYPES.Services.AddQueryToQueue) addQueryToQueue: AddQueryToQueue) { - this.spotify = thirdParty.spotify; + constructor(@inject(TYPES.ThirdParty) @optional() thirdParty: ThirdParty, @inject(TYPES.KeyValueCache) cache: KeyValueCacheProvider, @inject(TYPES.Services.AddQueryToQueue) addQueryToQueue: AddQueryToQueue) { + this.spotify = thirdParty?.spotify; this.cache = cache; this.addQueryToQueue = addQueryToQueue; } diff --git a/src/inversify.config.ts b/src/inversify.config.ts index 2f2005e2..8e621cbc 100644 --- a/src/inversify.config.ts +++ b/src/inversify.config.ts @@ -57,11 +57,20 @@ container.bind(TYPES.Client).toConstantValue(new Client({intents})); // Managers container.bind(TYPES.Managers.Player).to(PlayerManager).inSingletonScope(); +// Config values +container.bind(TYPES.Config).toConstantValue(new ConfigProvider()); + // Services container.bind(TYPES.Services.GetSongs).to(GetSongs).inSingletonScope(); container.bind(TYPES.Services.AddQueryToQueue).to(AddQueryToQueue).inSingletonScope(); container.bind(TYPES.Services.YoutubeAPI).to(YoutubeAPI).inSingletonScope(); -container.bind(TYPES.Services.SpotifyAPI).to(SpotifyAPI).inSingletonScope(); + +// Only instanciate spotify dependencies if the Spotify client ID and secret are set +const config = container.get(TYPES.Config); +if (config.SPOTIFY_CLIENT_ID !== '' && config.SPOTIFY_CLIENT_SECRET !== '') { + container.bind(TYPES.Services.SpotifyAPI).to(SpotifyAPI).inSingletonScope(); + container.bind(TYPES.ThirdParty).to(ThirdParty); +} // Commands [ @@ -91,12 +100,7 @@ container.bind(TYPES.Services.SpotifyAPI).to(SpotifyAPI).inSingleton container.bind(TYPES.Command).to(command).inSingletonScope(); }); -// Config values -container.bind(TYPES.Config).toConstantValue(new ConfigProvider()); - // Static libraries -container.bind(TYPES.ThirdParty).to(ThirdParty); - container.bind(TYPES.FileCache).to(FileCacheProvider); container.bind(TYPES.KeyValueCache).to(KeyValueCacheProvider); diff --git a/src/services/add-query-to-queue.ts b/src/services/add-query-to-queue.ts index 401ad902..95e16fff 100644 --- a/src/services/add-query-to-queue.ts +++ b/src/services/add-query-to-queue.ts @@ -1,6 +1,5 @@ /* eslint-disable complexity */ import {ChatInputCommandInteraction, GuildMember} from 'discord.js'; -import {URL} from 'node:url'; import {inject, injectable} from 'inversify'; import shuffle from 'array-shuffle'; import {TYPES} from '../types.js'; @@ -60,74 +59,7 @@ export default class AddQueryToQueue { await interaction.deferReply({ephemeral: queueAddResponseEphemeral}); - let newSongs: SongMetadata[] = []; - let extraMsg = ''; - - // Test if it's a complete URL - try { - const url = new URL(query); - - const YOUTUBE_HOSTS = [ - 'www.youtube.com', - 'youtu.be', - 'youtube.com', - 'music.youtube.com', - 'www.music.youtube.com', - ]; - - if (YOUTUBE_HOSTS.includes(url.host)) { - // YouTube source - if (url.searchParams.get('list')) { - // YouTube playlist - newSongs.push(...await this.getSongs.youtubePlaylist(url.searchParams.get('list')!, shouldSplitChapters)); - } else { - const songs = await this.getSongs.youtubeVideo(url.href, shouldSplitChapters); - - if (songs) { - newSongs.push(...songs); - } else { - throw new Error('that doesn\'t exist'); - } - } - } else if (url.protocol === 'spotify:' || url.host === 'open.spotify.com') { - const [convertedSongs, nSongsNotFound, totalSongs] = await this.getSongs.spotifySource(query, playlistLimit, shouldSplitChapters); - - if (totalSongs > playlistLimit) { - extraMsg = `a random sample of ${playlistLimit} songs was taken`; - } - - if (totalSongs > playlistLimit && nSongsNotFound !== 0) { - extraMsg += ' and '; - } - - if (nSongsNotFound !== 0) { - if (nSongsNotFound === 1) { - extraMsg += '1 song was not found'; - } else { - extraMsg += `${nSongsNotFound.toString()} songs were not found`; - } - } - - newSongs.push(...convertedSongs); - } else { - const song = await this.getSongs.httpLiveStream(query); - - if (song) { - newSongs.push(song); - } else { - throw new Error('that doesn\'t exist'); - } - } - } catch (_: unknown) { - // Not a URL, must search YouTube - const songs = await this.getSongs.youtubeVideoSearch(query, shouldSplitChapters); - - if (songs) { - newSongs.push(...songs); - } else { - throw new Error('that doesn\'t exist'); - } - } + let [newSongs, extraMsg] = await this.getSongs.getSongs(query, playlistLimit, shouldSplitChapters); if (newSongs.length === 0) { throw new Error('no songs found'); diff --git a/src/services/config.ts b/src/services/config.ts index b6b9aeaa..a5af5a4e 100644 --- a/src/services/config.ts +++ b/src/services/config.ts @@ -12,8 +12,8 @@ export const DATA_DIR = path.resolve(process.env.DATA_DIR ? process.env.DATA_DIR const CONFIG_MAP = { DISCORD_TOKEN: process.env.DISCORD_TOKEN, YOUTUBE_API_KEY: process.env.YOUTUBE_API_KEY, - SPOTIFY_CLIENT_ID: process.env.SPOTIFY_CLIENT_ID, - SPOTIFY_CLIENT_SECRET: process.env.SPOTIFY_CLIENT_SECRET, + SPOTIFY_CLIENT_ID: process.env.SPOTIFY_CLIENT_ID ?? '', + SPOTIFY_CLIENT_SECRET: process.env.SPOTIFY_CLIENT_SECRET ?? '', REGISTER_COMMANDS_ON_BOT: process.env.REGISTER_COMMANDS_ON_BOT === 'true', DATA_DIR, CACHE_DIR: path.join(DATA_DIR, 'cache'), diff --git a/src/services/get-songs.ts b/src/services/get-songs.ts index b9577347..dcaec0cd 100644 --- a/src/services/get-songs.ts +++ b/src/services/get-songs.ts @@ -1,34 +1,120 @@ -import {inject, injectable} from 'inversify'; +import {inject, injectable, optional} from 'inversify'; import * as spotifyURI from 'spotify-uri'; import {SongMetadata, QueuedPlaylist, MediaSource} from './player.js'; import {TYPES} from '../types.js'; import ffmpeg from 'fluent-ffmpeg'; import YoutubeAPI from './youtube-api.js'; import SpotifyAPI, {SpotifyTrack} from './spotify-api.js'; +import {URL} from 'node:url'; @injectable() export default class { private readonly youtubeAPI: YoutubeAPI; - private readonly spotifyAPI: SpotifyAPI; + private readonly spotifyAPI?: SpotifyAPI; - constructor(@inject(TYPES.Services.YoutubeAPI) youtubeAPI: YoutubeAPI, @inject(TYPES.Services.SpotifyAPI) spotifyAPI: SpotifyAPI) { + constructor(@inject(TYPES.Services.YoutubeAPI) youtubeAPI: YoutubeAPI, @inject(TYPES.Services.SpotifyAPI) @optional() spotifyAPI?: SpotifyAPI) { this.youtubeAPI = youtubeAPI; this.spotifyAPI = spotifyAPI; } - async youtubeVideoSearch(query: string, shouldSplitChapters: boolean): Promise { + async getSongs(query: string, playlistLimit: number, shouldSplitChapters: boolean): Promise<[SongMetadata[], string]> { + let newSongs: SongMetadata[] = []; + let extraMsg = ''; + + // Test if it's a complete URL + try { + const url = new URL(query); + + const YOUTUBE_HOSTS = [ + 'www.youtube.com', + 'youtu.be', + 'youtube.com', + 'music.youtube.com', + 'www.music.youtube.com', + ]; + + if (YOUTUBE_HOSTS.includes(url.host)) { + // YouTube source + if (url.searchParams.get('list')) { + // YouTube playlist + newSongs.push(...await this.youtubePlaylist(url.searchParams.get('list')!, shouldSplitChapters)); + } else { + const songs = await this.youtubeVideo(url.href, shouldSplitChapters); + + if (songs) { + newSongs.push(...songs); + } else { + throw new Error('that doesn\'t exist'); + } + } + } else if (url.protocol === 'spotify:' || url.host === 'open.spotify.com') { + if (this.spotifyAPI === undefined) { + throw new Error('Spotify is not enabled!') + } + + const [convertedSongs, nSongsNotFound, totalSongs] = await this.spotifySource(query, playlistLimit, shouldSplitChapters); + + if (totalSongs > playlistLimit) { + extraMsg = `a random sample of ${playlistLimit} songs was taken`; + } + + if (totalSongs > playlistLimit && nSongsNotFound !== 0) { + extraMsg += ' and '; + } + + if (nSongsNotFound !== 0) { + if (nSongsNotFound === 1) { + extraMsg += '1 song was not found'; + } else { + extraMsg += `${nSongsNotFound.toString()} songs were not found`; + } + } + + newSongs.push(...convertedSongs); + } else { + const song = await this.httpLiveStream(query); + + if (song) { + newSongs.push(song); + } else { + throw new Error('that doesn\'t exist'); + } + } + } catch (err: any) { + if (err = 'spotify not enabled') { + throw err; + } + + // Not a URL, must search YouTube + const songs = await this.youtubeVideoSearch(query, shouldSplitChapters); + + if (songs) { + newSongs.push(...songs); + } else { + throw new Error('that doesn\'t exist'); + } + } + + return [newSongs, extraMsg]; + } + + private async youtubeVideoSearch(query: string, shouldSplitChapters: boolean): Promise { return this.youtubeAPI.search(query, shouldSplitChapters); } - async youtubeVideo(url: string, shouldSplitChapters: boolean): Promise { + private async youtubeVideo(url: string, shouldSplitChapters: boolean): Promise { return this.youtubeAPI.getVideo(url, shouldSplitChapters); } - async youtubePlaylist(listId: string, shouldSplitChapters: boolean): Promise { + private async youtubePlaylist(listId: string, shouldSplitChapters: boolean): Promise { return this.youtubeAPI.getPlaylist(listId, shouldSplitChapters); } - async spotifySource(url: string, playlistLimit: number, shouldSplitChapters: boolean): Promise<[SongMetadata[], number, number]> { + private async spotifySource(url: string, playlistLimit: number, shouldSplitChapters: boolean): Promise<[SongMetadata[], number, number]> { + if (this.spotifyAPI === undefined) { + return [[], 0, 0]; + } + const parsed = spotifyURI.parse(url); switch (parsed.type) { @@ -58,7 +144,7 @@ export default class { } } - async httpLiveStream(url: string): Promise { + private async httpLiveStream(url: string): Promise { return new Promise((resolve, reject) => { ffmpeg(url).ffprobe((err, _) => { if (err) { diff --git a/src/services/youtube-api.ts b/src/services/youtube-api.ts index 143033ae..216a2c0c 100644 --- a/src/services/youtube-api.ts +++ b/src/services/youtube-api.ts @@ -95,7 +95,7 @@ export default class { } if (!firstVideo) { - throw new Error('No video found.'); + return []; } return this.getVideo(firstVideo.url, shouldSplitChapters); diff --git a/src/utils/get-youtube-and-spotify-suggestions-for.ts b/src/utils/get-youtube-and-spotify-suggestions-for.ts index 6594b526..c33cbeeb 100644 --- a/src/utils/get-youtube-and-spotify-suggestions-for.ts +++ b/src/utils/get-youtube-and-spotify-suggestions-for.ts @@ -14,28 +14,19 @@ const filterDuplicates = (items: T[]) => { return results; }; -const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify: SpotifyWebApi, limit = 10): Promise => { - const [youtubeSuggestions, spotifyResults] = await Promise.all([ - getYouTubeSuggestionsFor(query), - spotify.search(query, ['track', 'album'], {limit: 5}), - ]); +const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify?: SpotifyWebApi, limit = 10): Promise => { + + // Only search Spotify if enabled + let spotifySuggestionPromise = spotify !== undefined + ? spotify.search(query, ['album', 'track'], {limit}) + : undefined; + + const youtubeSuggestions = await getYouTubeSuggestionsFor(query); const totalYouTubeResults = youtubeSuggestions.length; + const numOfYouTubeSuggestions = Math.min(limit, totalYouTubeResults); - const spotifyAlbums = filterDuplicates(spotifyResults.body.albums?.items ?? []); - const spotifyTracks = filterDuplicates(spotifyResults.body.tracks?.items ?? []); - - const totalSpotifyResults = spotifyAlbums.length + spotifyTracks.length; - - // Number of results for each source should be roughly the same. - // If we don't have enough Spotify suggestions, prioritize YouTube results. - const maxSpotifySuggestions = Math.floor(limit / 2); - const numOfSpotifySuggestions = Math.min(maxSpotifySuggestions, totalSpotifyResults); - - const maxYouTubeSuggestions = limit - numOfSpotifySuggestions; - const numOfYouTubeSuggestions = Math.min(maxYouTubeSuggestions, totalYouTubeResults); - - const suggestions: APIApplicationCommandOptionChoice[] = []; + let suggestions: APIApplicationCommandOptionChoice[] = []; suggestions.push( ...youtubeSuggestions @@ -45,24 +36,45 @@ const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify: Spotif value: suggestion, }), )); + + + if (spotify !== undefined && spotifySuggestionPromise !== undefined) { + + const spotifyResponse = (await spotifySuggestionPromise).body + const spotifyAlbums = filterDuplicates(spotifyResponse.albums?.items ?? []); + const spotifyTracks = filterDuplicates(spotifyResponse.tracks?.items ?? []); + + const totalSpotifyResults = spotifyAlbums.length + spotifyTracks.length; + + // Number of results for each source should be roughly the same. + // If we don't have enough Spotify suggestions, prioritize YouTube results. + const maxSpotifySuggestions = Math.floor(limit / 2); + const numOfSpotifySuggestions = Math.min(maxSpotifySuggestions, totalSpotifyResults); + + + const maxSpotifyAlbums = Math.floor(numOfSpotifySuggestions / 2); + const numOfSpotifyAlbums = Math.min(maxSpotifyAlbums, spotifyResponse.albums?.items.length ?? 0); + const maxSpotifyTracks = numOfSpotifySuggestions - numOfSpotifyAlbums; + + // make room for spotify results + const maxYouTubeSuggestions = limit - numOfSpotifySuggestions; + suggestions = suggestions.slice(0, maxYouTubeSuggestions) + + suggestions.push( + ...spotifyAlbums.slice(0, maxSpotifyAlbums).map(album => ({ + name: `Spotify: 💿 ${album.name}${album.artists.length > 0 ? ` - ${album.artists[0].name}` : ''}`, + value: `spotify:album:${album.id}`, + })), + ); + + suggestions.push( + ...spotifyTracks.slice(0, maxSpotifyTracks).map(track => ({ + name: `Spotify: 🎵 ${track.name}${track.artists.length > 0 ? ` - ${track.artists[0].name}` : ''}`, + value: `spotify:track:${track.id}`, + })), + ); - const maxSpotifyAlbums = Math.floor(numOfSpotifySuggestions / 2); - const numOfSpotifyAlbums = Math.min(maxSpotifyAlbums, spotifyResults.body.albums?.items.length ?? 0); - const maxSpotifyTracks = numOfSpotifySuggestions - numOfSpotifyAlbums; - - suggestions.push( - ...spotifyAlbums.slice(0, maxSpotifyAlbums).map(album => ({ - name: `Spotify: 💿 ${album.name}${album.artists.length > 0 ? ` - ${album.artists[0].name}` : ''}`, - value: `spotify:album:${album.id}`, - })), - ); - - suggestions.push( - ...spotifyTracks.slice(0, maxSpotifyTracks).map(track => ({ - name: `Spotify: 🎵 ${track.name}${track.artists.length > 0 ? ` - ${track.artists[0].name}` : ''}`, - value: `spotify:track:${track.id}`, - })), - ); + } return suggestions; }; From 107464e22244e5f488212269f780675bc1494190 Mon Sep 17 00:00:00 2001 From: sofushn Date: Sat, 7 Sep 2024 21:49:10 +0200 Subject: [PATCH 2/2] chore: make linter parse --- src/services/get-songs.ts | 8 +++---- ...get-youtube-and-spotify-suggestions-for.ts | 23 ++++++++----------- 2 files changed, 13 insertions(+), 18 deletions(-) diff --git a/src/services/get-songs.ts b/src/services/get-songs.ts index dcaec0cd..c48d87dc 100644 --- a/src/services/get-songs.ts +++ b/src/services/get-songs.ts @@ -18,7 +18,7 @@ export default class { } async getSongs(query: string, playlistLimit: number, shouldSplitChapters: boolean): Promise<[SongMetadata[], string]> { - let newSongs: SongMetadata[] = []; + const newSongs: SongMetadata[] = []; let extraMsg = ''; // Test if it's a complete URL @@ -49,7 +49,7 @@ export default class { } } else if (url.protocol === 'spotify:' || url.host === 'open.spotify.com') { if (this.spotifyAPI === undefined) { - throw new Error('Spotify is not enabled!') + throw new Error('Spotify is not enabled!'); } const [convertedSongs, nSongsNotFound, totalSongs] = await this.spotifySource(query, playlistLimit, shouldSplitChapters); @@ -81,7 +81,7 @@ export default class { } } } catch (err: any) { - if (err = 'spotify not enabled') { + if (err instanceof Error && err.message === 'Spotify is not enabled!') { throw err; } @@ -112,7 +112,7 @@ export default class { private async spotifySource(url: string, playlistLimit: number, shouldSplitChapters: boolean): Promise<[SongMetadata[], number, number]> { if (this.spotifyAPI === undefined) { - return [[], 0, 0]; + return [[], 0, 0]; } const parsed = spotifyURI.parse(url); diff --git a/src/utils/get-youtube-and-spotify-suggestions-for.ts b/src/utils/get-youtube-and-spotify-suggestions-for.ts index c33cbeeb..bd6f1c87 100644 --- a/src/utils/get-youtube-and-spotify-suggestions-for.ts +++ b/src/utils/get-youtube-and-spotify-suggestions-for.ts @@ -15,12 +15,11 @@ const filterDuplicates = (items: T[]) => { }; const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify?: SpotifyWebApi, limit = 10): Promise => { - // Only search Spotify if enabled - let spotifySuggestionPromise = spotify !== undefined - ? spotify.search(query, ['album', 'track'], {limit}) - : undefined; - + const spotifySuggestionPromise = spotify === undefined + ? undefined + : spotify.search(query, ['album', 'track'], {limit}); + const youtubeSuggestions = await getYouTubeSuggestionsFor(query); const totalYouTubeResults = youtubeSuggestions.length; @@ -36,11 +35,9 @@ const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify?: Spoti value: suggestion, }), )); - - + if (spotify !== undefined && spotifySuggestionPromise !== undefined) { - - const spotifyResponse = (await spotifySuggestionPromise).body + const spotifyResponse = (await spotifySuggestionPromise).body; const spotifyAlbums = filterDuplicates(spotifyResponse.albums?.items ?? []); const spotifyTracks = filterDuplicates(spotifyResponse.tracks?.items ?? []); @@ -51,14 +48,13 @@ const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify?: Spoti const maxSpotifySuggestions = Math.floor(limit / 2); const numOfSpotifySuggestions = Math.min(maxSpotifySuggestions, totalSpotifyResults); - const maxSpotifyAlbums = Math.floor(numOfSpotifySuggestions / 2); const numOfSpotifyAlbums = Math.min(maxSpotifyAlbums, spotifyResponse.albums?.items.length ?? 0); const maxSpotifyTracks = numOfSpotifySuggestions - numOfSpotifyAlbums; - // make room for spotify results + // Make room for spotify results const maxYouTubeSuggestions = limit - numOfSpotifySuggestions; - suggestions = suggestions.slice(0, maxYouTubeSuggestions) + suggestions = suggestions.slice(0, maxYouTubeSuggestions); suggestions.push( ...spotifyAlbums.slice(0, maxSpotifyAlbums).map(album => ({ @@ -66,14 +62,13 @@ const getYouTubeAndSpotifySuggestionsFor = async (query: string, spotify?: Spoti value: `spotify:album:${album.id}`, })), ); - + suggestions.push( ...spotifyTracks.slice(0, maxSpotifyTracks).map(track => ({ name: `Spotify: 🎵 ${track.name}${track.artists.length > 0 ? ` - ${track.artists[0].name}` : ''}`, value: `spotify:track:${track.id}`, })), ); - } return suggestions;