@fett/synology-api 0.0.1-beta.2 → 0.0.1-beta.4

package/README.md

@@ -1,4 +1,4 @@
-# synology-api
+# Synology Api
 
 nodejs synology api wrapper
 
@@ -14,9 +14,13 @@ const synologyApi = new SynologyApi(
     password: "password",
 );
 
-// Connect to the server
-await synologyApi.connect();
+// you can now use the api by calling the methods
+const info = await synologyApi.FileStation.getInfo();
 
 ```
 
 ## API
+
+### FileStation
+
+### AudioStation

package/dist/cjs/index.js

@@ -1,19 +1,551 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("./core");
-__exportStar(require("./core"), exports);
-exports.default = core_1.SynologyApi;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AudioStationApi: () => AudioStationApi,
+  FileStationApi: () => FileStationApi,
+  SynologyApi: () => SynologyApi,
+  SynologyApiInfo: () => SynologyApiInfo,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var import_axios4 = __toESM(require("axios"));
+
+// src/types/apiInfo.ts
+var SynologyApiInfo = /* @__PURE__ */ ((SynologyApiInfo2) => {
+  SynologyApiInfo2["Auth"] = "SYNO.API.Auth";
+  SynologyApiInfo2["Info"] = "SYNO.API.Info";
+  SynologyApiInfo2["OTP"] = "SYNO.API.OTP";
+  return SynologyApiInfo2;
+})(SynologyApiInfo || {});
+var AudioStationApi = /* @__PURE__ */ ((AudioStationApi2) => {
+  AudioStationApi2["Song"] = "SYNO.AudioStation.Song";
+  AudioStationApi2["Album"] = "SYNO.AudioStation.Album";
+  AudioStationApi2["Artist"] = "SYNO.AudioStation.Artist";
+  AudioStationApi2["Genre"] = "SYNO.AudioStation.Genre";
+  AudioStationApi2["Playlist"] = "SYNO.AudioStation.Playlist";
+  AudioStationApi2["Folder"] = "SYNO.AudioStation.Folder";
+  AudioStationApi2["Cover"] = "SYNO.AudioStation.Cover";
+  AudioStationApi2["Download"] = "SYNO.AudioStation.Download";
+  AudioStationApi2["Info"] = "SYNO.AudioStation.Info";
+  AudioStationApi2["Lyrics"] = "SYNO.AudioStation.Lyrics";
+  AudioStationApi2["LyricsSearch"] = "SYNO.AudioStation.LyricsSearch";
+  AudioStationApi2["Radio"] = "SYNO.AudioStation.Radio";
+  AudioStationApi2["Stream"] = "SYNO.AudioStation.Stream";
+  AudioStationApi2["Tag"] = "SYNO.AudioStation.Tag";
+  return AudioStationApi2;
+})(AudioStationApi || {});
+var FileStationApi = /* @__PURE__ */ ((FileStationApi2) => {
+  FileStationApi2["File"] = "SYNO.FileStation.File";
+  FileStationApi2["Info"] = "SYNO.FileStation.Info";
+  FileStationApi2["List"] = "SYNO.FileStation.List";
+  FileStationApi2["Quota"] = "SYNO.FileStation.Quota";
+  FileStationApi2["Share"] = "SYNO.FileStation.Share";
+  FileStationApi2["Thumb"] = "SYNO.FileStation.Thumb";
+  FileStationApi2["Upload"] = "SYNO.FileStation.Upload";
+  return FileStationApi2;
+})(FileStationApi || {});
+
+// src/modules/AudioStation/Song.ts
+function getSongList(params) {
+  return __async(this, null, function* () {
+    const res = yield this.run("SYNO.AudioStation.Song" /* Song */, {
+      params: __spreadValues({
+        method: "list",
+        library: "all"
+      }, params)
+    });
+    return res.data;
+  });
+}
+
+// src/modules/AudioStation/index.ts
+var AudioStationMethods = {
+  getSongList
+};
+var AudioStationKey = "AudioStation";
+
+// src/modules/FileStation/Info.ts
+function getInfo() {
+  return __async(this, null, function* () {
+    const res = yield this.run("SYNO.FileStation.Info" /* Info */, {
+      params: {
+        method: "get"
+      }
+    });
+    return res.data;
+  });
+}
+
+// src/utils.ts
+function isHttpUrl(url) {
+  return /^https?:\/\//.test(url);
+}
+function isUndfined(value) {
+  return value === void 0;
+}
+function getApiKey(apiName) {
+  return apiName.split(".")[1];
+}
+
+// src/modules/FileStation/List.ts
+function getFileList() {
+  return __async(this, arguments, function* (params = {}) {
+    const { additional = ["real_path", "size", "owner", "time"], filetype = "all" } = params;
+    if (isUndfined(params.folder_path)) {
+      throw new Error("folder_path is required");
+    }
+    const res = yield this.run("SYNO.FileStation.List" /* List */, {
+      params: __spreadValues({
+        method: "list",
+        additional: JSON.stringify(additional),
+        filetype,
+        folder_path: params.folder_path
+      }, params)
+    });
+    return res.data;
+  });
+}
+function getFileListShare() {
+  return __async(this, arguments, function* (params = {}) {
+    const { additional = ["real_path", "size", "owner", "time"], onlywritable = false } = params;
+    const res = yield this.run("SYNO.FileStation.List" /* List */, {
+      params: __spreadValues({
+        method: "list_share",
+        additional: JSON.stringify(additional),
+        onlywritable
+      }, params)
+    });
+    return res.data;
+  });
+}
+
+// src/modules/FileStation/index.ts
+var FileStationMethods = {
+  getInfo,
+  getFileList,
+  getFileListShare
+};
+var FileStationKey = "FileStation";
+
+// src/modules/index.ts
+AudioStationKey, FileStationKey;
+var BaseSynologyApi = class {
+  constructor() {
+  }
+};
+function methodsBundler(instance, methods) {
+  const output = {};
+  for (const key in methods) {
+    output[key] = methods[key].bind(instance);
+  }
+  return output;
+}
+Object.defineProperties(BaseSynologyApi.prototype, {
+  [FileStationKey]: {
+    get() {
+      return methodsBundler(this, FileStationMethods);
+    }
+  },
+  [AudioStationKey]: {
+    get() {
+      return methodsBundler(this, AudioStationMethods);
+    }
+  }
+});
+
+// src/helpers.ts
+var import_axios = __toESM(require("axios"));
+
+// src/constants.ts
+var GLOBAL_QUICK_CONNECT_URL = "https://global.quickconnect.cn/Serv.php";
+var QUICK_CONNECT_PINGPANG_API = "/webman/pingpong.cgi?action=cors&quickconnect=true";
+
+// src/helpers.ts
+var getServersFromServerInfo = (serverInfo) => __async(null, null, function* () {
+  var _a, _b;
+  if (serverInfo.service.relay_ip) {
+    const server = `http://${serverInfo.service.relay_ip}:${serverInfo.service.relay_port}`;
+    const res = yield pingpang(server);
+    if (res) {
+      return server;
+    }
+  }
+  if (serverInfo.server.external.ip) {
+    const server = `http://${serverInfo.server.external.ip}:${serverInfo.service.port}`;
+    if (yield pingpang(server)) {
+      return server;
+    }
+  }
+  if ((_a = serverInfo.server.interface) == null ? void 0 : _a[0]) {
+    const server = `http://${(_b = serverInfo.server.interface) == null ? void 0 : _b[0].ip}:${serverInfo.service.port}`;
+    if (yield pingpang(server)) {
+      return server;
+    }
+  }
+});
+var getServerInfo = (quickConnectId) => __async(null, null, function* () {
+  var _a, _b, _c, _d;
+  const params = {
+    version: 1,
+    id: "dsm",
+    serverID: quickConnectId,
+    get_ca_fingerprints: true,
+    command: "get_server_info"
+  };
+  const serverInfo = yield import_axios.default.post(GLOBAL_QUICK_CONNECT_URL, params);
+  if (!((_b = (_a = serverInfo.data) == null ? void 0 : _a.service) == null ? void 0 : _b.relay_ip) && !((_d = (_c = serverInfo.data) == null ? void 0 : _c.service) == null ? void 0 : _d.relay_port)) {
+    const relayRequestParams = {
+      version: 1,
+      id: "dsm",
+      serverID: quickConnectId,
+      platform: "web",
+      command: "request_tunnel"
+    };
+    const result = yield import_axios.default.post(
+      `https://${serverInfo.data.env.control_host}/Serv.php`,
+      relayRequestParams
+    );
+    return getServersFromServerInfo(result.data);
+  } else {
+    return getServersFromServerInfo(serverInfo.data);
+  }
+});
+var pingpang = (server) => __async(null, null, function* () {
+  try {
+    const result = yield import_axios.default.get(`${server}/${QUICK_CONNECT_PINGPANG_API}`, {
+      timeout: 3e3
+    });
+    if (result.data.success) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (_err) {
+    return false;
+  }
+});
+
+// src/modules/Api/Auth.ts
+var import_axios2 = __toESM(require("axios"));
+function login(core) {
+  return __async(this, null, function* () {
+    const params = {
+      api: "SYNO.API.Auth" /* Auth */,
+      version: 6,
+      method: "login",
+      account: core.username,
+      passwd: core.password,
+      format: "sid"
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = yield import_axios2.default.get(url, { params });
+    if (!result.data.success) {
+      throw new Error(result.data.error.message);
+    }
+    return result.data;
+  });
+}
+function logout(core) {
+  return __async(this, null, function* () {
+    const params = {
+      api: "SYNO.API.Auth" /* Auth */,
+      version: 6,
+      method: "logout"
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = yield import_axios2.default.get(url, { params });
+    if (!result.data.success) {
+      throw new Error(result.data.error.message);
+    }
+  });
+}
+
+// src/modules/Api/Info.ts
+var import_axios3 = __toESM(require("axios"));
+function getApiInfo(core) {
+  return __async(this, null, function* () {
+    const params = {
+      api: "SYNO.API.Info" /* Info */,
+      version: 1,
+      method: "query"
+    };
+    const url = `${core.baseUrl}entry.cgi`;
+    const result = yield import_axios3.default.get(url, { params });
+    if (!result.data.success) {
+      throw new Error(result.data.error.message);
+    }
+    return result.data;
+  });
+}
+
+// src/errorcodes.ts
+var CODE_SUCCESS = 0;
+var CODE_UNKNOWN = 9999;
+var SYNOLOGY_ERROR_CODES = {
+  [FileStationKey]: {
+    400: "Invalid parameter of file operation",
+    401: "Unknown error of file operation",
+    402: "System is too busy",
+    403: "Invalid user does this file operation",
+    404: "Invalid group does this file operation",
+    405: "Invalid user and group does this file operation",
+    406: "Can't get user/group information from the account server",
+    407: "Operation not permitted",
+    408: "No such file or directory",
+    409: "Non-supported file system",
+    410: "Failed to connect internet-based file system (e.g., CIFS)",
+    411: "Read-only file system",
+    412: "Filename too long in the non-encrypted file system",
+    413: "Filename too long in the encrypted file system",
+    414: "File already exists",
+    415: "Disk quota exceeded",
+    416: "No space left on device",
+    417: "Input/output error",
+    418: "Illegal name or path",
+    419: "Illegal file name",
+    420: "Illegal file name on FAT file system",
+    421: "Device or resource busy",
+    599: "No such task of the file operation"
+  },
+  [AudioStationKey]: {},
+  COMMON_CODES: {
+    [CODE_SUCCESS]: "Success",
+    100: "Unknown error",
+    101: "No parameter of API, method or version",
+    102: "The requested API does not exist",
+    103: "The requested method does not exist",
+    104: "The requested version does not support the functionality",
+    105: "The logged in session does not have permission",
+    106: "Session timeout",
+    107: "Session interrupted by duplicated login",
+    108: "Failed to upload the file",
+    109: "The network connection is unstable or the system is busy",
+    110: "The network connection is unstable or the system is busy",
+    111: "The network connection is unstable or the system is busy",
+    112: "Preserve for other purpose",
+    113: "Preserve for other purpose",
+    114: "Lost parameters for this API",
+    115: "Not allowed to upload a file",
+    116: "Not allowed to perform for a demo site",
+    117: "The network connection is unstable or the system is busy",
+    118: "The network connection is unstable or the system is busy",
+    119: "Invalid session / SID not found.",
+    // # 120-149 Preserve for other purpose
+    120: "Preserve for other purpose",
+    121: "Preserve for other purpose",
+    122: "Preserve for other purpose",
+    123: "Preserve for other purpose",
+    124: "Preserve for other purpose",
+    125: "Preserve for other purpose",
+    126: "Preserve for other purpose",
+    127: "Preserve for other purpose",
+    128: "Preserve for other purpose",
+    129: "Preserve for other purpose",
+    130: "Preserve for other purpose",
+    131: "Preserve for other purpose",
+    132: "Preserve for other purpose",
+    133: "Preserve for other purpose",
+    134: "Preserve for other purpose",
+    135: "Preserve for other purpose",
+    136: "Preserve for other purpose",
+    137: "Preserve for other purpose",
+    138: "Preserve for other purpose",
+    139: "Preserve for other purpose",
+    140: "Preserve for other purpose",
+    141: "Preserve for other purpose",
+    142: "Preserve for other purpose",
+    143: "Preserve for other purpose",
+    144: "Preserve for other purpose",
+    145: "Preserve for other purpose",
+    146: "Preserve for other purpose",
+    147: "Preserve for other purpose",
+    148: "Preserve for other purpose",
+    149: "Preserve for other purpose",
+    150: "Request source IP does not match the login IP",
+    160: "Insufficient application privilege",
+    [CODE_UNKNOWN]: "Unknown error"
+  }
+};
+var resWithErrorCode = (apiKey, res) => {
+  var _a, _b;
+  const errorCodes = SYNOLOGY_ERROR_CODES[apiKey];
+  const code = (_a = res == null ? void 0 : res.error) == null ? void 0 : _a.code;
+  if (isUndfined(code)) return res;
+  return __spreadProps(__spreadValues({}, res), {
+    error: __spreadProps(__spreadValues({}, res.error), {
+      message: ((_b = res == null ? void 0 : res.error) == null ? void 0 : _b.message) || (errorCodes == null ? void 0 : errorCodes[code]) || "Unknown error"
+    })
+  });
+};
+
+// src/core.ts
+var SynologyApi = class extends BaseSynologyApi {
+  constructor(options) {
+    super();
+    this.isConnecting = false;
+    this.authInfo = null;
+    this.apiInfo = {};
+    this.server = options.server;
+    this.username = options.username;
+    this.password = options.password;
+    this.baseUrl = `${this.server}/webapi/`;
+  }
+  connect() {
+    return __async(this, null, function* () {
+      if (!isHttpUrl(this.server)) {
+        this.server = yield getServerInfo(this.server);
+        this.baseUrl = `${this.server}/webapi/`;
+      }
+      try {
+        const result = yield login(this);
+        this.authInfo = result.data;
+        this.isConnecting = true;
+        yield this._getApiInfo();
+        return true;
+      } catch (err) {
+        console.error(err);
+        return false;
+      }
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      try {
+        yield logout(this);
+        this.authInfo = null;
+        this.apiInfo = {};
+        this.isConnecting = false;
+        return true;
+      } catch (err) {
+        console.error(err);
+        return false;
+      }
+    });
+  }
+  _getApiInfo() {
+    return __async(this, null, function* () {
+      try {
+        const result = yield getApiInfo(this);
+        this.apiInfo = result.data;
+      } catch (err) {
+        console.error(err);
+      }
+    });
+  }
+  hasApi(apiName) {
+    if (!this.isConnecting) {
+      throw new Error("Not connected");
+    }
+    return Object.prototype.hasOwnProperty.call(this.apiInfo, apiName);
+  }
+  run(apiName, options) {
+    return __async(this, null, function* () {
+      if (!this.isConnecting) {
+        const res = yield this.connect();
+        if (!res) {
+          throw new Error("Not connected");
+        }
+      }
+      if (!this.hasApi(apiName)) {
+        throw new Error(`${apiName} not found`);
+      }
+      const { method = "get", params, data, headers } = options;
+      const api = this.apiInfo[apiName];
+      const url = `${this.baseUrl}${api.path}`;
+      const externalParams = __spreadValues({
+        api: apiName,
+        version: api.maxVersion,
+        _sid: this.authInfo.sid
+      }, params);
+      let result = null;
+      if (method === "get") {
+        result = yield import_axios4.default.get(url, { params: externalParams, data, headers });
+      }
+      if (method === "post") {
+        result = yield import_axios4.default.post(url, { params: externalParams, data, headers });
+      }
+      const apiKey = getApiKey(apiName);
+      if (!isUndfined(apiKey)) {
+        result.data = resWithErrorCode(apiKey, result.data);
+      }
+      return result;
+    });
+  }
+};
+
+// src/index.ts
+var index_default = SynologyApi;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioStationApi,
+  FileStationApi,
+  SynologyApi,
+  SynologyApiInfo
+});

package/dist/esm/constants.js

@@ -1,4 +1,5 @@
-export const SYNOLOGY_API_AUTH = "SYNO.API.Auth";
-export const SYNOLOGY_API_INFO = "SYNO.API.Info";
+/**
+ * synology constants
+*/
 export const GLOBAL_QUICK_CONNECT_URL = "https://global.quickconnect.cn/Serv.php";
 export const QUICK_CONNECT_PINGPANG_API = "/webman/pingpong.cgi?action=cors&quickconnect=true";

package/dist/esm/core.js

@@ -10,9 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 // reference: https://kb.synology.com/zh-tw/DSM/tutorial/What_websites_does_Synology_NAS_connect_to_when_running_services_or_updating_software
 import axios from "axios";
 import { BaseSynologyApi } from "./modules";
-import { isHttpUrl } from "./utils";
+import { isHttpUrl, getApiKey, isUndfined } from "./utils";
 import { getServerInfo } from "./helpers";
 import { login, logout, getApiInfo } from "./modules/Api";
+import { resWithErrorCode } from "./errorcodes";
 export class SynologyApi extends BaseSynologyApi {
     constructor(options) {
         super();
@@ -80,7 +81,10 @@ export class SynologyApi extends BaseSynologyApi {
     run(apiName, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isConnecting) {
-                throw new Error("Not connected");
+                const res = yield this.connect();
+                if (!res) {
+                    throw new Error("Not connected");
+                }
             }
             if (!this.hasApi(apiName)) {
                 throw new Error(`${apiName} not found`);
@@ -96,6 +100,11 @@ export class SynologyApi extends BaseSynologyApi {
             if (method === "post") {
                 result = yield axios.post(url, { params: externalParams, data, headers });
             }
+            // match error code msg
+            const apiKey = getApiKey(apiName);
+            if (!isUndfined(apiKey)) {
+                result.data = resWithErrorCode(apiKey, result.data);
+            }
             return result;
         });
     }