@jellyfin/sdk 0.0.0-unstable.202212091849

package/lib/discovery/discovery-service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+import { Jellyfin, RecommendedServerInfo, RecommendedServerInfoScore } from '..';
+/** Class used for discovering recommended servers. */
+export declare class DiscoveryService {
+    private jellyfin;
+    private recommendedServerDiscovery;
+    constructor(jellyfin: Jellyfin);
+    /**
+     * Finds the best server from a list of recommended servers by score.
+     * @param servers A list of recommended servers.
+     * @returns The best scoring recommended server.
+     */
+    findBestServer(servers: Array<RecommendedServerInfo>): RecommendedServerInfo | undefined;
+    /**
+     * Gets a list of address candidates url strings
+     * from a provided url address string.
+     * @param input A server url address string.
+     * @returns A list of potential server addresses.
+     */
+    getAddressCandidates(input: string): Array<string>;
+    /**
+     * Gets a list of recommended server information from a provided
+     * list of possible server addresses.
+     * @param servers A list of possible server addresses.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the possible server addresses.
+     */
+    getRecommendedServers(servers: Array<string>, minimumScore?: RecommendedServerInfoScore): Promise<Array<RecommendedServerInfo>>;
+    /**
+     * Gets a list of recommended server information from the address
+     * candidates of a potential server address.
+     * @param input A potential server address.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the address candidates.
+     */
+    getRecommendedServerCandidates(input: string, minimumScore?: RecommendedServerInfoScore): Promise<Array<RecommendedServerInfo>>;
+}

package/lib/discovery/discovery-service.js

@@ -0,0 +1,76 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+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 { RecommendedServerInfoScore } from '..';
+import { getAddressCandidates } from '../utils';
+import { RecommendedServerDiscovery } from './recommended-server-discovery';
+/** Class used for discovering recommended servers. */
+export class DiscoveryService {
+    constructor(jellyfin) {
+        this.jellyfin = jellyfin;
+        this.recommendedServerDiscovery = new RecommendedServerDiscovery(this.jellyfin);
+    }
+    /**
+     * Finds the best server from a list of recommended servers by score.
+     * @param servers A list of recommended servers.
+     * @returns The best scoring recommended server.
+     */
+    findBestServer(servers) {
+        // First look for GREAT scores
+        let best = servers.find(server => server.score === RecommendedServerInfoScore.GREAT);
+        // If no GREAT scores, look for GOOD scores
+        if (!best) {
+            best = servers.find(server => server.score === RecommendedServerInfoScore.GOOD);
+        }
+        // If no GREAT or GOOD scores, look for OK scores
+        if (!best) {
+            best = servers.find(server => server.score === RecommendedServerInfoScore.OK);
+        }
+        // Do NOT return any BAD scores
+        return best;
+    }
+    /**
+     * Gets a list of address candidates url strings
+     * from a provided url address string.
+     * @param input A server url address string.
+     * @returns A list of potential server addresses.
+     */
+    getAddressCandidates(input) {
+        return getAddressCandidates(input);
+    }
+    /**
+     * Gets a list of recommended server information from a provided
+     * list of possible server addresses.
+     * @param servers A list of possible server addresses.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the possible server addresses.
+     */
+    getRecommendedServers(servers, minimumScore) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.recommendedServerDiscovery.discover(servers, minimumScore);
+        });
+    }
+    /**
+     * Gets a list of recommended server information from the address
+     * candidates of a potential server address.
+     * @param input A potential server address.
+     * @param minimumScore The minimum server score to include in the results.
+     * @returns A list of RecommendedServerInfo from the address candidates.
+     */
+    getRecommendedServerCandidates(input, minimumScore) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRecommendedServers(this.getAddressCandidates(input), minimumScore);
+        });
+    }
+}

package/lib/discovery/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './discovery-service';
+export * from './recommended-server-discovery';

package/lib/discovery/index.js

@@ -0,0 +1,7 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './discovery-service';
+export * from './recommended-server-discovery';

