@fett/synology-api 0.0.1-beta.8 → 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import { SynologyApi } from "./core.js";
+export * from "./types/index.js";
+export * from "./core.js";
+export default SynologyApi;

package/lib/index.js

@@ -0,0 +1,4 @@
+import { SynologyApi } from "./core.js";
+export * from "./types/index.js";
+export * from "./core.js";
+export default SynologyApi;

package/lib/modules/Api/Auth.d.ts

@@ -0,0 +1,4 @@
+import { SynologyApiResponse } from "../../types/index.js";
+import { SynologyApi } from "../../core.js";
+export declare function login(core: SynologyApi): Promise<SynologyApiResponse>;
+export declare function logout(core: SynologyApi): Promise<void>;

package/lib/modules/Api/Auth.js

@@ -0,0 +1,30 @@
+import ky from "ky";
+import { SynologyApiInfo } from "../../types/index.js";
+export async function login(core) {
+    const params = {
+        api: SynologyApiInfo.Auth,
+        version: 6,
+        method: "login",
+        account: core.username,
+        passwd: core.password,
+        format: "sid",
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = await ky.get(url, { searchParams: params }).json();
+    if (!result.success) {
+        throw new Error(result.error.message);
+    }
+    return result;
+}
+export async function logout(core) {
+    const params = {
+        api: SynologyApiInfo.Auth,
+        version: 6,
+        method: "logout",
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = await ky.get(url, { searchParams: params }).json();
+    if (!result.success) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/modules/Api/Info.d.ts

@@ -0,0 +1,3 @@
+import { SynologyApiResponse } from "../../types/index.js";
+import { SynologyApi } from "../../core.js";
+export declare function getApiInfo(core: SynologyApi): Promise<SynologyApiResponse>;

package/lib/modules/Api/Info.js

@@ -0,0 +1,15 @@
+import ky from "ky";
+import { SynologyApiInfo } from "../../types/index.js";
+export async function getApiInfo(core) {
+    const params = {
+        api: SynologyApiInfo.Info,
+        version: 1,
+        method: "query",
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = await ky.get(url, { searchParams: params }).json();
+    if (!result.success) {
+        throw new Error(result.error.message);
+    }
+    return result;
+}

package/lib/modules/Api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Auth.js";
+export * from "./Info.js";

package/lib/modules/Api/index.js

@@ -0,0 +1,2 @@
+export * from "./Auth.js";
+export * from "./Info.js";

package/lib/modules/AudioStation/Album.d.ts

@@ -0,0 +1,30 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type AudioStationAlbumListParams = {
+    limit?: number;
+    offset?: number;
+    library?: "all" | "personal";
+    additional?: string[];
+    version?: number;
+    filter?: string;
+    artist?: string;
+    genre?: string;
+    sort_by?: "time" | "random" | "year" | "name" | "display_artist" | "avg_rating";
+    sort_direction?: "ASC" | "DESC";
+};
+export type AudioStationAlbumListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    albums: Array<{
+        additional: {
+            avg_rating?: {
+                rating: number;
+            };
+        };
+        album_artist: string;
+        artist: string;
+        display_artist: string;
+        name: string;
+        year: number;
+    }>;
+}>;
+export declare function getAlbumList(params: AudioStationAlbumListParams): Promise<AudioStationAlbumListResponse>;

package/lib/modules/AudioStation/Album.js

@@ -0,0 +1,17 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getAlbumList(params) {
+    const { additional = ["avg_rating"], library = "all", limit = 1000, offset = 0, sort_by = "name", sort_direction = "ASC", ...extraParams } = params;
+    const res = await this.run(AudioStationApi.Album, {
+        params: {
+            method: "list",
+            limit: limit,
+            offset: offset,
+            library: library,
+            sort_by: sort_by,
+            sort_direction: sort_direction,
+            additional: additional.join(","),
+            ...extraParams,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Artist.d.ts

@@ -0,0 +1,25 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type AudioStationArtistListParams = {
+    limit?: number;
+    offset?: number;
+    library?: "all" | "personal";
+    additional?: string[];
+    filter?: string;
+    artist?: string;
+    genre?: string;
+    sort_by?: "name";
+    sort_direction?: "ASC" | "DESC";
+};
+export type AudioStationArtistListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    artists: Array<{
+        additional: {
+            avg_rating?: {
+                rating: number;
+            };
+        };
+        name: string;
+    }>;
+}>;
+export declare function getArtistList(params: AudioStationArtistListParams): Promise<AudioStationArtistListResponse>;

package/lib/modules/AudioStation/Artist.js

@@ -0,0 +1,17 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getArtistList(params) {
+    const { additional = ["avg_rating"], library = "all", limit = 1000, offset = 0, sort_by = "name", sort_direction = "ASC", ...extraParams } = params;
+    const res = await this.run(AudioStationApi.Artist, {
+        params: {
+            method: "list",
+            limit: limit,
+            offset: offset,
+            library: library,
+            sort_by: sort_by,
+            sort_direction: sort_direction,
+            additional: additional.join(","),
+            ...extraParams,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Folder.d.ts

@@ -0,0 +1,24 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type AudioStationFolderListParams = {
+    limit?: number;
+    offset?: number;
+    library?: "all";
+    additional?: Array<"song_tag" | "song_audio" | "song_rating">;
+    id?: string;
+    sort_by?: "song_rating" | "title" | "album" | "artist" | "duration" | "track";
+    sort_direction?: "ASC" | "DESC";
+};
+export type AudioStationFolderListResponse = SynologyApiResponse<{
+    folder_total: number;
+    id: string;
+    items: Array<{
+        id: string;
+        is_personal: boolean;
+        path: string;
+        title: string;
+        type: string;
+    }>;
+    offset: number;
+    total: number;
+}>;
+export declare function getFolderList(params: AudioStationFolderListParams): Promise<AudioStationFolderListResponse>;

package/lib/modules/AudioStation/Folder.js

@@ -0,0 +1,17 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getFolderList(params) {
+    const { additional = ["song_tag", "song_audio", "song_rating"], library = "all", limit = 1000, offset = 0, sort_by = "title", sort_direction = "ASC", ...extraParams } = params;
+    const res = await this.run(AudioStationApi.Folder, {
+        params: {
+            method: "list",
+            limit: limit,
+            offset: offset,
+            library: library,
+            sort_by: sort_by,
+            sort_direction: sort_direction,
+            additional: additional.join(","),
+            ...extraParams,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Info.d.ts

@@ -0,0 +1,45 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type AudioStationInfoResponse = SynologyApiResponse<{
+    ame_status: {
+        ame_major_version: number;
+        has_aac: boolean;
+        has_license: boolean;
+        is_aac_activated: boolean;
+        is_ame_broken: boolean;
+        is_ame_install: boolean;
+        need_aac_transcoding: boolean;
+    };
+    browse_personal_library: string;
+    dsd_decode_capability: boolean;
+    enable_equalizer: boolean;
+    enable_personal_library: boolean;
+    enable_user_home: boolean;
+    has_music_share: boolean;
+    is_manager: boolean;
+    playing_queue_max: number;
+    privilege: {
+        playlist_edit: boolean;
+        remote_player: boolean;
+        sharing: boolean;
+        tag_edit: boolean;
+        upnp_browse: boolean;
+    };
+    remote_controller: boolean;
+    same_subnet: boolean;
+    serial_number: string;
+    settings: {
+        audio_show_virtual_library: boolean;
+        disable_upnp: boolean;
+        enable_download: boolean;
+        prefer_using_html5: boolean;
+        transcode_to_mp3: boolean;
+    };
+    sid: string;
+    support_bluetooth: boolean;
+    support_usb: boolean;
+    support_virtual_library: boolean;
+    transcode_capability: Array<string>;
+    version: number;
+    version_string: string;
+}>;
+export declare function getInfo(): Promise<AudioStationInfoResponse>;

package/lib/modules/AudioStation/Info.js

@@ -0,0 +1,9 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getInfo() {
+    const res = await this.run(AudioStationApi.Info, {
+        params: {
+            method: "getinfo",
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Lyrics.d.ts

@@ -0,0 +1,25 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export declare function getLyrics(params: {
+    id: string;
+}): Promise<SynologyApiResponse<{
+    lyrics: string;
+}>>;
+export type AudioStationSearchLyricsParams = {
+    title?: string;
+    artist?: string;
+    limit?: number;
+    additional?: Array<"full_lyrics" | string>;
+};
+export type AudioStationSearchLyricsResponse = SynologyApiResponse<{
+    lyrics: Array<{
+        additional: {
+            full_lyrics: string;
+        };
+        artist: string;
+        id: string;
+        partial_lyrics: string;
+        plugin: string;
+        title: string;
+    }>;
+}>;
+export declare function searchLyrics(params: AudioStationSearchLyricsParams): Promise<AudioStationSearchLyricsResponse>;

package/lib/modules/AudioStation/Lyrics.js

@@ -0,0 +1,23 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getLyrics(params // song id
+) {
+    const res = await this.run(AudioStationApi.Lyrics, {
+        params: {
+            method: "getlyrics",
+            id: params.id,
+        },
+    });
+    return res;
+}
+export async function searchLyrics(params) {
+    const { additional = ["full_lyrics"], limit = 1, ...extraParams } = params;
+    const res = await this.run(AudioStationApi.LyricsSearch, {
+        params: {
+            method: "searchlyrics",
+            limit: limit,
+            additional: additional.join(","),
+            ...extraParams,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Playlist.d.ts

@@ -0,0 +1,34 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type AudioStationCreatePlaylistParams = {
+    library?: "all" | "personal";
+    name: string;
+};
+export type AudioStationCreatePlaylistResponse = SynologyApiResponse<{
+    id: string;
+}>;
+export declare function createPlaylist(params: AudioStationCreatePlaylistParams): Promise<AudioStationCreatePlaylistResponse>;
+export type AudioStationPlaylistParams = {
+    limit?: number;
+    offset?: number;
+    library?: "all" | "personal";
+};
+export type AudioStationPlaylistResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    playlists: Array<{
+        id: string;
+        library: string;
+        name: string;
+        sharing_status: string;
+        type: string;
+    }>;
+}>;
+export declare function getPlaylist(params: AudioStationPlaylistParams): Promise<AudioStationPlaylistResponse>;
+/**
+ * deletePlaylist
+ * @param id
+ * @returns
+ */
+export declare function deletePlaylist(params: {
+    id: string;
+}): Promise<SynologyApiResponse<any>>;

package/lib/modules/AudioStation/Playlist.js

@@ -0,0 +1,38 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function createPlaylist(params) {
+    const { library = "all", name } = params;
+    const res = await this.run(AudioStationApi.Playlist, {
+        params: {
+            method: "create",
+            library,
+            name,
+        },
+    });
+    return res;
+}
+export async function getPlaylist(params) {
+    const { library = "all", limit = 1000, offset = 0 } = params;
+    const res = await this.run(AudioStationApi.Playlist, {
+        params: {
+            method: "list",
+            limit: limit,
+            offset: offset,
+            library: library,
+        },
+    });
+    return res;
+}
+/**
+ * deletePlaylist
+ * @param id
+ * @returns
+ */
+export async function deletePlaylist(params) {
+    const res = await this.run(AudioStationApi.Playlist, {
+        params: {
+            method: "delete",
+            id: params.id,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Search.d.ts

@@ -0,0 +1,53 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type AudioStationSearchListParams = {
+    limit?: number;
+    library?: "all" | "personal";
+    additional?: Array<"song_tag" | "song_audio" | "song_rating">;
+    keyword?: string;
+    sort_by?: "title";
+    sort_direction?: "ASC" | "DESC";
+};
+export type AudioStationSearchListResponse = SynologyApiResponse<{
+    albumTotal: number;
+    albums: Array<{
+        album_artist: string;
+        artist: string;
+        display_artist: string;
+        name: string;
+        year: number;
+    }>;
+    artistTotal: number;
+    artists: Array<{
+        name: string;
+    }>;
+    songTotal: number;
+    songs: Array<{
+        additional: {
+            song_audio: {
+                bitrate: number;
+                channel: number;
+                codec: string;
+                container: string;
+                duration: number;
+                filesize: number;
+                frequency: number;
+            };
+            song_tag: {
+                album: string;
+                album_artist: string;
+                artist: string;
+                comment: string;
+                composer: string;
+                disc: number;
+                genre: string;
+                track: number;
+                year: number;
+            };
+        };
+        id: string;
+        path: string;
+        title: string;
+        type: string;
+    }>;
+}>;
+export declare function getArtistList(params: AudioStationSearchListParams): Promise<AudioStationSearchListResponse>;

package/lib/modules/AudioStation/Search.js

@@ -0,0 +1,17 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getArtistList(params) {
+    const { additional = ["song_tag", "song_audio", "song_rating"], library = "all", limit = 10, sort_by = "title", sort_direction = "ASC", keyword = "", ...extraParams } = params;
+    const res = await this.run(AudioStationApi.Search, {
+        params: {
+            method: "list",
+            limit: limit,
+            keyword: keyword,
+            library: library,
+            sort_by: sort_by,
+            sort_direction: sort_direction,
+            additional: additional.join(","),
+            ...extraParams,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/Song.d.ts

@@ -0,0 +1,33 @@
+import { SynologyApiResponse } from "../../types/index.js";
+/**
+ * fetch song list
+ * */
+export type AudioStationSongListParams = {
+    limit?: number;
+    offset?: number;
+    library?: "all" | "personal";
+    additional?: Array<"song_tag" | "song_audio" | "song_rating">;
+    rating_filter?: number;
+    album_artist?: string;
+    album?: string;
+    artist?: string;
+    genre?: string;
+    sort_by?: "title" | "artist" | "random" | "name";
+    sort_direction?: "ASC" | "DESC";
+};
+export type AudioStationSongListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    songs: {
+        [key: string]: any;
+    };
+}>;
+export declare function getSongList(params: AudioStationSongListParams): Promise<AudioStationSongListResponse>;
+/**
+ * set song rating
+ */
+export type AudioStationSetSongRatingParams = {
+    id: string;
+    rating: number;
+};
+export declare function setSongRating(params: AudioStationSetSongRatingParams): Promise<SynologyApiResponse<any>>;

package/lib/modules/AudioStation/Song.js

@@ -0,0 +1,27 @@
+import { AudioStationApi } from "../../types/index.js";
+export async function getSongList(params) {
+    const { additional = ["song_tag", "song_audio", "song_rating"], library = "all", limit = 1000, offset = 0, sort_by = "title", sort_direction = "DESC", ...extraParams } = params;
+    const res = await this.run(AudioStationApi.Song, {
+        params: {
+            method: "list",
+            limit: limit,
+            offset: offset,
+            library: library,
+            sort_by: sort_by,
+            sort_direction: sort_direction,
+            additional: additional.join(","),
+            ...extraParams,
+        },
+    });
+    return res;
+}
+export async function setSongRating(params) {
+    const res = await this.run(AudioStationApi.Song, {
+        params: {
+            method: "setrating",
+            id: params.id,
+            rating: params.rating,
+        },
+    });
+    return res;
+}

package/lib/modules/AudioStation/index.d.ts

@@ -0,0 +1,23 @@
+import { getSongList, setSongRating } from "./Song.js";
+import { getAlbumList } from "./Album.js";
+import { getArtistList } from "./Artist.js";
+import { getPlaylist, createPlaylist, deletePlaylist } from "./Playlist.js";
+import { getFolderList } from "./Folder.js";
+import { getLyrics, searchLyrics } from "./Lyrics.js";
+import { getInfo } from "./Info.js";
+export declare const METHODS: {
+    getSongList: typeof getSongList;
+    setSongRating: typeof setSongRating;
+    getAlbumList: typeof getAlbumList;
+    getArtistList: typeof getArtistList;
+    getPlaylist: typeof getPlaylist;
+    createPlaylist: typeof createPlaylist;
+    deletePlaylist: typeof deletePlaylist;
+    getFolderList: typeof getFolderList;
+    getLyrics: typeof getLyrics;
+    searchLyrics: typeof searchLyrics;
+    getInfo: typeof getInfo;
+};
+export declare const SPELLING_KEY = "AudioStation";
+export declare const SIMPLIFY_KEY = "as";
+export type TMethods = typeof METHODS;

package/lib/modules/AudioStation/index.js

@@ -0,0 +1,23 @@
+import { getSongList, setSongRating } from "./Song.js";
+import { getAlbumList } from "./Album.js";
+import { getArtistList } from "./Artist.js";
+import { getPlaylist, createPlaylist, deletePlaylist } from "./Playlist.js";
+import { getFolderList } from "./Folder.js";
+import { getLyrics, searchLyrics } from "./Lyrics.js";
+import { getInfo } from "./Info.js";
+export const METHODS = {
+    getSongList,
+    setSongRating,
+    getAlbumList,
+    getArtistList,
+    getPlaylist,
+    createPlaylist,
+    deletePlaylist,
+    getFolderList,
+    getLyrics,
+    searchLyrics,
+    getInfo,
+};
+// name space
+export const SPELLING_KEY = "AudioStation";
+export const SIMPLIFY_KEY = "as";

package/lib/modules/Auth/AuthKey.d.ts

@@ -0,0 +1,8 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type SynologyApiGetAuthKeyGrantParams = {
+    allow_api: string;
+    allow_methods: string[];
+};
+export declare function getAuthKeyGrant(params: SynologyApiGetAuthKeyGrantParams): Promise<SynologyApiResponse<{
+    tid: string;
+}>>;

package/lib/modules/Auth/AuthKey.js

@@ -0,0 +1,12 @@
+import { SynologyApiInfo } from "../../types/index.js";
+export async function getAuthKeyGrant(params) {
+    const { allow_methods, allow_api } = params;
+    const result = await this.run(SynologyApiInfo.AuthKey, {
+        params: {
+            method: "grant",
+            allow_api: allow_api,
+            allow_methods: JSON.stringify(allow_methods),
+        },
+    });
+    return result;
+}

package/lib/modules/Auth/index.d.ts

@@ -0,0 +1,7 @@
+import { getAuthKeyGrant } from "./AuthKey.js";
+export declare const METHODS: {
+    getAuthKeyGrant: typeof getAuthKeyGrant;
+};
+export declare const SPELLING_KEY = "Auth";
+export declare const SIMPLIFY_KEY = "au";
+export type TMethods = typeof METHODS;

package/lib/modules/Auth/index.js

@@ -0,0 +1,8 @@
+import { getAuthKeyGrant } from "./AuthKey.js";
+// fs methods
+export const METHODS = {
+    getAuthKeyGrant,
+};
+// name space
+export const SPELLING_KEY = "Auth";
+export const SIMPLIFY_KEY = "au";

package/lib/{types/modules → modules}/FileStation/Info.d.ts

@@ -1,4 +1,4 @@
-import { SynologyApiResponse } from "../../types";
+import { SynologyApiResponse } from "../../types/index.js";
 /**
  * get filestation info
  */

package/lib/modules/FileStation/Info.js

@@ -0,0 +1,9 @@
+import { FileStationApi } from "../../types/index.js";
+export async function getInfo() {
+    const res = await this.run(FileStationApi.Info, {
+        params: {
+            method: "get",
+        },
+    });
+    return res;
+}

package/lib/{types/modules → modules}/FileStation/List.d.ts

@@ -1,4 +1,4 @@
-import { SynologyApiResponse } from "../../types";
+import { SynologyApiResponse } from "../../types/index.js";
 /**
  * fetch filestation list
  */