@lucaperret/tidal-cli 1.2.3 → 1.2.5

package/dist/history.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRecentlyAddedData = getRecentlyAddedData;
 exports.getRecentlyAdded = getRecentlyAdded;
 const auth_1 = require("./auth");
+const pagination_1 = require("./pagination");
 const endpointMap = {
     tracks: '/userCollectionTracks/{id}/relationships/items',
     albums: '/userCollectionAlbums/{id}/relationships/items',
@@ -14,20 +15,15 @@ const includeTypeMap = {
     artists: 'artists',
 };
 async function getRecentlyAddedData(type, client, countryCode) {
-    const { data, error } = await client.GET(endpointMap[type], {
-        params: {
-            path: { id: 'me' },
-            query: {
-                countryCode,
-                include: ['items'],
-                sort: ['-addedAt'],
-            },
+    // Paginated: returns the full collection (most-recent-first), not just the first ~20.
+    const { data: relData, included } = await (0, pagination_1.fetchAllPages)(client, endpointMap[type], {
+        path: { id: 'me' },
+        query: {
+            countryCode,
+            include: ['items'],
+            sort: ['-addedAt'],
         },
     });
-    if (error || !data) {
-        throw new Error(`Failed to get recently added ${type} — ${JSON.stringify(error)}`);
-    }
-    const included = data.included ?? [];
     const items = included
         .filter((item) => item.type === includeTypeMap[type])
         .map((item) => {
@@ -39,7 +35,6 @@ async function getRecentlyAddedData(type, client, countryCode) {
         };
     });
     // Enrich with addedAt from the relationship data if available
-    const relData = data.data ?? [];
     for (const rel of relData) {
         const addedAt = rel.meta?.addedAt;
         if (addedAt) {

package/dist/library.js

@@ -11,6 +11,7 @@ exports.addPlaylistToFavorites = addPlaylistToFavorites;
 exports.removePlaylistFromFavoritesData = removePlaylistFromFavoritesData;
 exports.removePlaylistFromFavorites = removePlaylistFromFavorites;
 const auth_1 = require("./auth");
+const pagination_1 = require("./pagination");
 const collectionEndpoints = {
     artist: { path: '/userCollectionArtists/{id}/relationships/items', type: 'artists' },
     album: { path: '/userCollectionAlbums/{id}/relationships/items', type: 'albums' },
@@ -74,18 +75,10 @@ async function removeFromLibrary(resourceType, resourceId, json) {
     }
 }
 async function listFavoritedPlaylistsData(client) {
-    const { data, error } = await client.GET('/userCollectionPlaylists/{id}/relationships/items', {
-        params: {
-            path: { id: 'me' },
-            query: {
-                include: ['items'],
-            },
-        },
+    const { included } = await (0, pagination_1.fetchAllPages)(client, '/userCollectionPlaylists/{id}/relationships/items', {
+        path: { id: 'me' },
+        query: { include: ['items'] },
     });
-    if (error || !data) {
-        throw new Error(`Failed to list favorited playlists — ${JSON.stringify(error)}`);
-    }
-    const included = data.included ?? [];
     return included
         .filter((item) => item.type === 'playlists')
         .map((item) => {

package/dist/pagination.d.ts

@@ -0,0 +1,19 @@
+/** Pull the `page[cursor]` token out of a JSON:API `links.next` value. */
+export declare function extractCursor(next: unknown): string | undefined;
+interface PageParams {
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+}
+interface PaginationOptions {
+    /** Delay between per-page retries. Overridable (set to 0) to keep tests fast. */
+    retryDelayMs?: number;
+}
+/**
+ * Repeatedly GET `path`, following `links.next`, until no further page.
+ * Returns the concatenated `data` and `included` arrays from every page.
+ */
+export declare function fetchAllPages(client: any, path: string, params: PageParams, options?: PaginationOptions): Promise<{
+    data: any[];
+    included: any[];
+}>;
+export {};

package/dist/pagination.js

@@ -0,0 +1,86 @@
+"use strict";
+// Cursor-based pagination for the Tidal v2 JSON:API.
+//
+// List responses return one page (~20 items) plus a `links.next` value carrying a
+// `page[cursor]` token for the following page. The API also intermittently returns
+// an HTTP 200 with an empty `data` array — a transient glitch that must be retried,
+// otherwise a single bad response silently truncates the result.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCursor = extractCursor;
+exports.fetchAllPages = fetchAllPages;
+const MAX_PAGES = 100; // safety cap against a server that never stops returning `next`
+const MAX_ATTEMPTS = 3; // per-page attempts for transient empty/error responses
+const RETRY_DELAY_MS = 250;
+/** Pull the `page[cursor]` token out of a JSON:API `links.next` value. */
+function extractCursor(next) {
+    if (typeof next !== 'string' || next.length === 0)
+        return undefined;
+    const queryStart = next.indexOf('?');
+    const queryString = queryStart >= 0 ? next.slice(queryStart + 1) : next;
+    const cursor = new URLSearchParams(queryString).get('page[cursor]');
+    return cursor ?? undefined;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * GET a single page, retrying transient failures (an `{ error }` response or an
+ * HTTP 200 with an empty `data` array). Throws once every attempt has errored;
+ * returns the (possibly empty) page once retries are exhausted without an error —
+ * an empty page is then treated as genuine end-of-data.
+ */
+async function fetchPage(client, path, requestParams, retryDelayMs) {
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        const { data, error } = await client.GET(path, { params: requestParams });
+        if (!error && data) {
+            const pageData = data.data ?? [];
+            // A non-empty page is always real. An empty page may be a transient glitch,
+            // so accept it only once retries are spent.
+            if (pageData.length > 0 || attempt === MAX_ATTEMPTS) {
+                const links = data.links;
+                return {
+                    data: pageData,
+                    included: data.included ?? [],
+                    cursor: links?.meta?.nextCursor ?? extractCursor(links?.next),
+                };
+            }
+            lastError = undefined;
+        }
+        else {
+            lastError = error;
+        }
+        if (attempt < MAX_ATTEMPTS)
+            await sleep(retryDelayMs);
+    }
+    throw new Error(`Failed to fetch ${path} — ${JSON.stringify(lastError)}`);
+}
+/**
+ * Repeatedly GET `path`, following `links.next`, until no further page.
+ * Returns the concatenated `data` and `included` arrays from every page.
+ */
+async function fetchAllPages(client, path, params, options = {}) {
+    const retryDelayMs = options.retryDelayMs ?? RETRY_DELAY_MS;
+    const allData = [];
+    const allIncluded = [];
+    const seenCursors = new Set();
+    let cursor;
+    for (let page = 0; page < MAX_PAGES; page++) {
+        const query = { ...(params.query ?? {}) };
+        if (cursor)
+            query['page[cursor]'] = cursor;
+        const requestParams = {};
+        if (params.path)
+            requestParams.path = params.path;
+        if (Object.keys(query).length > 0)
+            requestParams.query = query;
+        const result = await fetchPage(client, path, requestParams, retryDelayMs);
+        allData.push(...result.data);
+        allIncluded.push(...result.included);
+        cursor = result.cursor;
+        // Stop on no next page, or if the server hands back a cursor already used.
+        if (!cursor || seenCursors.has(cursor))
+            break;
+        seenCursors.add(cursor);
+    }
+    return { data: allData, included: allIncluded };
+}
+//# sourceMappingURL=pagination.js.map

package/dist/playlist.js

@@ -19,19 +19,15 @@ exports.moveTrackInPlaylist = moveTrackInPlaylist;
 exports.updatePlaylistDescriptionData = updatePlaylistDescriptionData;
 exports.updatePlaylistDescription = updatePlaylistDescription;
 const auth_1 = require("./auth");
+const pagination_1 = require("./pagination");
 async function listPlaylistsData(client, countryCode) {
-    const { data, error } = await client.GET('/playlists', {
-        params: {
-            query: {
-                'filter[owners.id]': ['me'],
-                countryCode,
-            },
+    const { data } = await (0, pagination_1.fetchAllPages)(client, '/playlists', {
+        query: {
+            'filter[owners.id]': ['me'],
+            countryCode,
         },
     });
-    if (error || !data) {
-        throw new Error(`Failed to list playlists — ${JSON.stringify(error)}`);
-    }
-    return (data.data ?? []).map((p) => ({
+    return data.map((p) => ({
         id: p.id,
         name: p.attributes?.name ?? 'Untitled',
         description: p.attributes?.description,
@@ -187,13 +183,9 @@ async function addTrackToPlaylist(playlistId, trackId, json) {
     }
 }
 async function removeTrackFromPlaylistData(playlistId, trackId, client) {
-    const { data: itemsData, error: itemsError } = await client.GET('/playlists/{id}/relationships/items', {
-        params: { path: { id: playlistId } },
+    const { data: items } = await (0, pagination_1.fetchAllPages)(client, '/playlists/{id}/relationships/items', {
+        path: { id: playlistId },
     });
-    if (itemsError || !itemsData) {
-        throw new Error(`Failed to get playlist items — ${JSON.stringify(itemsError)}`);
-    }
-    const items = itemsData.data ?? [];
     const item = items.find((i) => i.id === trackId);
     if (!item) {
         throw new Error(`Track ${trackId} not found in playlist ${playlistId}.`);
@@ -267,13 +259,9 @@ async function addAlbumToPlaylist(playlistId, albumId, json) {
     }
 }
 async function moveTrackInPlaylistData(playlistId, trackId, positionBefore, client) {
-    const { data: itemsData, error: itemsError } = await client.GET('/playlists/{id}/relationships/items', {
-        params: { path: { id: playlistId } },
+    const { data: items } = await (0, pagination_1.fetchAllPages)(client, '/playlists/{id}/relationships/items', {
+        path: { id: playlistId },
     });
-    if (itemsError || !itemsData) {
-        throw new Error(`Failed to get playlist items — ${JSON.stringify(itemsError)}`);
-    }
-    const items = itemsData.data ?? [];
     const item = items.find((i) => i.id === trackId);
     if (!item) {
         throw new Error(`Track ${trackId} not found in playlist ${playlistId}.`);

package/dist/saved.js

@@ -7,17 +7,13 @@ exports.addSavedItem = addSavedItem;
 exports.removeSavedItemData = removeSavedItemData;
 exports.removeSavedItem = removeSavedItem;
 const auth_1 = require("./auth");
+const pagination_1 = require("./pagination");
 async function listSavedItemsData(client) {
-    const { data, error } = await client.GET('/userCollectionSaveForLaters/{id}/relationships/items', {
-        params: {
-            path: { id: 'me' },
-            query: { include: ['items'] },
-        },
+    // Paginated: returns the full save-for-later collection, not just the first ~20.
+    const { included } = await (0, pagination_1.fetchAllPages)(client, '/userCollectionSaveForLaters/{id}/relationships/items', {
+        path: { id: 'me' },
+        query: { include: ['items'] },
     });
-    if (error || !data) {
-        throw new Error(`Failed to list saved items — ${JSON.stringify(error)}`);
-    }
-    const included = data.included ?? [];
     return included.map((item) => {
         const attrs = item.attributes ?? {};
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaperret/tidal-cli",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "CLI for Tidal music streaming service, designed for LLM agent automation",
   "main": "dist/index.js",
   "bin": {