fix: refactor JellyfinApi to be less burdensome to implement

Also, automatically catch errors

src/store/downloads/actions.ts

@@ -1,9 +1,9 @@
 import { createAction, createAsyncThunk, createEntityAdapter } from '@reduxjs/toolkit';
 import { AppState } from '@/store';
-import { generateTrackUrl } from '@/utility/JellyfinApi';
 import { downloadFile, unlink, DocumentDirectoryPath, exists } from 'react-native-fs';
 import { DownloadEntity } from './types';
 import MimeTypes from '@/utility/MimeTypes';
+import { generateTrackUrl } from '@/utility/JellyfinApi/track';
 
 export const downloadAdapter = createEntityAdapter<DownloadEntity>();
 
@@ -15,12 +15,9 @@ export const failDownload = createAction<{ id: string }>('download/fail');
 
 export const downloadTrack = createAsyncThunk(
     '/downloads/track',
-    async (id: string, { dispatch, getState }) => {
-        // Get the credentials from the store
-        const { settings: { jellyfin: credentials } } = (getState() as AppState);
-
+    async (id: string, { dispatch }) => {
         // Generate the URL we can use to download the file
-        const url = generateTrackUrl(id as string, credentials);
+        const url = generateTrackUrl(id);
 
         // Get the content-type from the URL by doing a HEAD-only request
         const contentType = (await fetch(url, { method: 'HEAD' })).headers.get('Content-Type');

src/store/index.ts

@@ -87,6 +87,7 @@ const store = configureStore({
 export type AppState = ReturnType<typeof reducers> & { _persist: PersistState };
 export type AppDispatch = typeof store.dispatch;
 export type AsyncThunkAPI = { state: AppState, dispatch: AppDispatch };
+export type Store = typeof store;
 export const useTypedSelector: TypedUseSelectorHook<AppState> = useSelector;
 export const useAppDispatch: () => AppDispatch = useDispatch;
 

src/store/music/actions.ts

@@ -1,7 +1,9 @@
 import { createAsyncThunk, createEntityAdapter } from '@reduxjs/toolkit';
 import { Album, AlbumTrack, Playlist } from './types';
 import { AsyncThunkAPI } from '..';
-import { retrieveAllAlbums, retrieveAlbumTracks, retrieveRecentAlbums, searchItem, retrieveAlbum, retrieveAllPlaylists, retrievePlaylistTracks } from '@/utility/JellyfinApi';
+import { retrieveAllAlbums, retrieveRecentAlbums, retrieveAlbumTracks, retrieveAlbum } from '@/utility/JellyfinApi/album';
+import { retrieveAllPlaylists, retrievePlaylistTracks } from '@/utility/JellyfinApi/playlist';
+import { searchItem } from '@/utility/JellyfinApi/search';
 
 export const albumAdapter = createEntityAdapter<Album, string>({
     selectId: album => album.Id,
@@ -13,10 +15,7 @@ export const albumAdapter = createEntityAdapter<Album, string>({
  */
 export const fetchAllAlbums = createAsyncThunk<Album[], undefined, AsyncThunkAPI>(
     '/albums/all',
-    async (empty, thunkAPI) => {
-        const credentials = thunkAPI.getState().settings.jellyfin;
-        return retrieveAllAlbums(credentials) as Promise<Album[]>;
-    }
+    retrieveAllAlbums,
 );
 
 /**
@@ -24,10 +23,7 @@ export const fetchAllAlbums = createAsyncThunk<Album[], undefined, AsyncThunkAPI
  */
 export const fetchRecentAlbums = createAsyncThunk<Album[], number | undefined, AsyncThunkAPI>(
     '/albums/recent',
-    async (numberOfAlbums, thunkAPI) => {
-        const credentials = thunkAPI.getState().settings.jellyfin;
-        return retrieveRecentAlbums(credentials, numberOfAlbums) as Promise<Album[]>;
-    }
+    retrieveRecentAlbums,
 );
 
 export const trackAdapter = createEntityAdapter<AlbumTrack, string>({
@@ -40,18 +36,12 @@ export const trackAdapter = createEntityAdapter<AlbumTrack, string>({
  */
 export const fetchTracksByAlbum = createAsyncThunk<AlbumTrack[], string, AsyncThunkAPI>(
     '/tracks/byAlbum',
-    async (ItemId, thunkAPI) => {
-        const credentials = thunkAPI.getState().settings.jellyfin;
-        return retrieveAlbumTracks(ItemId, credentials) as Promise<AlbumTrack[]>;
-    }
+    retrieveAlbumTracks,
 );
 
 export const fetchAlbum = createAsyncThunk<Album, string, AsyncThunkAPI>(
     '/albums/single',
-    async (ItemId, thunkAPI) => {
-        const credentials = thunkAPI.getState().settings.jellyfin;
-        return retrieveAlbum(credentials, ItemId) as Promise<Album>;
-    }
+    retrieveAlbum,
 );
 
 type SearchAndFetchResults = {
@@ -67,7 +57,7 @@ AsyncThunkAPI
     '/search',
     async ({ term, limit = 24 }, thunkAPI) => {
         const state = thunkAPI.getState();
-        const results = await searchItem(state.settings.jellyfin, term, limit);
+        const results = await searchItem(term, limit);
 
         const albums = await Promise.all(results.filter((item) => (
             !state.music.albums.ids.includes(item.Type === 'MusicAlbum' ? item.Id : item.AlbumId)
@@ -77,7 +67,7 @@ AsyncThunkAPI
                 return item;
             }
 
-            return retrieveAlbum(state.settings.jellyfin, item.AlbumId);
+            return retrieveAlbum(item.AlbumId);
         }));
 
         return {
@@ -97,10 +87,7 @@ export const playlistAdapter = createEntityAdapter<Playlist, string>({
  */
 export const fetchAllPlaylists = createAsyncThunk<Playlist[], undefined, AsyncThunkAPI>(
     '/playlists/all',
-    async (empty, thunkAPI) => {
-        const credentials = thunkAPI.getState().settings.jellyfin;
-        return retrieveAllPlaylists(credentials) as Promise<Playlist[]>;
-    }
+    retrieveAllPlaylists,
 );
 
 /**
@@ -108,8 +95,5 @@ export const fetchAllPlaylists = createAsyncThunk<Playlist[], undefined, AsyncTh
  */
 export const fetchTracksByPlaylist = createAsyncThunk<AlbumTrack[], string, AsyncThunkAPI>(
     '/tracks/byPlaylist',
-    async (ItemId, thunkAPI) => {
-        const credentials = thunkAPI.getState().settings.jellyfin;
-        return retrievePlaylistTracks(ItemId, credentials) as Promise<AlbumTrack[]>;
-    }
+    retrievePlaylistTracks,
 );