maybe?

api/queries.ts

@@ -1,10 +1,10 @@
 import { Jellyfin } from "@jellyfin/sdk"
-import { useQuery } from "@tanstack/react-query";
+import { Query, useQuery } from "@tanstack/react-query";
 import { getDeviceNameSync, getUniqueIdSync } from "react-native-device-info"
 import { QueryKeys } from "../enums/query-keys";
-import { useCredentials } from "./queries/keychain";
 import { name, version } from "../package.json"
-import { createPublicApi } from "./query-functions/api";
+import { createApi, createPublicApi } from "./query-functions/api";
+import { fetchServerUrl } from "./query-functions/storage";
 
 export const client : Jellyfin  = new Jellyfin({
     clientInfo: {
@@ -24,10 +24,16 @@ export const usePublicApi = (serverUrl: string) => useQuery({
     }
 })
 
-export const useApi = useQuery({
-    queryKey: [QueryKeys.Api],
+export const useApi = (serverUrl: string) => useQuery({
+    queryKey: [QueryKeys.Api, serverUrl],
+    queryFn: async ({ queryKey }) => {
+        createApi(queryKey[1]);
+    }
+})
+
+export const useServerUrl = () => useQuery({
+    queryKey: [QueryKeys.ServerUrl],
     queryFn: () => {
-        let credentials = useCredentials.data!
-        return client.createApi(credentials.server, credentials.password);
+        return fetchServerUrl()
     }
 })

api/queries/albums.ts

@@ -4,16 +4,18 @@ import { QueryKeys } from "../../enums/query-keys";
 import { useApi } from "../queries";
 import { BaseItemDto } from "@jellyfin/sdk/lib/generated-client/models";
 import { useChildrenFromParent } from "./items";
+import { fetchServerUrl } from "../query-functions/storage";
+import { createApi } from "../query-functions/api";
 
 export const useArtistAlbums : (artistId: string) => UseQueryResult<BaseItemDto[], Error> = (artistId: string) => useQuery({
     queryKey: [QueryKeys.ArtistAlbums, artistId],
-    queryFn: (({ queryKey }) => {
-        return getItemsApi(useApi.data!)
+    queryFn: async ({ queryKey }) => {
+        return getItemsApi(await createApi(await fetchServerUrl()))
             .getItems({ albumArtistIds: [queryKey[1]] })
             .then((result) => {
                 return result.data.Items
             });
-    })
+    }
 });
 
 export const useAlbumSongs : (albumId: string) => UseQueryResult<BaseItemDto[], Error> = (albumId: string) => useChildrenFromParent(QueryKeys.AlbumTracks, albumId);

api/queries/playlist.ts

@@ -1,12 +1,13 @@
 import { useQuery } from "@tanstack/react-query";
 import { QueryKeys } from "../../enums/query-keys";
 import { getPlaylistsApi } from "@jellyfin/sdk/lib/utils/api/playlists-api"
-import { useApi } from "../queries";
+import { createApi } from "../query-functions/api";
+import { fetchServerUrl } from "../query-functions/storage";
 
 
 export const usePlaylists = useQuery({
     queryKey: [QueryKeys.Playlists],
-    queryFn: () => {
-        return getPlaylistsApi(useApi.data!)
+    queryFn: async () => {
+        return getPlaylistsApi(await createApi(await fetchServerUrl()))
     }
 })

api/queries/public.ts

@@ -2,10 +2,12 @@ import { useQuery } from "@tanstack/react-query";
 import { QueryKeys } from "../../enums/query-keys";
 import { usePublicApi } from "../queries";
 import { getSystemApi } from "@jellyfin/sdk/lib/utils/api/system-api";
+import { createPublicApi } from "../query-functions/api";
 
 export const usePublicSystemInfo = (serverUrl: string) => useQuery({
     queryKey: [QueryKeys.PublicSystemInfo, serverUrl],
     queryFn: ({ queryKey }) => {
-        return getSystemApi(usePublicApi(queryKey[1]).data!).getPublicSystemInfo()
+        return getSystemApi(createPublicApi(queryKey[1]))
+            .getPublicSystemInfo()
     }
 });

api/query-functions/api.ts

@@ -1,7 +1,12 @@
 import { Api } from "@jellyfin/sdk";
 import { client } from "../queries";
+import { fetchCredentials } from "./keychain";
 
 
+export const createApi: (serverUrl: string) => Promise<Api> = async (serverUrl) => {
+    let credentials = await fetchCredentials(serverUrl)
+    return client.createApi(credentials.server, credentials.password);
+}
 
 export const createPublicApi: (serverUrl: string) => Api = (serverUrl) => {
     return client.createApi(serverUrl);