@fett/synology-api 0.0.1-beta.0

package/README.md

@@ -0,0 +1,2 @@
+# synology-api
+nodejs synology api wrapper

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SYNOLOGY_API_AUTH = "SYNO.API.Auth";
+export declare const SYNOLOGY_API_INFO = "SYNO.API.Info";

package/dist/constants.js

@@ -0,0 +1,2 @@
+export const SYNOLOGY_API_AUTH = "SYNO.API.Auth";
+export const SYNOLOGY_API_INFO = "SYNO.API.Info";

package/dist/core.d.ts

@@ -0,0 +1,38 @@
+import { BaseSynologyApi } from "./modules";
+export interface SynologyApiOptions {
+    server: string;
+    username: string;
+    password: string;
+}
+export interface SynologyApiInfo {
+    maxVersion: number;
+    minVersion: number;
+    path: string;
+    requestFormat?: string;
+}
+export interface SynologyApiAuthInfo {
+    sid: string;
+    did: number;
+    is_portal_port: boolean;
+    synotoken: string;
+}
+export declare class SynologyApi extends BaseSynologyApi {
+    server: string;
+    username: string;
+    password: string;
+    baseUrl: string;
+    isConnecting: boolean;
+    private authInfo;
+    private apiInfo;
+    constructor(options: SynologyApiOptions);
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    _getApiInfo(): Promise<void>;
+    hasApi(apiName: string): any;
+    run(apiName: string, options: {
+        method?: "get" | "post";
+        params?: Record<string, any>;
+        data?: Record<string, any>;
+        headers?: Record<string, any>;
+    }): Promise<any>;
+}

package/dist/core.js

@@ -0,0 +1,123 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import axios from "axios";
+import { SYNOLOGY_API_AUTH, SYNOLOGY_API_INFO } from "./constants";
+import { BaseSynologyApi } from "./modules";
+export class SynologyApi 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 __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                api: SYNOLOGY_API_AUTH,
+                version: 6,
+                method: "login",
+                account: this.username,
+                passwd: this.password,
+                format: "sid",
+            };
+            try {
+                const url = `${this.baseUrl}entry.cgi`;
+                const result = yield axios.get(url, { params });
+                if (!result.data.success) {
+                    throw new Error(result.data.error.message);
+                }
+                this.authInfo = result.data.data;
+                this.isConnecting = true;
+                yield this._getApiInfo();
+                return true;
+            }
+            catch (err) {
+                console.error(err);
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                api: SYNOLOGY_API_AUTH,
+                version: 6,
+                method: "logout",
+            };
+            try {
+                const url = `${this.baseUrl}entry.cgi`;
+                const result = yield axios.get(url, { params });
+                if (!result.data.success) {
+                    throw new Error(result.data.error.message);
+                }
+                this.authInfo = null;
+                this.apiInfo = {};
+                this.isConnecting = false;
+                return true;
+            }
+            catch (err) {
+                console.error(err);
+                return false;
+            }
+        });
+    }
+    _getApiInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                api: SYNOLOGY_API_INFO,
+                version: 1,
+                method: "query",
+            };
+            try {
+                const url = `${this.baseUrl}entry.cgi`;
+                const result = yield axios.get(url, { params });
+                if (!result.data.success) {
+                    throw new Error(result.data.error.message);
+                }
+                this.apiInfo = result.data.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 __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnecting) {
+                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 = Object.assign({ api: apiName, version: api.maxVersion, _sid: this.authInfo.sid }, params);
+            let result = null;
+            if (method === "get") {
+                result = yield axios.get(url, { params: externalParams, data, headers });
+            }
+            if (method === "post") {
+                result = yield axios.post(url, { params: externalParams, data, headers });
+            }
+            return result;
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./core";
+export * from "./modules";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./core";
+export * from "./modules";

package/dist/modules/AudioStation.d.ts

@@ -0,0 +1,7 @@
+import { AudioStationSongListRequest, AudioStationSongListResponse } from "../types/AudioStation.Song";
+declare function getSongList(params: AudioStationSongListRequest): Promise<AudioStationSongListResponse>;
+export declare const AudioStationMethods: {
+    getSongList: typeof getSongList;
+};
+export declare const AudioStationProp = "AudioStation";
+export {};

package/dist/modules/AudioStation.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function getSongList(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield this.run("SYNO.AudioStation.Song", {
+            params: {
+                method: "list",
+                library: "all",
+                limit: params.limit,
+                offset: params.offset,
+            },
+        });
+        return res.data;
+    });
+}
+export const AudioStationMethods = {
+    getSongList,
+};
+export const AudioStationProp = "AudioStation";

package/dist/modules/index.d.ts

@@ -0,0 +1,5 @@
+import { AudioStationProp, AudioStationMethods } from "./AudioStation";
+export declare class BaseSynologyApi {
+    [AudioStationProp]: typeof AudioStationMethods;
+    constructor();
+}

package/dist/modules/index.js

@@ -0,0 +1,15 @@
+import { AudioStationProp, AudioStationMethods } from "./AudioStation";
+export class BaseSynologyApi {
+    constructor() { }
+}
+const instanceBindings = new WeakMap();
+Object.defineProperty(BaseSynologyApi.prototype, AudioStationProp, {
+    get() {
+        if (!instanceBindings.has(this)) {
+            instanceBindings.set(this, {
+                getSongList: AudioStationMethods.getSongList.bind(this),
+            });
+        }
+        return instanceBindings.get(this);
+    },
+});

package/dist/types/API.js

@@ -0,0 +1 @@
+// export type 

package/dist/types/AudioStation.Song.d.ts

@@ -0,0 +1,17 @@
+export type AudioStationSongListRequest = {
+    limit?: number;
+    offset?: number;
+    method?: number;
+    library?: number;
+    additional?: string;
+    version?: number;
+    sort_by?: string;
+    sort_direction?: string;
+};
+export type AudioStationSongListResponse = {
+    offset: number;
+    total: number;
+    songs: {
+        [key: string]: any;
+    };
+};

package/dist/types/AudioStation.Song.js

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

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isEmpty(obj: Record<string, any>): boolean;
+export declare function queryObjToString(params: Record<string, any>): string;

package/dist/utils.js

@@ -0,0 +1,11 @@
+export function isEmpty(obj) {
+    return Object.keys(obj).length === 0;
+}
+export function queryObjToString(params) {
+    if (isEmpty(params)) {
+        return "";
+    }
+    return Object.keys(params)
+        .map((key) => encodeURIComponent(key) + "=" + encodeURIComponent(params[key]))
+        .join("&");
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@fett/synology-api",
+  "version": "0.0.1-beta.0",
+  "description": "synology api for nodejs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "author": "ChrisSong1994 <https://github.com/ChrisSong1994>",
+  "keywords": [
+    "synology",
+    "api",
+    "nodejs",
+    "typescript",
+    "esmodule"
+  ],
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsc --sourceMap --watch",
+    "build": "npm run clean && tsc",
+    "lint": "eslint src --ext .ts --fix",
+    "prettier": "prettier --write 'src/**/*.ts'",
+    "format": "npm run prettier && npm run lint",
+    "prepublish": "npm run build",
+    "pub": "npm publish --access=public",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "clean": "rimraf dist"
+  },
+  "license": "ISC",
+  "packageManager": "pnpm@10.8.1",
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "eslint": "9.25.1",
+    "globals": "^16.1.0",
+    "prettier": "3.5.3",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.32.0",
+    "vite": "^6.3.5",
+    "vitest": "^3.1.3"
+  },
+  "dependencies": {
+    "axios": "^1.9.0"
+  }
+}