Add subsonic server support

src/i18n/locales/en.json

@@ -552,7 +552,7 @@
         "column": {
             "album": "album",
             "albumArtist": "album artist",
-            "albumCount": "$t(entity.album_other)",
+            "albumCount": "$t(entity.album_one)",
             "artist": "$t(entity.artist_one)",
             "biography": "biography",
             "bitrate": "bitrate",

src/logger.ts

@@ -0,0 +1,41 @@
+import dayjs from 'dayjs';
+
+const reset = '\x1b[0m';
+
+const baseLog = (errorType: 'error' | 'info' | 'success' | 'warn') => {
+    let logString = '';
+    switch (errorType) {
+        case 'error':
+            logString = '\x1b[31m[ERROR]   ';
+            break;
+        case 'info':
+            logString = '\x1b[34m[INFO]    ';
+            break;
+        case 'success':
+            logString = '\x1b[32m[SUCCESS] ';
+            break;
+        case 'warn':
+            logString = '\x1b[33m[WARNING] ';
+            break;
+        default:
+            logString = '\x1b[34m[INFO]    ';
+            break;
+    }
+
+    return (text: string, options?: { context?: Record<string, any>; toast?: boolean }): void => {
+        // const { toast } = options || {};
+        const now = dayjs().toISOString();
+        console.log(
+            `${logString}${now}: ${text} | ${
+                options?.context && JSON.stringify(options.context)
+            }${reset}`,
+        );
+    };
+};
+
+export const fsLog = {
+    error: baseLog('error'),
+    info: baseLog('info'),
+    success: baseLog('success'),
+    warn: baseLog('warn'),
+};

src/renderer/api/controller.ts

@@ -1,100 +1,38 @@
-import { useAuthStore } from '/@/renderer/store';
-import { toast } from '/@/renderer/components/toast/index';
+import { RandomSongListArgs } from './types';
+import i18n from '/@/i18n/i18n';
+import { JellyfinController } from '/@/renderer/api/jellyfin/jellyfin-controller';
+import { NavidromeController } from '/@/renderer/api/navidrome/navidrome-controller';
+import { SubsonicController } from '/@/renderer/api/subsonic/subsonic-controller';
 import type {
-    AlbumDetailArgs,
-    AlbumListArgs,
-    SongListArgs,
-    SongDetailArgs,
+    AddToPlaylistArgs,
     AlbumArtistDetailArgs,
     AlbumArtistListArgs,
-    SetRatingArgs,
-    GenreListArgs,
+    AlbumDetailArgs,
+    AlbumListArgs,
+    ArtistListArgs,
+    ControllerEndpoint,
     CreatePlaylistArgs,
     DeletePlaylistArgs,
+    FavoriteArgs,
+    GenreListArgs,
+    LyricsArgs,
+    MusicFolderListArgs,
     PlaylistDetailArgs,
     PlaylistListArgs,
-    MusicFolderListArgs,
     PlaylistSongListArgs,
-    ArtistListArgs,
-    UpdatePlaylistArgs,
-    UserListArgs,
-    FavoriteArgs,
-    TopSongListArgs,
-    AddToPlaylistArgs,
-    AddToPlaylistResponse,
     RemoveFromPlaylistArgs,
-    RemoveFromPlaylistResponse,
     ScrobbleArgs,
-    ScrobbleResponse,
-    AlbumArtistDetailResponse,
-    FavoriteResponse,
-    CreatePlaylistResponse,
-    AlbumArtistListResponse,
-    AlbumDetailResponse,
-    AlbumListResponse,
-    ArtistListResponse,
-    GenreListResponse,
-    MusicFolderListResponse,
-    PlaylistDetailResponse,
-    PlaylistListResponse,
-    RatingResponse,
-    SongDetailResponse,
-    SongListResponse,
-    TopSongListResponse,
-    UpdatePlaylistResponse,
-    UserListResponse,
-    AuthenticationResponse,
     SearchArgs,
-    SearchResponse,
-    LyricsArgs,
-    LyricsResponse,
+    SetRatingArgs,
+    SongDetailArgs,
+    SongListArgs,
+    TopSongListArgs,
+    UpdatePlaylistArgs,
+    UserListArgs,
 } from '/@/renderer/api/types';
+import { toast } from '/@/renderer/components/toast/index';
+import { useAuthStore } from '/@/renderer/store';
 import { ServerType } from '/@/renderer/types';
-import { DeletePlaylistResponse, RandomSongListArgs } from './types';
-import { ndController } from '/@/renderer/api/navidrome/navidrome-controller';
-import { ssController } from '/@/renderer/api/subsonic/subsonic-controller';
-import { jfController } from '/@/renderer/api/jellyfin/jellyfin-controller';
-import i18n from '/@/i18n/i18n';
-
-export type ControllerEndpoint = Partial<{
-    addToPlaylist: (args: AddToPlaylistArgs) => Promise<AddToPlaylistResponse>;
-    authenticate: (
-        url: string,
-        body: { password: string; username: string },
-    ) => Promise<AuthenticationResponse>;
-    clearPlaylist: () => void;
-    createFavorite: (args: FavoriteArgs) => Promise<FavoriteResponse>;
-    createPlaylist: (args: CreatePlaylistArgs) => Promise<CreatePlaylistResponse>;
-    deleteFavorite: (args: FavoriteArgs) => Promise<FavoriteResponse>;
-    deletePlaylist: (args: DeletePlaylistArgs) => Promise<DeletePlaylistResponse>;
-    getAlbumArtistDetail: (args: AlbumArtistDetailArgs) => Promise<AlbumArtistDetailResponse>;
-    getAlbumArtistList: (args: AlbumArtistListArgs) => Promise<AlbumArtistListResponse>;
-    getAlbumDetail: (args: AlbumDetailArgs) => Promise<AlbumDetailResponse>;
-    getAlbumList: (args: AlbumListArgs) => Promise<AlbumListResponse>;
-    getArtistDetail: () => void;
-    getArtistInfo: (args: any) => void;
-    getArtistList: (args: ArtistListArgs) => Promise<ArtistListResponse>;
-    getFavoritesList: () => void;
-    getFolderItemList: () => void;
-    getFolderList: () => void;
-    getFolderSongs: () => void;
-    getGenreList: (args: GenreListArgs) => Promise<GenreListResponse>;
-    getLyrics: (args: LyricsArgs) => Promise<LyricsResponse>;
-    getMusicFolderList: (args: MusicFolderListArgs) => Promise<MusicFolderListResponse>;
-    getPlaylistDetail: (args: PlaylistDetailArgs) => Promise<PlaylistDetailResponse>;
-    getPlaylistList: (args: PlaylistListArgs) => Promise<PlaylistListResponse>;
-    getPlaylistSongList: (args: PlaylistSongListArgs) => Promise<SongListResponse>;
-    getRandomSongList: (args: RandomSongListArgs) => Promise<SongListResponse>;
-    getSongDetail: (args: SongDetailArgs) => Promise<SongDetailResponse>;
-    getSongList: (args: SongListArgs) => Promise<SongListResponse>;
-    getTopSongs: (args: TopSongListArgs) => Promise<TopSongListResponse>;
-    getUserList: (args: UserListArgs) => Promise<UserListResponse>;
-    removeFromPlaylist: (args: RemoveFromPlaylistArgs) => Promise<RemoveFromPlaylistResponse>;
-    scrobble: (args: ScrobbleArgs) => Promise<ScrobbleResponse>;
-    search: (args: SearchArgs) => Promise<SearchResponse>;
-    setRating: (args: SetRatingArgs) => Promise<RatingResponse>;
-    updatePlaylist: (args: UpdatePlaylistArgs) => Promise<UpdatePlaylistResponse>;
-}>;
 
 type ApiController = {
     jellyfin: ControllerEndpoint;
@@ -103,110 +41,9 @@ type ApiController = {
 };
 
 const endpoints: ApiController = {
-    jellyfin: {
-        addToPlaylist: jfController.addToPlaylist,
-        authenticate: jfController.authenticate,
-        clearPlaylist: undefined,
-        createFavorite: jfController.createFavorite,
-        createPlaylist: jfController.createPlaylist,
-        deleteFavorite: jfController.deleteFavorite,
-        deletePlaylist: jfController.deletePlaylist,
-        getAlbumArtistDetail: jfController.getAlbumArtistDetail,
-        getAlbumArtistList: jfController.getAlbumArtistList,
-        getAlbumDetail: jfController.getAlbumDetail,
-        getAlbumList: jfController.getAlbumList,
-        getArtistDetail: undefined,
-        getArtistInfo: undefined,
-        getArtistList: undefined,
-        getFavoritesList: undefined,
-        getFolderItemList: undefined,
-        getFolderList: undefined,
-        getFolderSongs: undefined,
-        getGenreList: jfController.getGenreList,
-        getLyrics: jfController.getLyrics,
-        getMusicFolderList: jfController.getMusicFolderList,
-        getPlaylistDetail: jfController.getPlaylistDetail,
-        getPlaylistList: jfController.getPlaylistList,
-        getPlaylistSongList: jfController.getPlaylistSongList,
-        getRandomSongList: jfController.getRandomSongList,
-        getSongDetail: jfController.getSongDetail,
-        getSongList: jfController.getSongList,
-        getTopSongs: jfController.getTopSongList,
-        getUserList: undefined,
-        removeFromPlaylist: jfController.removeFromPlaylist,
-        scrobble: jfController.scrobble,
-        search: jfController.search,
-        setRating: undefined,
-        updatePlaylist: jfController.updatePlaylist,
-    },
-    navidrome: {
-        addToPlaylist: ndController.addToPlaylist,
-        authenticate: ndController.authenticate,
-        clearPlaylist: undefined,
-        createFavorite: ssController.createFavorite,
-        createPlaylist: ndController.createPlaylist,
-        deleteFavorite: ssController.removeFavorite,
-        deletePlaylist: ndController.deletePlaylist,
-        getAlbumArtistDetail: ndController.getAlbumArtistDetail,
-        getAlbumArtistList: ndController.getAlbumArtistList,
-        getAlbumDetail: ndController.getAlbumDetail,
-        getAlbumList: ndController.getAlbumList,
-        getArtistDetail: undefined,
-        getArtistInfo: undefined,
-        getArtistList: undefined,
-        getFavoritesList: undefined,
-        getFolderItemList: undefined,
-        getFolderList: undefined,
-        getFolderSongs: undefined,
-        getGenreList: ndController.getGenreList,
-        getLyrics: undefined,
-        getMusicFolderList: ssController.getMusicFolderList,
-        getPlaylistDetail: ndController.getPlaylistDetail,
-        getPlaylistList: ndController.getPlaylistList,
-        getPlaylistSongList: ndController.getPlaylistSongList,
-        getRandomSongList: ssController.getRandomSongList,
-        getSongDetail: ndController.getSongDetail,
-        getSongList: ndController.getSongList,
-        getTopSongs: ssController.getTopSongList,
-        getUserList: ndController.getUserList,
-        removeFromPlaylist: ndController.removeFromPlaylist,
-        scrobble: ssController.scrobble,
-        search: ssController.search3,
-        setRating: ssController.setRating,
-        updatePlaylist: ndController.updatePlaylist,
-    },
-    subsonic: {
-        authenticate: ssController.authenticate,
-        clearPlaylist: undefined,
-        createFavorite: ssController.createFavorite,
-        createPlaylist: undefined,
-        deleteFavorite: ssController.removeFavorite,
-        deletePlaylist: undefined,
-        getAlbumArtistDetail: undefined,
-        getAlbumArtistList: undefined,
-        getAlbumDetail: undefined,
-        getAlbumList: undefined,
-        getArtistDetail: undefined,
-        getArtistInfo: undefined,
-        getArtistList: undefined,
-        getFavoritesList: undefined,
-        getFolderItemList: undefined,
-        getFolderList: undefined,
-        getFolderSongs: undefined,
-        getGenreList: undefined,
-        getLyrics: undefined,
-        getMusicFolderList: ssController.getMusicFolderList,
-        getPlaylistDetail: undefined,
-        getPlaylistList: undefined,
-        getSongDetail: undefined,
-        getSongList: undefined,
-        getTopSongs: ssController.getTopSongList,
-        getUserList: undefined,
-        scrobble: ssController.scrobble,
-        search: ssController.search3,
-        setRating: undefined,
-        updatePlaylist: undefined,
-    },
+    jellyfin: JellyfinController,
+    navidrome: NavidromeController,
+    subsonic: SubsonicController,
 };
 
 const apiController = (endpoint: keyof ControllerEndpoint, type?: ServerType) => {
@@ -259,6 +96,15 @@ const getAlbumList = async (args: AlbumListArgs) => {
     )?.(args);
 };
 
+const getAlbumListCount = async (args: AlbumListArgs) => {
+    return (
+        apiController(
+            'getAlbumListCount',
+            args.apiClientProps.server?.type,
+        ) as ControllerEndpoint['getAlbumListCount']
+    )?.(args);
+};
+
 const getAlbumDetail = async (args: AlbumDetailArgs) => {
     return (
         apiController(
@@ -277,6 +123,15 @@ const getSongList = async (args: SongListArgs) => {
     )?.(args);
 };
 
+const getSongListCount = async (args: SongListArgs) => {
+    return (
+        apiController(
+            'getSongListCount',
+            args.apiClientProps.server?.type,
+        ) as ControllerEndpoint['getSongListCount']
+    )?.(args);
+};
+
 const getSongDetail = async (args: SongDetailArgs) => {
     return (
         apiController(
@@ -322,6 +177,15 @@ const getAlbumArtistList = async (args: AlbumArtistListArgs) => {
     )?.(args);
 };
 
+const getAlbumArtistListCount = async (args: AlbumArtistListArgs) => {
+    return (
+        apiController(
+            'getAlbumArtistListCount',
+            args.apiClientProps.server?.type,
+        ) as ControllerEndpoint['getAlbumArtistListCount']
+    )?.(args);
+};
+
 const getArtistList = async (args: ArtistListArgs) => {
     return (
         apiController(
@@ -340,6 +204,15 @@ const getPlaylistList = async (args: PlaylistListArgs) => {
     )?.(args);
 };
 
+const getPlaylistListCount = async (args: PlaylistListArgs) => {
+    return (
+        apiController(
+            'getPlaylistListCount',
+            args.apiClientProps.server?.type,
+        ) as ControllerEndpoint['getPlaylistListCount']
+    )?.(args);
+};
+
 const createPlaylist = async (args: CreatePlaylistArgs) => {
     return (
         apiController(
@@ -490,18 +363,22 @@ export const controller = {
     deletePlaylist,
     getAlbumArtistDetail,
     getAlbumArtistList,
+    getAlbumArtistListCount,
     getAlbumDetail,
     getAlbumList,
+    getAlbumListCount,
     getArtistList,
     getGenreList,
     getLyrics,
     getMusicFolderList,
     getPlaylistDetail,
     getPlaylistList,
+    getPlaylistListCount,
     getPlaylistSongList,
     getRandomSongList,
     getSongDetail,
     getSongList,
+    getSongListCount,
     getTopSongList,
     getUserList,
     removeFromPlaylist,