Secret metadata provider

packages/app/__mocks__/@nuclear/core.ts

@@ -66,8 +66,6 @@ module.exports = {
       urlSearch: jest.fn().mockResolvedValue([]),
       liveStreamSearch: jest.fn().mockResolvedValue([])
     },
-    NuclearPlaylistsService: jest.requireActual('@nuclear/core/src/rest/Nuclear/Playlists').NuclearPlaylistsService,
-    NuclearStreamMappingsService: jest.requireActual('@nuclear/core/src/rest/Nuclear/StreamMappings').NuclearStreamMappingsService,
     Deezer: {
       ...jest.requireActual('@nuclear/core/src/rest/Deezer'),
       getEditorialCharts: jest.fn().mockResolvedValue({

packages/app/app/actions/actionTypes.ts

@@ -20,15 +20,14 @@ export enum Search {
   ALBUM_INFO_SEARCH_START = 'ALBUM_INFO_SEARCH_START',
   ALBUM_INFO_SEARCH_SUCCESS = 'ALBUM_INFO_SEARCH_SUCCESS',
   ALBUM_INFO_SEARCH_ERROR = 'ALBUM_INFO_SEARCH_ERROR',
-  PODCAST_SEARCH_SUCCESS = 'PODCAST_SEARCH_SUCCESS',
   ARTIST_INFO_SEARCH_START = 'ARTIST_INFO_SEARCH_START',
   ARTIST_INFO_SEARCH_SUCCESS = 'ARTIST_INFO_SEARCH_SUCCESS',
   ARTIST_INFO_SEARCH_ERROR = 'ARTIST_INFO_SEARCH_ERROR',
   ARTIST_RELEASES_SEARCH_START = 'ARTIST_RELEASES_SEARCH_START',
   ARTIST_RELEASES_SEARCH_SUCCESS = 'ARTIST_RELEASES_SEARCH_SUCCESS',
   ARTIST_RELEASES_SEARCH_ERROR = 'ARTIST_RELEASES_SEARCH_ERROR',
-  LASTFM_TRACK_SEARCH_START = 'LASTFM_TRACK_SEARCH_START',
-  LASTFM_TRACK_SEARCH_SUCCESS = 'LASTFM_TRACK_SEARCH_SUCCESS',
+  TRACK_SEARCH_START = 'TRACK_SEARCH_START',
+  TRACK_SEARCH_ERROR = 'TRACK_SEARCH_ERROR',
   TRACK_SEARCH_SUCCESS = 'TRACK_SEARCH_SUCCESS',
   YOUTUBE_PLAYLIST_SEARCH_START = 'YOUTUBE_PLAYLIST_SEARCH_START',
   YOUTUBE_PLAYLIST_SEARCH_SUCCESS = 'YOUTUBE_PLAYLIST_SEARCH_SUCCESS',
@@ -62,10 +61,6 @@ export enum Playlists {
   LOAD_LOCAL_PLAYLISTS_SUCCESS = 'LOAD_LOCAL_PLAYLISTS_SUCCESS',
   LOAD_LOCAL_PLAYLISTS_ERROR = 'LOAD_LOCAL_PLAYLISTS_ERROR',
   UPDATE_LOCAL_PLAYLISTS = 'UPDATE_LOCAL_PLAYLISTS',
-
-  LOAD_REMOTE_PLAYLISTS_START = 'LOAD_REMOTE_PLAYLISTS_START',
-  LOAD_REMOTE_PLAYLISTS_SUCCESS = 'LOAD_REMOTE_PLAYLISTS_SUCCESS',
-  LOAD_REMOTE_PLAYLISTS_ERROR = 'LOAD_REMOTE_PLAYLISTS_ERROR',
 }
 
 export enum ImportFavs {

packages/app/app/actions/playlists.ts

@@ -3,9 +3,7 @@ import { v4 } from 'uuid';
 import { createAsyncAction, createStandardAction } from 'typesafe-actions';
 import { ipcRenderer } from 'electron';
 
-import { store, PlaylistHelper, Playlist, PlaylistTrack, rest, IpcEvents } from '@nuclear/core';
-import { GetPlaylistsByUserIdResponseBody } from '@nuclear/core/src/rest/Nuclear/Playlists.types';
-import { ErrorBody } from '@nuclear/core/src/rest/Nuclear/types';
+import { store, PlaylistHelper, Playlist, PlaylistTrack, IpcEvents } from '@nuclear/core';
 
 import { Playlists } from './actionTypes';
 
@@ -15,7 +13,6 @@ import {
   updatePlaylistsOrderEffect
 } from './playlists.effects';
 import { success, error } from './toasts';
-import { IdentityStore } from '../reducers/nuclear/identity';
 import { PlaylistsStore } from '../reducers/playlists';
 import { isEmpty } from 'lodash';
 
@@ -27,12 +24,6 @@ export const loadLocalPlaylistsAction = createAsyncAction(
   Playlists.LOAD_LOCAL_PLAYLISTS_ERROR
 )<void, Array<Playlist>, void>();
 
-export const loadRemotePlaylistsAction = createAsyncAction(
-  Playlists.LOAD_REMOTE_PLAYLISTS_START,
-  Playlists.LOAD_REMOTE_PLAYLISTS_SUCCESS,
-  Playlists.LOAD_REMOTE_PLAYLISTS_ERROR
-)<void, GetPlaylistsByUserIdResponseBody, ErrorBody>();
-
 export const addPlaylist = (tracks: Array<PlaylistTrack>, name: string) => dispatch => {
   if (name?.length === 0) {
     return;
@@ -62,30 +53,6 @@ export const loadLocalPlaylists = () => dispatch => {
   }
 };
 
-
-export const loadRemotePlaylists = ({ token, signedInUser }: IdentityStore) => async (dispatch, getState) => {
-  dispatch(loadRemotePlaylistsAction.request());
-  const { settings } = getState();
-  const service = new rest.NuclearPlaylistsService(
-    settings.nuclearPlaylistsServiceUrl
-  );
-
-  try {
-    if (token) {
-      const playlists = await service.getPlaylistsByUserId(token, signedInUser.id);
-      if (playlists.ok) {
-        dispatch(loadRemotePlaylistsAction.success(playlists.body as GetPlaylistsByUserIdResponseBody));
-      } else {
-        throw playlists.body;
-      }
-    } else {
-      throw new Error('No token');
-    }
-  } catch (e) {
-    dispatch(loadRemotePlaylistsAction.failure(e.message));
-  }
-};
-
 export const updatePlaylist = (playlist: Playlist) => dispatch => {
   const playlists = updatePlaylistEffect(store)(playlist);
   dispatch(updatePlaylistsAction(playlists));

packages/app/app/actions/queue.ts

@@ -3,7 +3,9 @@
 import { createStandardAction } from 'typesafe-actions';
 import { v4 } from 'uuid';
 
-import { rest, StreamProvider } from '@nuclear/core';
+import { StreamProvider } from '@nuclear/core';
+import StreamProviderPlugin from '@nuclear/core/src/plugins/streamProvider';
+import { Nuclear } from '@nuclear/core/src/rest';
 import { getTrackArtist, getTrackTitle } from '@nuclear/ui';
 import { Track } from '@nuclear/ui/lib/types';
 
@@ -13,8 +15,6 @@
 import { RootState } from '../reducers';
 import { LocalLibraryState } from './local';
 import { Queue } from './actionTypes';
-import StreamProviderPlugin from '@nuclear/core/src/plugins/streamProvider';
-import { isSuccessCacheEntry } from '@nuclear/core/src/rest/Nuclear/StreamMappings';
 import { queue as queueSelector } from '../selectors/queue';
 import { error } from './toasts';
 import { random } from 'lodash';
@@ -200,15 +200,15 @@
   }
 
   try {
-    const StreamMappingsService = rest.NuclearStreamMappingsService.get(process.env.NUCLEAR_VERIFICATION_SERVICE_URL);
+    const StreamMappingsService = Nuclear.NuclearStreamMappingsService.get(process.env.NUCLEAR_VERIFICATION_SERVICE_URL);
     const topStream = await StreamMappingsService.getTopStream(
       getTrackArtist(track),
       getTrackTitle(track),
       selectedStreamProvider.sourceName,
       settings?.userId
     );
 
-    if (!isSuccessCacheEntry(topStream)) {
+    if (!Nuclear.isSuccessCacheEntry(topStream)) {
       return streamData;
     }
 

packages/app/app/actions/search.ts

@@ -1,18 +1,14 @@
 import { logger } from '@nuclear/core';
 import { rest } from '@nuclear/core';
-import _, { isString } from 'lodash';
-import artPlaceholder from '../../resources/media/art_placeholder.png';
-import globals from '../globals';
+import _ from 'lodash';
 import { error } from './toasts';
 import { Search } from './actionTypes';
 import { History } from 'history';
 import { RootState } from '../reducers';
-import { AlbumDetails, ArtistDetails, SearchResultsAlbum, SearchResultsArtist, SearchResultsPodcast, SearchResultsSource } from '@nuclear/core/src/plugins/plugins.types';
-import { createStandardAction } from 'typesafe-actions';
-import { LastfmTrackMatch, LastfmTrackMatchInternal } from '@nuclear/core/src/rest/Lastfm.types';
+import { AlbumDetails, ArtistDetails, SearchResultsAlbum, SearchResultsArtist, SearchResultsSource, SearchResultsTrack } from '@nuclear/core/src/plugins/plugins.types';
+import { createAsyncAction, createStandardAction } from 'typesafe-actions';
 import { YoutubeResult } from '@nuclear/core/src/rest/Youtube';
-
-const lastfm = new rest.LastFmApi(globals.lastfmApiKey, globals.lastfmApiSecret);
+import { getTrackArtist } from '@nuclear/ui';
 
 export const SearchActions = {
   unifiedSearchStart: createStandardAction(Search.UNIFIED_SEARCH_START)<string>(),
@@ -28,7 +24,7 @@
     };
   }),
   youtubeLiveStreamSearchStart: createStandardAction(Search.YOUTUBE_LIVESTREAM_SEARCH_START)<string>(),
-  youtubeLiveStreamSearchSuccess: createStandardAction(Search.YOUTUBE_LIVESTREAM_SEARCH_SUCCESS).map((id: string, info: YoutubeResult[]) => {
+  youtubeLiveStreamSearchSuccess: createStandardAction(Search.YOUTUBE_LIVESTREAM_SEARCH_SUCCESS).map((id: string, info: SearchResultsTrack[]) => {
     return {
       payload: {
         id,
@@ -68,19 +64,8 @@
       }
     };
   }),
-  podcastSearchSuccess: createStandardAction(Search.PODCAST_SEARCH_SUCCESS)<SearchResultsPodcast[]>(),
   setSearchDropdownVisibility: createStandardAction(Search.SEARCH_DROPDOWN_DISPLAY_CHANGE)<boolean>(),
   updateSearchHistory: createStandardAction(Search.UPDATE_SEARCH_HISTORY)<string[]>(),
-  lastFmTrackSearchStart: createStandardAction(Search.LASTFM_TRACK_SEARCH_START)<string>(),
-  lastFmTrackSearchSuccess: createStandardAction(Search.LASTFM_TRACK_SEARCH_SUCCESS).map((terms: string, searchResults: LastfmTrackMatchInternal[]) => {
-    return {
-      payload: {
-        id: terms,
-        info: searchResults
-      }
-    };
-  }),
-  trackSearchSuccess: createStandardAction(Search.TRACK_SEARCH_SUCCESS)<SearchResultsAlbum[]>(),
   artistSearchSuccess: createStandardAction(Search.ARTIST_SEARCH_SUCCESS)<SearchResultsArtist[]>(),
   artistInfoStart: createStandardAction(Search.ARTIST_INFO_SEARCH_START)<string>(),
   artistInfoSuccess: createStandardAction(Search.ARTIST_INFO_SEARCH_SUCCESS).map((artistId: string, info: ArtistDetails) => {
@@ -121,7 +106,12 @@
         error
       }
     };
-  })
+  }),
+  trackSearchAction: createAsyncAction(
+    Search.TRACK_SEARCH_START,
+    Search.TRACK_SEARCH_SUCCESS,
+    Search.TRACK_SEARCH_ERROR
+  )<undefined, SearchResultsTrack[], undefined>()
 };
 
 
@@ -131,9 +121,12 @@
       plugins: { metaProviders }, selected }
   } = getState();
 
-  return wantedProvider ?
+  const selectedProvider = wantedProvider ?
     _.find(metaProviders, { searchName: wantedProvider }) :
     _.find(metaProviders, { sourceName: selected.metaProviders });
+
+
+  return selectedProvider || _.find(metaProviders, { isDefault: true }) || null;
 };
 
 export const artistSearch = (terms: string) => async (dispatch, getState: () => RootState) => {
@@ -149,57 +142,17 @@
 };
 
 export const trackSearch = (terms: string) => async (dispatch, getState: () => RootState) => {
-  const selectedProvider = getSelectedMetaProvider(getState);
-  const results = await selectedProvider.searchForTracks(terms);
-  dispatch(SearchActions.trackSearchSuccess(results));
-};
-
-export const podcastSearch = (terms: string) => async (dispatch, getState: () => RootState) => {
-  const selectedProvider = getSelectedMetaProvider(getState);
-  const results = await selectedProvider.searchForPodcast(terms);
-  dispatch(SearchActions.podcastSearchSuccess(results));
-};
-
-
-const isAcceptableLastFMThumbnail = (thumbnail: string) =>
-  !(/https?:\/\/lastfm-img\d.akamaized.net\/i\/u\/\d+s\/2a96cbd8b46e442fc41c2b86b821562f\.png/.test(thumbnail));
-
-const getTrackThumbnail = (track: LastfmTrackMatch) => {
-  const image =
-    _.get(
-      track,
-      ['image', 1, '#text'],
-      _.get(
-        track,
-        ['image', 0, '#text'],
-        artPlaceholder
-      )
-    );
-
-  return !isString(image) ? artPlaceholder : isAcceptableLastFMThumbnail(image) ? image : artPlaceholder;
+  dispatch(SearchActions.trackSearchAction.request());
+  try {
+    const selectedProvider = getSelectedMetaProvider(getState);
+    const results = await selectedProvider.searchForTracks(terms);
+    dispatch(SearchActions.trackSearchAction.success(results));
+  } catch (e) {
+    logger.error(e);
+    dispatch(SearchActions.trackSearchAction.failure());
+  }
 };
 
