@ctrl/plex 1.5.2 → 2.0.0

package/dist/{myplex.js → src/myplex.js}

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MyPlexDevice = exports.ResourceConnection = exports.MyPlexResource = exports.MyPlexAccount = void 0;
-const got_1 = __importDefault(require("got"));
-const url_1 = require("url");
-const p_any_1 = __importDefault(require("p-any"));
-const config_1 = require("./config");
-const server_1 = require("./server");
-const plexObject_1 = require("./base/plexObject");
-const xml2js_1 = require("xml2js");
+import { URL, URLSearchParams } from 'url';
+import got from 'got';
+import pAny from 'p-any';
+import { parseStringPromise } from 'xml2js';
+import { PlexObject } from './base/plexObject.js';
+import { BASE_HEADERS, TIMEOUT } from './config.js';
+import { PlexServer } from './server.js';
 /**
  * MyPlex account and profile information. This object represents the data found Account on
  * the myplex.tv servers at the url https://plex.tv/users/account. You may create this object
@@ -18,7 +12,8 @@ const xml2js_1 = require("xml2js");
  * method provided at :class:`~plexapi.server.PlexServer.myPlexAccount()` which will create
  * and return this object.
  */
-class MyPlexAccount {
+export class MyPlexAccount {
+    static { this.key = 'https://plex.tv/api/v2/user'; }
     /**
      *
      * @param username Your MyPlex username
@@ -28,7 +23,7 @@ class MyPlexAccount {
      * @param timeout timeout in seconds on initial connect to myplex
      * @param server not often available
      */
-    constructor(baseUrl = null, username, password, token, timeout = config_1.TIMEOUT, server) {
+    constructor(baseUrl = null, username, password, token, timeout = TIMEOUT, server) {
         this.baseUrl = baseUrl;
         this.username = username;
         this.password = password;
@@ -94,6 +89,18 @@ class MyPlexAccount {
         const data = await this.query(MyPlexResource.key);
         return data.map(device => new MyPlexResource(this, device, this.baseUrl));
     }
+    /**
+     * @param name Name to match against.
+     * @param clientId clientIdentifier to match against.
+     */
+    async device(name = '', clientId) {
+        const devices = await this.devices();
+        const device = devices.find(device => device.name?.toLowerCase() === name.toLowerCase() || device.clientIdentifier === clientId);
+        if (!device) {
+            throw new Error('Unable to find device');
+        }
+        return device;
+    }
     /**
      * Returns a list of all :class:`~plexapi.myplex.MyPlexDevice` objects connected to the server.
      */
@@ -117,18 +124,18 @@ class MyPlexAccount {
             const credentials = Buffer.from(`${username}:${password}`).toString('base64');
             requestHeaders.Authorization = `Basic ${credentials}`;
         }
-        const promise = got_1.default({
+        const promise = got({
             method,
-            url: new url_1.URL(url),
+            url: new URL(url),
             headers: requestHeaders,
-            timeout: timeout !== null && timeout !== void 0 ? timeout : config_1.TIMEOUT,
-            username,
-            password,
-            retry: 0,
+            timeout: { request: timeout ?? TIMEOUT },
+            ...(username ? { username } : {}),
+            ...(password ? { password } : {}),
+            retry: { limit: 0 },
         });
         if (url.includes('xml')) {
             const res = await promise;
-            const xml = await xml2js_1.parseStringPromise(res.body);
+            const xml = await parseStringPromise(res.body);
             return xml;
         }
         const res = await promise.json();
@@ -141,29 +148,29 @@ class MyPlexAccount {
      */
     async claimToken() {
         const url = 'https://plex.tv/api/claim/token.json';
-        const response = await this.query(url, 'get', undefined, config_1.TIMEOUT);
+        const response = await this.query(url, 'get', undefined, TIMEOUT);
         return response.token;
     }
     /**
      * @param token pass token from claimToken
      */
     async claimServer(token) {
-        const params = new url_1.URLSearchParams({
+        const params = new URLSearchParams({
             token,
-            ...config_1.BASE_HEADERS,
+            ...BASE_HEADERS,
         });
         const url = `${this.baseUrl}/myplex/claim?${params.toString()}`;
-        return got_1.default({
+        return got({
             method: 'POST',
             url,
-            timeout: config_1.TIMEOUT,
+            timeout: { request: TIMEOUT },
             headers: this._headers(),
-            retry: 0,
+            retry: { limit: 0 },
         });
     }
     _headers() {
         const headers = {
-            ...config_1.BASE_HEADERS,
+            ...BASE_HEADERS,
             'Content-type': 'application/json',
         };
         if (this.token) {
@@ -176,7 +183,6 @@ class MyPlexAccount {
         return data.user;
     }
     _loadData(user) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         // Attempt to prevent token from being logged accidentally
         Object.defineProperty(this, 'token', {
             enumerable: false,
@@ -194,21 +200,19 @@ class MyPlexAccount {
         this.username = user.username;
         this.title = user.title;
         this.locale = user.locale;
-        this.mailingListStatus = (_a = user.mailingListStatus) !== null && _a !== void 0 ? _a : 'inactive';
+        this.mailingListStatus = user.mailingListStatus ?? 'inactive';
         this.mailingListActive = user.mailingListActive;
         this.queueEmail = user.queueEmail;
         this.thumb = user.thumb;
         this.scrobbleTypes = user.scrobbleTypes;
         this.restricted = user.restricted;
-        this.subscriptionActive = (_c = (_b = user.subscription) === null || _b === void 0 ? void 0 : _b.active) !== null && _c !== void 0 ? _c : null;
-        this.subscriptionStatus = (_f = (_e = (_d = user.subscription) === null || _d === void 0 ? void 0 : _d.status) === null || _e === void 0 ? void 0 : _e.toLowerCase()) !== null && _f !== void 0 ? _f : 'inactive';
-        this.subscriptionPlan = (_h = (_g = user.subscription) === null || _g === void 0 ? void 0 : _g.plan) !== null && _h !== void 0 ? _h : null;
-        this.subscriptionFeatures = (_k = (_j = user.subscription) === null || _j === void 0 ? void 0 : _j.features) !== null && _k !== void 0 ? _k : [];
+        this.subscriptionActive = user.subscription?.active ?? null;
+        this.subscriptionStatus = user.subscription?.status?.toLowerCase() ?? 'inactive';
+        this.subscriptionPlan = user.subscription?.plan ?? null;
+        this.subscriptionFeatures = user.subscription?.features ?? [];
         this.entitlements = user.entitlements;
     }
 }
-exports.MyPlexAccount = MyPlexAccount;
-MyPlexAccount.key = 'https://plex.tv/api/v2/user';
 /**
  * Connects to the specified cls with url and token
  */
@@ -221,7 +225,8 @@ async function connect(cls, url, token, timeout) {
  * This object represents resources connected to your Plex server that can provide
  * content such as Plex Media Servers, iPhone or Android clients, etc.
  */
-class MyPlexResource {
+export class MyPlexResource {
+    static { this.key = 'https://plex.tv/api/v2/resources?includeHttps=1&includeRelay=1'; }
     constructor(account, data, baseUrl = null) {
         this.account = account;
         this.baseUrl = baseUrl;
@@ -255,19 +260,18 @@ class MyPlexResource {
         // TODO: switch between PlexServer and PlexClient
         // Try connecting to all known resource connections in parellel, but
         // only return the first server (in order) that provides a response.
-        const promises = attemptUrls.map(async (url) => connect((...args) => new server_1.PlexServer(...args), url, this.accessToken, timeout));
-        const result = await p_any_1.default(promises);
+        const promises = attemptUrls.map(async (url) => connect((...args) => new PlexServer(...args), url, this.accessToken, timeout));
+        const result = await pAny(promises);
         return result;
     }
     /** Remove this device from your account */
     async delete() {
-        const key = `https://plex.tv/api/servers/${this.clientIdentifier}?X-Plex-Client-Identifier=${config_1.BASE_HEADERS['X-Plex-Client-Identifier']}&X-Plex-Token=${this.accessToken}`;
-        await got_1.default.delete(key, { retry: 0 });
+        const key = `https://plex.tv/api/servers/${this.clientIdentifier}?X-Plex-Client-Identifier=${BASE_HEADERS['X-Plex-Client-Identifier']}&X-Plex-Token=${this.accessToken}`;
+        await got.delete(key, { retry: { limit: 0 } });
     }
     _loadData(data) {
-        var _a, _b, _c;
         this.name = data.name;
-        this.accessToken = (_a = data.accessToken) !== null && _a !== void 0 ? _a : '';
+        this.accessToken = data.accessToken ?? '';
         this.owned = data.owned;
         this.clientIdentifier = data.clientIdentifier;
         this.createdAt = new Date(data.createdAt);
@@ -282,12 +286,10 @@ class MyPlexResource {
         this.product = data.product;
         this.productVersion = data.productVersion;
         this.connections =
-            (_c = (_b = data.connections) === null || _b === void 0 ? void 0 : _b.map(connection => new ResourceConnection(connection))) !== null && _c !== void 0 ? _c : [];
+            data.connections?.map(connection => new ResourceConnection(connection)) ?? [];
     }
 }
-exports.MyPlexResource = MyPlexResource;
-MyPlexResource.key = 'https://plex.tv/api/v2/resources?includeHttps=1&includeRelay=1';
-class ResourceConnection {
+export class ResourceConnection {
     constructor(data) {
         this.TAG = 'Connection';
         this._loadData(data);
@@ -301,16 +303,31 @@ class ResourceConnection {
         this.httpuri = `http://${data.address}:${data.port}`;
     }
 }
-exports.ResourceConnection = ResourceConnection;
 /**
  * This object represents resources connected to your Plex server that provide
  * playback ability from your Plex Server, iPhone or Android clients, Plex Web,
  * this API, etc. The raw xml for the data presented here can be found at:
  * https://plex.tv/devices.xml
  */
-class MyPlexDevice extends plexObject_1.PlexObject {
+export class MyPlexDevice extends PlexObject {
+    static { this.TAG = 'Device'; }
+    static { this.key = 'https://plex.tv/devices.xml'; }
+    async connect() {
+        // TODO: switch between PlexServer and PlexClient
+        // Try connecting to all known resource connections in parellel, but
+        // only return the first server (in order) that provides a response.
+        const promises = (this.connections ?? []).map(async (url) => connect((...args) => new PlexServer(...args), url, this.token));
+        const result = await pAny(promises);
+        return result;
+    }
+    /**
+     * Remove this device from your account
+     */
+    async delete() {
+        const key = `https://plex.tv/devices/${this.id}.xml`;
+        await this.server.query(key, 'delete');
+    }
     _loadData(data) {
-        var _a;
         this.name = data.$.name;
         this.publicAddress = data.$.publicAddress;
         this.product = data.$.product;
@@ -332,11 +349,8 @@ class MyPlexDevice extends plexObject_1.PlexObject {
         });
         this.screenResolution = data.$.screenResolution;
         this.screenDensity = data.$.screenDensity;
-        this.createdAt = new Date(data.$.createdAt);
-        this.lastSeenAt = new Date(data.$.lastSeenAt);
-        this.connections = (_a = data.Connection) === null || _a === void 0 ? void 0 : _a.map(connection => connection.$.uri);
+        this.createdAt = new Date(parseInt(data.$.createdAt, 10));
+        this.lastSeenAt = new Date(parseInt(data.$.lastSeenAt, 10));
+        this.connections = data.Connection?.map(connection => connection.$.uri);
     }
 }
-exports.MyPlexDevice = MyPlexDevice;
-MyPlexDevice.TAG = 'Device';
-MyPlexDevice.key = 'https://plex.tv/devices.xml';

package/dist/src/myplex.types.js

@@ -0,0 +1,10 @@
+export var Status;
+(function (Status) {
+    Status["Online"] = "online";
+    Status["Offline"] = "offline";
+})(Status || (Status = {}));
+export var Protocol;
+(function (Protocol) {
+    Protocol["HTTP"] = "http";
+    Protocol["HTTPS"] = "https";
+})(Protocol || (Protocol = {}));

package/dist/src/playlist.d.ts

@@ -0,0 +1,75 @@
+import { Playable } from './base/playable.js';
+import type { Section } from './library.js';
+import { PlaylistResponse } from './playlist.types.js';
+import type { PlexServer } from './server.js';
+import { Episode, Movie, VideoType } from './video.js';
+interface CreateRegularPlaylistOptions {
+    /** True to create a smart playlist */
+    smart?: false;
+    /** Regular playlists only */
+    items?: VideoType[];
+}
+interface CreateSmartPlaylistOptions {
+    /** True to create a smart playlist */
+    smart: true;
+    /** Smart playlists only, the library section to create the playlist in. */
+    section?: Section;
+    /** Smart playlists only, limit the number of items in the playlist. */
+    limit?: number;
+    /**
+     * Smart playlists only, a string of comma separated sort fields
+     * or a list of sort fields in the format ``column:dir``.
+     * See {@link Section.search}  for more info.
+     */
+    sort?: string;
+    /**
+     * Smart playlists only, a dictionary of advanced filters.
+     * See {@link Section.search}  for more info.
+     */
+    filters?: Record<string, any>;
+}
+type CreatePlaylistOptions = CreateRegularPlaylistOptions | CreateSmartPlaylistOptions;
+type PlaylistContent = Episode | Movie;
+export declare class Playlist extends Playable {
+    static TAG: string;
+    static create(server: PlexServer, title: string, options: CreatePlaylistOptions): Promise<Playlist>;
+    /** Create a smart playlist. */
+    private static _create;
+    TYPE: string;
+    addedAt: Date;
+    updatedAt: Date;
+    composite: string;
+    guid: string;
+    leafCount: number;
+    playlistType: string;
+    smart: boolean;
+    summary: string;
+    allowSync?: boolean;
+    duration?: number;
+    durationInSeconds?: number;
+    /** Cache of playlist items */
+    private _items;
+    _edit(args: {
+        title?: string;
+        summary?: string;
+    }): Promise<void>;
+    edit(changeObj: {
+        title?: string;
+        summary?: string;
+    }): Promise<void>;
+    /**
+     * @returns the item in the playlist that matches the specified title.
+     */
+    item(title: string): Promise<PlaylistContent | null>;
+    items(): Promise<PlaylistContent[]>;
+    /** Add items to a playlist. */
+    addItems(items: PlaylistContent[]): Promise<void>;
+    /** Remove an item from a playlist. */
+    removeItems(items: PlaylistContent[]): Promise<void>;
+    /** Delete the playlist. */
+    delete(): Promise<void>;
+    protected _loadData(data: PlaylistResponse): void;
+    protected _loadFullData(data: any): void;
+    private _getPlaylistItemID;
+}
+export {};

package/dist/src/playlist.js

@@ -0,0 +1,142 @@
+import { URLSearchParams } from 'url';
+import { Playable } from './base/playable.js';
+import { fetchItems } from './baseFunctionality.js';
+import { BadRequest, NotFound } from './exceptions.js';
+import { Episode, Movie } from './video.js';
+/**
+ * Map media types to their respective class
+ */
+function contentClass(data) {
+    switch (data.type) {
+        case 'episode':
+            return Episode;
+        case 'movie':
+            return Movie;
+        default:
+            throw new Error('Media type not implemented');
+    }
+}
+export class Playlist extends Playable {
+    constructor() {
+        super(...arguments);
+        this.TYPE = 'playlist';
+        /** Cache of playlist items */
+        this._items = null;
+    }
+    static { this.TAG = 'Playlist'; }
+    static async create(server, title, options) {
+        if (options.smart) {
+            throw new Error('not yet supported');
+            // return this._createSmart(server, title, options);
+        }
+        return this._create(server, title, options.items);
+    }
+    /** Create a smart playlist. */
+    // private static _createSmart(server: PlexServer, title: string, options: CreatePlaylistOptions) {}
+    static async _create(server, title, items) {
+        if (!items || items.length === 0) {
+            throw new BadRequest('Must include items to add when creating new playlist.');
+        }
+        const { listType } = items[0];
+        const ratingKeys = items ? items.map(x => x.ratingKey) : [];
+        const uri = `${server._uriRoot()}/library/metadata/${ratingKeys.join(',')}`;
+        const params = new URLSearchParams({
+            uri,
+            type: listType,
+            title,
+            smart: '0',
+        });
+        const key = `/playlists?${params.toString()}`;
+        const data = await server.query(key, 'post');
+        return new Playlist(server, data.MediaContainer.Metadata[0], key);
+    }
+    async _edit(args) {
+        const searchparams = new URLSearchParams(args);
+        const key = `${this.key}?${searchparams.toString()}`;
+        await this.server.query(key, 'put');
+    }
+    async edit(changeObj) {
+        await this._edit(changeObj);
+    }
+    /**
+     * @returns the item in the playlist that matches the specified title.
+     */
+    async item(title) {
+        const items = await this.items();
+        const matched = items.find(item => item.title.toLowerCase() === title.toLowerCase());
+        return matched ?? null;
+    }
+    async items() {
+        if (this._items === null) {
+            const key = `/playlists/${this.ratingKey}/items`;
+            const items = await fetchItems(this.server, key);
+            this._items = items.map(data => {
+                const Cls = contentClass(data);
+                return new Cls(this.server, data, key, this);
+            });
+        }
+        return this._items;
+    }
+    /** Add items to a playlist. */
+    async addItems(items) {
+        if (this.smart) {
+            throw new BadRequest('Cannot add items to a smart playlist.');
+        }
+        const isInvalidType = items.some(x => x.listType !== this.playlistType);
+        if (isInvalidType) {
+            throw new BadRequest('Can not mix media types when building a playlist');
+        }
+        const ratingKeys = items.map(x => x.ratingKey);
+        const params = new URLSearchParams({
+            uri: `${this.server._uriRoot()}/library/metadata/${ratingKeys.join(',')}`,
+        });
+        const key = `${this.key}/items?${params.toString()}`;
+        await this.server.query(key, 'put');
+    }
+    /** Remove an item from a playlist. */
+    async removeItems(items) {
+        if (this.smart) {
+            throw new BadRequest('Cannot remove items to a smart playlist.');
+        }
+        for (const item of items) {
+            // eslint-disable-next-line no-await-in-loop
+            const playlistItemId = await this._getPlaylistItemID(item);
+            const key = `${this.key}/items/${playlistItemId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await this.server.query(key, 'delete');
+        }
+    }
+    /** Delete the playlist. */
+    async delete() {
+        await this.server.query(this.key, 'delete');
+    }
+    _loadData(data) {
+        this.key = data.key.replace('/items', '');
+        this.ratingKey = data.ratingKey;
+        this.title = data.title;
+        this.type = data.type;
+        this.addedAt = new Date(data.addedAt);
+        this.updatedAt = new Date(data.updatedAt);
+        this.composite = data.composite;
+        this.guid = data.guid;
+        this.playlistType = data.playlistType;
+        this.summary = data.summary;
+        this.smart = data.smart;
+        this.leafCount = data.leafCount;
+        // TODO: verify these. Possibly audio playlist related
+        this.allowSync = data.allowSync;
+        this.duration = data.duration;
+        this.durationInSeconds = data.durationInSeconds;
+    }
+    _loadFullData(data) {
+        this._loadData(data.Metadata[0]);
+    }
+    async _getPlaylistItemID(item) {
+        const items = await this.items();
+        const playlistItem = items.find(i => i.ratingKey === item.ratingKey);
+        if (!playlistItem) {
+            throw new NotFound(`Item with title "${item.title}" not found in the playlist`);
+        }
+        return playlistItem.playlistItemID;
+    }
+}

package/dist/src/playlist.types.d.ts

@@ -0,0 +1,17 @@
+export interface PlaylistResponse {
+    ratingKey: string;
+    key: string;
+    guid: string;
+    type: string;
+    title: string;
+    summary: string;
+    smart: boolean;
+    playlistType: string;
+    composite: string;
+    leafCount: number;
+    addedAt: number;
+    updatedAt: number;
+    allowSync?: boolean;
+    duration?: number;
+    durationInSeconds?: number;
+}

package/dist/src/playlist.types.js

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

package/dist/{search.d.ts → src/search.d.ts}

@@ -1,6 +1,6 @@
 import { ValueOf } from 'type-fest';
-import { PlexObject } from './base/plexObject';
-import { MatchSearchResult } from './search.types';
+import { PlexObject } from './base/plexObject.js';
+import { MatchSearchResult } from './search.types.js';
 export declare class SearchResult extends PlexObject {
     static TAG: string;
     guid: string;
@@ -41,12 +41,13 @@ export declare const SEARCHTYPES: {
     readonly playlist: 15;
     readonly playlistFolder: 16;
     readonly collection: 18;
+    readonly optimizedVersion: 42;
     readonly userPlaylistItem: 1001;
 };
-declare type SearchTypesValues = ValueOf<typeof SEARCHTYPES>;
+type SearchTypesValues = ValueOf<typeof SEARCHTYPES>;
 /**
  * Returns the integer value of the library string type.
  * @param libtype to lookup (movie, show, season, episode, artist, album, track, collection)
  */
-export declare function searchType(libtype: string | number | keyof typeof SEARCHTYPES | SearchTypesValues): SearchTypesValues;
+export declare function searchType(libtype?: string | number | keyof typeof SEARCHTYPES | SearchTypesValues): SearchTypesValues;
 export {};

package/dist/{search.js → src/search.js}

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchType = exports.SEARCHTYPES = exports.Agent = exports.SearchResult = void 0;
-const plexObject_1 = require("./base/plexObject");
-const util_1 = require("./util");
-class SearchResult extends plexObject_1.PlexObject {
+import { PlexObject } from './base/plexObject.js';
+import { rsplit } from './util.js';
+export class SearchResult extends PlexObject {
+    static { this.TAG = 'SearchResult'; }
     _loadData(data) {
         this.guid = data.guid;
         this.lifespanEnded = data.lifespanEnded;
@@ -12,19 +10,18 @@ class SearchResult extends plexObject_1.PlexObject {
         this.year = data.year;
     }
 }
-exports.SearchResult = SearchResult;
-SearchResult.TAG = 'SearchResult';
 /**
  * Represents a single Agent
  */
-class Agent extends plexObject_1.PlexObject {
+export class Agent extends PlexObject {
+    static { this.TAG = 'Agent'; }
     // languageCode: any[] = [];
     _loadData(data) {
         this.hasAttribution = data.hasAttribution;
         this.hasPrefs = data.hasPrefs;
         this.identifier = data.identifier;
         this.primary = data.primary;
-        this.shortIdentifier = util_1.rsplit(this.identifier, '.', 1)[1];
+        this.shortIdentifier = rsplit(this.identifier, '.', 1)[1];
         if (this.initpath.includes('mediaType')) {
             this.name = data.name;
             // this.languageCode = [];
@@ -32,9 +29,7 @@ class Agent extends plexObject_1.PlexObject {
         }
     }
 }
-exports.Agent = Agent;
-Agent.TAG = 'Agent';
-exports.SEARCHTYPES = {
+export const SEARCHTYPES = {
     movie: 1,
     show: 2,
     season: 3,
@@ -52,21 +47,22 @@ exports.SEARCHTYPES = {
     playlist: 15,
     playlistFolder: 16,
     collection: 18,
+    optimizedVersion: 42,
     userPlaylistItem: 1001,
 };
 /**
  * Returns the integer value of the library string type.
  * @param libtype to lookup (movie, show, season, episode, artist, album, track, collection)
  */
-function searchType(libtype) {
-    if (Object.values(exports.SEARCHTYPES)
-        .map(x => x.toString())
-        .includes(libtype.toString())) {
+export function searchType(libtype) {
+    if (libtype &&
+        Object.values(SEARCHTYPES)
+            .map(num => num.toString())
+            .includes(`${libtype}`)) {
         return Number(libtype);
     }
-    if (exports.SEARCHTYPES[libtype] !== undefined) {
-        return exports.SEARCHTYPES[libtype];
+    if (libtype && SEARCHTYPES[libtype] !== undefined) {
+        return SEARCHTYPES[libtype];
     }
     throw new Error(`Unknown libtype: ${libtype}`);
 }
-exports.searchType = searchType;

package/dist/src/search.types.js

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