@fett/synology-api 0.0.2-beta.2 → 0.0.2

package/lib/modules/FileStation/Delete.js

@@ -0,0 +1,35 @@
+import { FileStationApi } from "../../types/index.js";
+export async function startDeleteFile(params) {
+    const { accurate_progress = true, recursive = true, path } = params;
+    const paths = Array.isArray(path) ? path : [path];
+    const res = await this.run(FileStationApi.Delete, {
+        params: {
+            method: "start",
+            path: JSON.stringify(paths),
+            accurate_progress,
+            recursive,
+            search_taskid: params?.search_taskid,
+        },
+    });
+    return res;
+}
+export async function stopDeleteFile(params) {
+    const { taskid } = params;
+    const res = await this.run(FileStationApi.Delete, {
+        params: {
+            method: "stop",
+            taskid,
+        },
+    });
+    return res;
+}
+export async function getDeleteFileStatus(params) {
+    const { taskid } = params;
+    const res = await this.run(FileStationApi.Delete, {
+        params: {
+            method: "status",
+            taskid,
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/DirSize.d.ts

@@ -0,0 +1,20 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type StartDirSizeCalcParams = {
+    path: string;
+};
+export type StartDirSizeCalcResponse = SynologyApiResponse<{
+    taskid: string;
+}>;
+export declare function startDirSizeCalc(params: StartDirSizeCalcParams): Promise<StartDirSizeCalcResponse>;
+export declare function stopDirSizeCalc(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<any>>;
+export type DirSizeCalcStatusResponse = SynologyApiResponse<{
+    finished: boolean;
+    num_dir: number;
+    num_file: number;
+    total_size: number;
+}>;
+export declare function getDirSizeCalcStatus(params: {
+    taskid: string;
+}): Promise<DirSizeCalcStatusResponse>;

package/lib/modules/FileStation/DirSize.js

@@ -0,0 +1,28 @@
+import { FileStationApi } from "../../types/index.js";
+export async function startDirSizeCalc(params) {
+    const res = await this.run(FileStationApi.DirSize, {
+        params: {
+            method: "start",
+            ...params,
+        },
+    });
+    return res;
+}
+export async function stopDirSizeCalc(params) {
+    const res = await this.run(FileStationApi.DirSize, {
+        params: {
+            method: "stop",
+            ...params,
+        },
+    });
+    return res;
+}
+export async function getDirSizeCalcStatus(params) {
+    const res = await this.run(FileStationApi.DirSize, {
+        params: {
+            method: "status",
+            ...params,
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/Download.d.ts

@@ -0,0 +1,7 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type DownloadFileParams = {
+    path: string;
+    mode?: "download" | "open";
+};
+export type DownloadFileResponse = SynologyApiResponse<string>;
+export declare function getDownloadFile(params: DownloadFileParams): Promise<DownloadFileResponse>;

package/lib/modules/FileStation/Download.js

@@ -0,0 +1,19 @@
+import { FileStationApi } from "../../types/index.js";
+import { buildUrlWithQuery } from "../../utils/index.js";
+export async function getDownloadFile(params) {
+    const { path, mode = "download" } = params;
+    const api = this.getApiInfoByName(FileStationApi.Download);
+    const query = {
+        method: "download",
+        path,
+        mode,
+        version: api.maxVersion,
+        api: FileStationApi.Download,
+        _sid: this.authInfo.sid,
+    };
+    const url = buildUrlWithQuery(`${this.baseUrl}${api.path}`, query);
+    return {
+        data: url,
+        success: true,
+    };
+}

package/lib/modules/FileStation/Extract.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/modules/FileStation/Extract.js

@@ -0,0 +1 @@
+export {};

package/lib/modules/FileStation/Favorite.d.ts

@@ -0,0 +1,45 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type FavoriteListParams = {
+    limit?: number;
+    offset?: number;
+    sort_by?: string;
+    sort_direction?: "ASC" | "DESC";
+    additional?: string[];
+    status_filter: "all" | "valid" | "broken";
+};
+export type FavoriteListResponse = SynologyApiResponse<{
+    is_manager: boolean;
+    support_virtual_protocol: number;
+    support_sharing: boolean;
+    hostname: string;
+}>;
+export declare function getFavoriteList(params: FavoriteListParams): Promise<FavoriteListResponse>;
+export type AddFavoriteParams = {
+    path: string;
+    name: string;
+    index: number;
+};
+/**
+ * add favorite
+ */
+export declare function addFavorite(params: FavoriteListParams): Promise<SynologyApiResponse<any>>;
+export type RemoveFavoriteParams = {
+    path: string;
+};
+/**
+ * remove favorite
+ */
+export declare function deleteFavorite(params: RemoveFavoriteParams): Promise<SynologyApiResponse<any>>;
+/**
+ * clear_broken
+ * Delete all broken statuses of favorites.
+ */
+export declare function clearBrokenFavorite(): Promise<SynologyApiResponse<any>>;
+export type EditFavoriteParams = {
+    path: string;
+    name: string;
+};
+/**
+ * Edit a favorite name
+*/
+export declare function editFavorite(params: EditFavoriteParams): Promise<SynologyApiResponse<any>>;

package/lib/modules/FileStation/Favorite.js

@@ -0,0 +1,60 @@
+import { FileStationApi } from "../../types/index.js";
+export async function getFavoriteList(params) {
+    const { additional = ["real_path", "size", "owner", "time"], ...resetParams } = params;
+    const res = await this.run(FileStationApi.Favorite, {
+        params: {
+            method: "list",
+            ...resetParams,
+            additional: JSON.stringify(additional),
+        },
+    });
+    return res;
+}
+/**
+ * add favorite
+ */
+export async function addFavorite(params) {
+    const res = await this.run(FileStationApi.Favorite, {
+        params: {
+            method: "add",
+            ...params,
+        },
+    });
+    return res;
+}
+/**
+ * remove favorite
+ */
+export async function deleteFavorite(params) {
+    const res = await this.run(FileStationApi.Favorite, {
+        params: {
+            method: "delete",
+            ...params,
+        },
+    });
+    return res;
+}
+/**
+ * clear_broken
+ * Delete all broken statuses of favorites.
+ */
+export async function clearBrokenFavorite() {
+    const res = await this.run(FileStationApi.Favorite, {
+        params: {
+            method: "clear_broken",
+        },
+    });
+    return res;
+}
+/**
+ * Edit a favorite name
+*/
+export async function editFavorite(params) {
+    const res = await this.run(FileStationApi.Favorite, {
+        params: {
+            method: "edit",
+            ...params
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/List.d.ts

@@ -2,17 +2,17 @@ import { SynologyApiResponse } from "../../types/index.js";
 /**
  * fetch filestation list
  */
-export type FileStationFileListRequest = {
+export type FileListRequest = {
     limit?: number;
     offset?: number;
     sort_by?: string;
     sort_direction?: "ASC" | "DESC";
-    version?: number;
     filetype?: "file" | "dir" | "all";
     folder_path?: string;
-    additional?: string[];
+    additional?: Array<"real_path" | "size" | "owner" | "time" | "perm" | "type" | "mount_point_type">;
+    pattern?: string;
 };
-export type FileStationFileListItem = {
+export type FileListItem = {
     isdir: boolean;
     name: string;
     path: string;
@@ -31,16 +31,16 @@ export type FileStationFileListItem = {
         description: Record<string, any>;
     };
 };
-export type FileStationFileListResponse = SynologyApiResponse<{
-    files: FileStationFileListItem[];
+export type FileListResponse = SynologyApiResponse<{
+    files: FileListItem[];
     offset: number;
     total: number;
 }>;
-export declare function getFileList(params?: FileStationFileListRequest): Promise<FileStationFileListResponse>;
+export declare function getFileList(params?: FileListRequest): Promise<FileListResponse>;
 /**
  * fetch file share list
  * */
-export type FileStationFileShareListRequest = {
+export type FileShareListRequest = {
     limit?: number;
     offset?: number;
     sort_by?: string;
@@ -48,12 +48,40 @@ export type FileStationFileShareListRequest = {
     additional?: string[];
     onlywritable?: boolean;
 };
-export type FileStationFileShareListResponse = SynologyApiResponse<{
-    shares: FileStationFileListItem & {
+export type FileShareListResponse = SynologyApiResponse<{
+    shares: FileListItem & {
         hybridshare_cache_status: number;
         hybridshare_pin_status: number;
     }[];
     offset: number;
     total: number;
 }>;
-export declare function getFileListShare(params?: FileStationFileShareListRequest): Promise<FileStationFileShareListResponse>;
+export declare function getShareFileList(params?: FileShareListRequest): Promise<FileShareListResponse>;
+/**
+ * fetch file share list
+ * */
+export type VirtualFolderListRequest = {
+    type?: "Nfs" | "cifs" | "iso";
+    limit?: number;
+    offset?: number;
+    sort_by?: string;
+    sort_direction?: "ASC" | "DESC";
+    additional?: Array<"real_path" | "owner" | "time" | "perm" | "mount_point_type" | "volume_status">;
+};
+export type VirtualFolderListResponse = SynologyApiResponse<{
+    folders: Array<{
+        path: string;
+        name: string;
+        additional?: {
+            real_path?: string;
+            owner?: Record<string, any>;
+            time?: Record<string, any>;
+            perm?: Record<string, any>;
+            mount_point_type?: string;
+            volume_status?: Record<string, any>;
+        };
+    }>;
+    offset: number;
+    total: number;
+}>;
+export declare function getVirtualFolderList(params?: VirtualFolderListRequest): Promise<VirtualFolderListResponse>;

package/lib/modules/FileStation/List.js

@@ -1,5 +1,5 @@
 import { FileStationApi } from "../../types/index.js";
-import { isUndfined } from "../../utils.js";
+import { isUndfined } from "../../utils/index.js";
 export async function getFileList(params = {}) {
     const { additional = ["real_path", "size", "owner", "time"], filetype = "all" } = params;
     if (isUndfined(params.folder_path)) {
@@ -8,22 +8,30 @@ export async function getFileList(params = {}) {
     const res = await this.run(FileStationApi.List, {
         params: {
             method: "list",
-            additional: JSON.stringify(additional),
-            filetype: filetype,
-            folder_path: params.folder_path,
             ...params,
+            additional: JSON.stringify(additional),
         },
     });
     return res;
 }
-export async function getFileListShare(params = {}) {
+export async function getShareFileList(params = {}) {
     const { additional = ["real_path", "size", "owner", "time"], onlywritable = false } = params;
     const res = await this.run(FileStationApi.List, {
         params: {
             method: "list_share",
+            ...params,
             additional: JSON.stringify(additional),
-            onlywritable: onlywritable,
+        },
+    });
+    return res;
+}
+export async function getVirtualFolderList(params = {}) {
+    const { additional = [] } = params;
+    const res = await this.run(FileStationApi.VirtualFolder, {
+        params: {
+            method: "list",
             ...params,
+            additional: JSON.stringify(additional),
         },
     });
     return res;

package/lib/modules/FileStation/MD5.d.ts

@@ -0,0 +1,15 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export declare function startMD5Calc(params: {
+    file_path: string;
+}): Promise<SynologyApiResponse<{
+    taskid: string;
+}>>;
+export declare function stopMD5Calc(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<any>>;
+export declare function getMD5CalcStatus(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<{
+    finished: boolean;
+    md5: string;
+}>>;

package/lib/modules/FileStation/MD5.js

@@ -0,0 +1,29 @@
+import { FileStationApi } from "../../types/index.js";
+export async function startMD5Calc(params) {
+    const res = await this.run(FileStationApi.MD5, {
+        params: {
+            method: "start",
+            file_path: params.file_path,
+        },
+    });
+    return res;
+}
+export async function stopMD5Calc(params) {
+    const { taskid } = params;
+    const res = await this.run(FileStationApi.MD5, {
+        params: {
+            method: "stop",
+            taskid,
+        },
+    });
+    return res;
+}
+export async function getMD5CalcStatus(params) {
+    const res = await this.run(FileStationApi.MD5, {
+        params: {
+            method: "status",
+            taskid: params.taskid,
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/Rename.d.ts

@@ -0,0 +1,38 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type RenameParams = {
+    path: string;
+    name: string;
+    additional?: Array<"real_path" | "size" | "owner" | "time" | "perm" | "type">;
+    /**
+     * Optional. A unique ID for the search
+     * task which is obtained from start
+     * method. It is used to update the
+     * renamed file in the search result.
+     */
+    search_taskid?: string;
+};
+export type RenameResponse = SynologyApiResponse<{
+    files: Array<{
+        isdir: boolean;
+        name: string;
+        path: string;
+        additional?: {
+            type: string;
+            size: number;
+            time: {
+                atime: number;
+                mtime: number;
+                ctime: number;
+                btime: number;
+            };
+            real_path: string;
+            mount_point_type: string;
+            indexed: boolean;
+            description: Record<string, any>;
+        };
+    }>;
+}>;
+/**
+ * Rename a file/folder.
+ */
+export declare function rename(params: RenameParams): Promise<RenameResponse>;

package/lib/modules/FileStation/Rename.js

@@ -0,0 +1,14 @@
+import { FileStationApi } from "../../types/index.js";
+/**
+ * Rename a file/folder.
+ */
+export async function rename(params) {
+    const res = await this.run(FileStationApi.Rename, {
+        params: {
+            method: "rename",
+            ...params,
+            additional: JSON.stringify(params.additional ?? []),
+        },
+    });
+    return res;
+}

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

@@ -0,0 +1,40 @@
+import { SynologyApiResponse } from "../../types/index.js";
+import { FileListItem } from "./List.js";
+export type StartSearchParams = {
+    folder_path?: string;
+    filetype?: "file" | "dir" | "all";
+    recursive?: boolean;
+    pattern?: string;
+};
+export type StartSearchResponse = SynologyApiResponse<{
+    has_not_index_share: boolean;
+    taskid: string;
+}>;
+export declare function startSearch(params: StartSearchParams): Promise<StartSearchResponse>;
+export declare function stopSearch(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<any>>;
+export type SearchListParams = {
+    taskid: string;
+    filetype?: "file" | "dir" | "all";
+    limit?: number;
+    offset?: number;
+    additional?: string[];
+    sort_by?: "name" | "size" | "user" | "group" | "mtime" | "atime" | "ctime" | "crtime" | "posix" | "type";
+    sort_direction?: "ASC" | "DESC";
+};
+export type SearchListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    finished: boolean;
+    files: Array<FileListItem>;
+}>;
+export declare function getSearchList(params: SearchListParams): Promise<SearchListResponse>;
+/**
+ * Delete search temporary database(s).
+ * @param taskid - Unique ID(s) for the search task which are
+obtained from start method.
+*/
+export declare function cleanSearch(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<any>>;

package/lib/modules/FileStation/Search.js

@@ -0,0 +1,49 @@
+import { FileStationApi } from "../../types/index.js";
+export async function startSearch(params) {
+    const { recursive = true } = params;
+    return await this.run(FileStationApi.Search, {
+        params: {
+            method: "start",
+            recursive: recursive,
+            ...params,
+        },
+    });
+}
+export async function stopSearch(params) {
+    return await this.run(FileStationApi.Search, {
+        params: {
+            method: "stop",
+            ...params,
+        },
+    });
+}
+export async function getSearchList(params) {
+    const { taskid, filetype, limit = 1000, offset = 0, sort_by = "name", additional = ["real_path", "size", "owner", "time", "perm", "type"], sort_direction = "ASC", ...resetParams } = params;
+    const res = await this.run(FileStationApi.Search, {
+        params: {
+            method: "list",
+            taskid,
+            filetype,
+            limit,
+            offset,
+            sort_by,
+            sort_direction,
+            additional: JSON.stringify(additional),
+            ...resetParams,
+        },
+    });
+    return res;
+}
+/**
+ * Delete search temporary database(s).
+ * @param taskid - Unique ID(s) for the search task which are
+obtained from start method.
+*/
+export async function cleanSearch(params) {
+    return await this.run(FileStationApi.Search, {
+        params: {
+            method: "clean",
+            ...params,
+        },
+    });
+}

package/lib/modules/FileStation/Sharing.d.ts

@@ -0,0 +1,69 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type SharingLink = {
+    id: string;
+    date_available?: string;
+    date_expired?: string;
+    has_password?: boolean;
+    isFolder?: boolean;
+    link_owner?: string;
+    name?: string;
+    path?: string;
+    url?: string;
+    qrcode?: string;
+};
+/**
+ *  Get information of a sharing link by the sharing link ID.
+ */
+export declare function getSharingInfo(params: {
+    id: string;
+}): Promise<SynologyApiResponse<SharingLink>>;
+/**
+ * Get Sharing List
+ * */
+export type GetSharingListParams = {
+    limit?: number;
+    offset?: number;
+    sort_by?: string;
+    sort_direction?: "ASC" | "DESC";
+    force_clean?: boolean;
+};
+export type GetSharingListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    links: Array<SharingLink>;
+}>;
+export declare function getSharingList(params?: GetSharingListParams): Promise<GetSharingListResponse>;
+/**
+ * Generate one or more sharing link(s) by file/folder path(s)
+ */
+export type CreateSharingLinkParams = {
+    path: string | string[];
+    password?: string;
+    date_expired?: string;
+    date_available?: string;
+};
+export type CreateSharingLinkResponse = SynologyApiResponse<{
+    links: Array<SharingLink>;
+}>;
+export declare function createSharingLink(params: CreateSharingLinkParams): Promise<CreateSharingLinkResponse>;
+/**
+ * Delete one or more sharing links.
+ */
+export type DeleteSharingLinkParams = {
+    id: string | string[];
+};
+export declare function deleteSharingLink(params: DeleteSharingLinkParams): Promise<SynologyApiResponse<any>>;
+/**
+ * Remove all expired and broken sharing links.
+ */
+export declare function clearInvalidSharingLink(): Promise<SynologyApiResponse<any>>;
+/**
+ * Edit sharing link(s)
+ * */
+export type EditSharingLinkParams = {
+    id: string | string[];
+    password?: string;
+    date_expired?: string;
+    date_available?: string;
+};
+export declare function editSharingLink(params: EditSharingLinkParams): Promise<SynologyApiResponse<any>>;

package/lib/modules/FileStation/Sharing.js

@@ -0,0 +1,64 @@
+import { FileStationApi } from "../../types/index.js";
+/**
+ *  Get information of a sharing link by the sharing link ID.
+ */
+export async function getSharingInfo(params) {
+    return await this.run(FileStationApi.Sharing, {
+        params: {
+            method: "getinfo",
+            ...params,
+        },
+    });
+}
+export async function getSharingList(params = {}) {
+    const res = await this.run(FileStationApi.Sharing, {
+        params: {
+            method: "list",
+            ...params,
+        },
+    });
+    return res;
+}
+export async function createSharingLink(params) {
+    const { path, ...resetParams } = params;
+    const res = await this.run(FileStationApi.Sharing, {
+        params: {
+            method: "create",
+            path: Array.isArray(path) ? path.join(",") : path,
+            ...resetParams,
+        },
+    });
+    return res;
+}
+export async function deleteSharingLink(params) {
+    const { id } = params;
+    const res = await this.run(FileStationApi.Sharing, {
+        params: {
+            method: "delete",
+            id: Array.isArray(id) ? id.join(",") : id,
+        },
+    });
+    return res;
+}
+/**
+ * Remove all expired and broken sharing links.
+ */
+export async function clearInvalidSharingLink() {
+    const res = await this.run(FileStationApi.Sharing, {
+        params: {
+            method: "clear_invalid",
+        },
+    });
+    return res;
+}
+export async function editSharingLink(params) {
+    const { id, ...resetParams } = params;
+    const res = await this.run(FileStationApi.Sharing, {
+        params: {
+            method: "edit",
+            id: Array.isArray(id) ? id.join(",") : id,
+            ...resetParams,
+        },
+    });
+    return res;
+}