-export const mapLastFMTrackToInternal = (track: LastfmTrackMatch) => ({
-  ...track,
-  thumbnail: getTrackThumbnail(track)
-});
-
-export function lastFmTrackSearch(terms: string) {
-  return dispatch => {
-    dispatch(SearchActions.lastFmTrackSearchStart(terms));
-    Promise.all([lastfm.searchTracks(terms)])
-      .then(results => Promise.all(results.map(info => info.json())))
-      .then(results => {
-        dispatch(
-          SearchActions.lastFmTrackSearchSuccess(terms, _.get(results[0], 'results.trackmatches.track', []).map(mapLastFMTrackToInternal))
-        );
-      })
-      .catch(error => {
-        logger.error(error);
-      });
-  };
-}
-
 export function youtubePlaylistSearch(terms: string) {
   return dispatch => {
     dispatch(SearchActions.youtubePlaylistSearchStart(terms));
@@ -218,7 +171,13 @@
 export const youtubeLiveStreamSearch = (terms: string) => async (dispatch) => {
   dispatch(SearchActions.youtubeLiveStreamSearchStart(terms));
   try {
-    const results = await rest.Youtube.liveStreamSearch(terms);
+    const results = (await rest.Youtube.liveStreamSearch(terms)).map(el => ({
+      id: el.streams[0].id,
+      title: el.name,
+      artist: getTrackArtist(el),
+      thumb: el.thumbnail,
+      source: SearchResultsSource.Youtube
+    }) satisfies SearchResultsTrack);
     dispatch(SearchActions.youtubeLiveStreamSearchSuccess(terms, results));
   } catch (e) {
     logger.error(e);
@@ -233,8 +192,7 @@
     Promise.all([
       dispatch(albumSearch(terms)),
       dispatch(artistSearch(terms)),
-      dispatch(podcastSearch(terms)),
-      dispatch(lastFmTrackSearch(terms)),
+      dispatch(trackSearch(terms)),
       dispatch(youtubePlaylistSearch(terms)),
       dispatch(youtubeLiveStreamSearch(terms))
     ])
@@ -251,28 +209,28 @@
   };
 }
 
-export const albumInfoSearch = (albumId: string, releaseType: 'master' | 'release' = 'master', release: SearchResultsAlbum) => async (dispatch, getState:() => RootState) => {
-  dispatch(SearchActions.albumInfoStart(albumId));
+export const albumInfoSearch = (release: SearchResultsAlbum) => async (dispatch, getState:() => RootState) => {
+  dispatch(SearchActions.albumInfoStart(release.id));
   try {
     const selectedProvider = getSelectedMetaProvider(getState);
-    const albumDetails = await selectedProvider.fetchAlbumDetails(albumId, releaseType, release?.resourceUrl);
-    dispatch(SearchActions.albumInfoSuccess(albumId, albumDetails));
+    const albumDetails = await selectedProvider.fetchAlbumDetails(release.id, release.type, release?.resourceUrl);
+    dispatch(SearchActions.albumInfoSuccess(release.id, albumDetails));
   } catch (e) {
     logger.error(e);
-    dispatch(SearchActions.albumInfoError(albumId, e));
+    dispatch(SearchActions.albumInfoError(release.id, e));
   }
 };
 
 
-export const artistInfoSearch = (artistId: string, artist: SearchResultsArtist) => async (dispatch, getState: () => RootState) => {
-  dispatch(SearchActions.artistInfoStart(artistId));
+export const artistInfoSearch = (artist: SearchResultsArtist) => async (dispatch, getState: () => RootState) => {
+  dispatch(SearchActions.artistInfoStart(artist.id));
   try {
     const selectedProvider = getSelectedMetaProvider(getState, artist?.source);
-    const artistDetails = await selectedProvider.fetchArtistDetails(artistId);
-    dispatch(SearchActions.artistInfoSuccess(artistId, artistDetails));
+    const artistDetails = await selectedProvider.fetchArtistDetails(artist.id);
+    dispatch(SearchActions.artistInfoSuccess(artist.id, artistDetails));
   } catch (e) {
     logger.error(e);
-    dispatch(SearchActions.artistInfoError(artistId, e));
+    dispatch(SearchActions.artistInfoError(artist.id, e));
   }
 };
 

packages/app/app/components/ArtistView/ArtistHeader/index.tsx

@@ -24,15 +24,17 @@ export const ArtistHeader: React.FC<ArtistHeaderProps> = ({
   addFavoriteArtist
 }) => {
   const { t }= useTranslation('artist');
+
+  const avatar = artist.thumb ?? artist.images?.[1] ?? artPlaceholder;
+
   return <div className={styles.artist_header_overlay}>
     <div className={styles.artist_header_container}>
       {
         artist.images &&
         <div
           className={styles.artist_avatar}
           style={{
-            background: `url('${get(artist, 'images[1]', artPlaceholder)
-            }')`,
+            background: `url('${avatar}')`,
             backgroundRepeat: 'noRepeat',
             backgroundPosition: 'center',
             backgroundSize: 'cover'