package/lib/discovery/recommended-server-discovery.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+import { Jellyfin, RecommendedServerInfo, RecommendedServerInfoScore } from '..';
+/** Class to discover and evaluate potential servers. */
+export declare class RecommendedServerDiscovery {
+    private jellyfin;
+    constructor(jellyfin: Jellyfin);
+    /**
+     * Fetches the RecommendedServerInfo for a single server address.
+     * @param address The server address.
+     * @returns The resulting RecommendedServerInfo.
+     */
+    fetchRecommendedServerInfo(address: string): Promise<RecommendedServerInfo>;
+    /**
+     * Fetches the RecommendedServerInfo for multiple server addresses.
+     * @param servers An array of server addresses.
+     * @returns The RecommendedServerInfo for each address.
+     */
+    discover(servers: Array<string>, minimumScore?: RecommendedServerInfoScore): Promise<Array<RecommendedServerInfo>>;
+}

package/lib/discovery/recommended-server-discovery.js

@@ -0,0 +1,110 @@
+/**
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+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 { compare } from 'compare-versions';
+import { API_VERSION, MINIMUM_VERSION, ProductNameIssue, RecommendedServerInfoScore, SlowResponseIssue, SystemInfoIssue, VersionMissingIssue, VersionOutdatedIssue, VersionUnsupportedIssue } from '..';
+import { getSystemApi } from '../utils/api/system-api';
+/** The expected product name in system info. */
+const PRODUCT_NAME = 'Jellyfin Server';
+/** Requests taking longer than 3s are considered slow. */
+const SLOW_RESPONSE_TIME = 3000;
+/** System info request timeout. */
+const HTTP_TIMEOUT = 5000;
+/** Get the minimum RecommendedServerInfoScore from an array. */
+function getMinScore(scores, defaultScore = RecommendedServerInfoScore.GREAT) {
+    return scores.length > 0 ? Math.min(...scores) : defaultScore;
+}
+/** Builds a RecommendedServerInfo from a SystemInfoResult. */
+function toRecommendedServerInfo(result) {
+    var _a, _b, _c;
+    const issues = [];
+    const scores = [];
+    if (!((_a = result.response) === null || _a === void 0 ? void 0 : _a.data) || result.error) {
+        // The response did not return valid data or returned an error
+        issues.push(new SystemInfoIssue(result.error));
+        scores.push(RecommendedServerInfoScore.BAD);
+    }
+    else if (result.response.data.ProductName !== PRODUCT_NAME) {
+        // The product name returned was invalid
+        issues.push(new ProductNameIssue(result.response.data.ProductName));
+        scores.push(RecommendedServerInfoScore.BAD);
+    }
+    const version = (_b = result.response) === null || _b === void 0 ? void 0 : _b.data.Version;
+    if (!version) {
+        // No version was returned
+        issues.push(new VersionMissingIssue());
+        scores.push(RecommendedServerInfoScore.BAD);
+    }
+    else if (compare(version, MINIMUM_VERSION, '<')) {
+        // Version is less than the minimum supported
+        issues.push(new VersionUnsupportedIssue(version));
+        scores.push(RecommendedServerInfoScore.OK);
+    }
+    else if (compare(version, API_VERSION, '<')) {
+        // Version is less than the generated client, but above the minimum
+        issues.push(new VersionOutdatedIssue(version));
+        scores.push(RecommendedServerInfoScore.GOOD);
+    }
+    if (result.responseTime > SLOW_RESPONSE_TIME) {
+        // Response was slow
+        issues.push(new SlowResponseIssue(result.responseTime));
+        scores.push(RecommendedServerInfoScore.GOOD);
+    }
+    return {
+        address: result.address,
+        responseTime: result.responseTime,
+        score: getMinScore(scores),
+        issues,
+        systemInfo: (_c = result.response) === null || _c === void 0 ? void 0 : _c.data
+    };
+}
+/** Class to discover and evaluate potential servers. */
+export class RecommendedServerDiscovery {
+    constructor(jellyfin) {
+        this.jellyfin = jellyfin;
+    }
+    /**
+     * Fetches the RecommendedServerInfo for a single server address.
+     * @param address The server address.
+     * @returns The resulting RecommendedServerInfo.
+     */
+    fetchRecommendedServerInfo(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = this.jellyfin.createApi(address);
+            const startTime = Date.now();
+            return getSystemApi(api).getPublicSystemInfo({ timeout: HTTP_TIMEOUT })
+                .then(response => ({
+                address,
+                response,
+                responseTime: Date.now() - startTime
+            }))
+                .catch(error => ({
+                address,
+                error,
+                responseTime: Date.now() - startTime
+            }))
+                .then(result => toRecommendedServerInfo(result));
+        });
+    }
+    /**
+     * Fetches the RecommendedServerInfo for multiple server addresses.
+     * @param servers An array of server addresses.
+     * @returns The RecommendedServerInfo for each address.
+     */
+    discover(servers, minimumScore = RecommendedServerInfoScore.BAD) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(servers.map(server => this.fetchRecommendedServerInfo(server)))).filter(serverInfo => serverInfo.score >= minimumScore);
+        });
+    }
+}

package/lib/generated-client/api/activity-log-api.d.ts

@@ -0,0 +1,113 @@
+/**
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit the class manually.
+ *
+ * Jellyfin API
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+import { AxiosPromise, AxiosInstance, AxiosRequestConfig } from 'axios';
+import { Configuration } from '../configuration';
+import { RequestArgs, BaseAPI } from '../base';
+import { ActivityLogEntryQueryResult } from '../models';
+/**
+ * ActivityLogApi - axios parameter creator
+ * @export
+ */
+export declare const ActivityLogApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @param {number} [limit] Optional. The maximum number of records to return.
+     * @param {string} [minDate] Optional. The minimum date. Format = ISO.
+     * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLogEntries: (startIndex?: number, limit?: number, minDate?: string, hasUserId?: boolean, options?: AxiosRequestConfig) => Promise<RequestArgs>;
+};
+/**
+ * ActivityLogApi - functional programming interface
+ * @export
+ */
+export declare const ActivityLogApiFp: (configuration?: Configuration) => {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @param {number} [limit] Optional. The maximum number of records to return.
+     * @param {string} [minDate] Optional. The minimum date. Format &#x3D; ISO.
+     * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLogEntries(startIndex?: number, limit?: number, minDate?: string, hasUserId?: boolean, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActivityLogEntryQueryResult>>;
+};
+/**
+ * ActivityLogApi - factory interface
+ * @export
+ */
+export declare const ActivityLogApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @param {number} [limit] Optional. The maximum number of records to return.
+     * @param {string} [minDate] Optional. The minimum date. Format &#x3D; ISO.
+     * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getLogEntries(startIndex?: number, limit?: number, minDate?: string, hasUserId?: boolean, options?: any): AxiosPromise<ActivityLogEntryQueryResult>;
+};
+/**
+ * Request parameters for getLogEntries operation in ActivityLogApi.
+ * @export
+ * @interface ActivityLogApiGetLogEntriesRequest
+ */
+export interface ActivityLogApiGetLogEntriesRequest {
+    /**
+     * Optional. The record index to start at. All items with a lower index will be dropped from the results.
+     * @type {number}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly startIndex?: number;
+    /**
+     * Optional. The maximum number of records to return.
+     * @type {number}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly limit?: number;
+    /**
+     * Optional. The minimum date. Format &#x3D; ISO.
+     * @type {string}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly minDate?: string;
+    /**
+     * Optional. Filter log entries if it has user id, or not.
+     * @type {boolean}
+     * @memberof ActivityLogApiGetLogEntries
+     */
+    readonly hasUserId?: boolean;
+}
+/**
+ * ActivityLogApi - object-oriented interface
+ * @export
+ * @class ActivityLogApi
+ * @extends {BaseAPI}
+ */
+export declare class ActivityLogApi extends BaseAPI {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {ActivityLogApiGetLogEntriesRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ActivityLogApi
+     */
+    getLogEntries(requestParameters?: ActivityLogApiGetLogEntriesRequest, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<ActivityLogEntryQueryResult, any>>;
+}

package/lib/generated-client/api/activity-log-api.js

@@ -0,0 +1,146 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit the class manually.
+ *
+ * Jellyfin API
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+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 globalAxios from 'axios';
+// Some imports not used depending on template conditions
+// @ts-ignore
+import { DUMMY_BASE_URL, setApiKeyToObject, setSearchParams, toPathString, createRequestFunction } from '../common';
+// @ts-ignore
+import { BASE_PATH, BaseAPI } from '../base';
+/**
+ * ActivityLogApi - axios parameter creator
+ * @export
+ */
+export const ActivityLogApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         *
+         * @summary Gets activity log entries.
+         * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+         * @param {number} [limit] Optional. The maximum number of records to return.
+         * @param {string} [minDate] Optional. The minimum date. Format = ISO.
+         * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getLogEntries: (startIndex, limit, minDate, hasUserId, options = {}) => __awaiter(this, void 0, void 0, function* () {
+            const localVarPath = `/System/ActivityLog/Entries`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = Object.assign(Object.assign({ method: 'GET' }, baseOptions), options);
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication CustomAuthentication required
+            yield setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration);
+            if (startIndex !== undefined) {
+                localVarQueryParameter['startIndex'] = startIndex;
+            }
+            if (limit !== undefined) {
+                localVarQueryParameter['limit'] = limit;
+            }
+            if (minDate !== undefined) {
+                localVarQueryParameter['minDate'] = (minDate instanceof Date) ?
+                    minDate.toISOString() :
+                    minDate;
+            }
+            if (hasUserId !== undefined) {
+                localVarQueryParameter['hasUserId'] = hasUserId;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = Object.assign(Object.assign(Object.assign({}, localVarHeaderParameter), headersFromBaseOptions), options.headers);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        }),
+    };
+};
+/**
+ * ActivityLogApi - functional programming interface
+ * @export
+ */
+export const ActivityLogApiFp = function (configuration) {
+    const localVarAxiosParamCreator = ActivityLogApiAxiosParamCreator(configuration);
+    return {
+        /**
+         *
+         * @summary Gets activity log entries.
+         * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+         * @param {number} [limit] Optional. The maximum number of records to return.
+         * @param {string} [minDate] Optional. The minimum date. Format = ISO.
+         * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getLogEntries(startIndex, limit, minDate, hasUserId, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const localVarAxiosArgs = yield localVarAxiosParamCreator.getLogEntries(startIndex, limit, minDate, hasUserId, options);
+                return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            });
+        },
+    };
+};
+/**
+ * ActivityLogApi - factory interface
+ * @export
+ */
+export const ActivityLogApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = ActivityLogApiFp(configuration);
+    return {
+        /**
+         *
+         * @summary Gets activity log entries.
+         * @param {number} [startIndex] Optional. The record index to start at. All items with a lower index will be dropped from the results.
+         * @param {number} [limit] Optional. The maximum number of records to return.
+         * @param {string} [minDate] Optional. The minimum date. Format = ISO.
+         * @param {boolean} [hasUserId] Optional. Filter log entries if it has user id, or not.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getLogEntries(startIndex, limit, minDate, hasUserId, options) {
+            return localVarFp.getLogEntries(startIndex, limit, minDate, hasUserId, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * ActivityLogApi - object-oriented interface
+ * @export
+ * @class ActivityLogApi
+ * @extends {BaseAPI}
+ */
+export class ActivityLogApi extends BaseAPI {
+    /**
+     *
+     * @summary Gets activity log entries.
+     * @param {ActivityLogApiGetLogEntriesRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ActivityLogApi
+     */
+    getLogEntries(requestParameters = {}, options) {
+        return ActivityLogApiFp(this.configuration).getLogEntries(requestParameters.startIndex, requestParameters.limit, requestParameters.minDate, requestParameters.hasUserId, options).then((request) => request(this.axios, this.basePath));
+    }
+}