fix(autoplay): prioritize user tracks, Spotify liked seeds, sertanejo filter, expand Last.fm limits

packages/bot/src/spotify/spotifyApi.spec.ts

@@ -839,80 +839,179 @@ describe('spotifyApi', () => {
     })
 
     describe('getUserSavedTracks', () => {
-        it('returns track ids from saved tracks response', async () => {
+        it('returns empty array when response is not ok', async () => {
+            fetchMock.mockResolvedValue({ ok: false, json: async () => ({}) })
+
+            const result = await getUserSavedTracks('token')
+
+            expect(result).toEqual([])
+        })
+
+        it('returns track ids from a single page', async () => {
             fetchMock.mockResolvedValue({
                 ok: true,
-                json: () =>
-                    Promise.resolve({
-                        items: [
-                            { track: { id: 'track-1' } },
-                            { track: { id: 'track-2' } },
-                            { track: { id: 'track-3' } },
-                        ],
+                json: async () => ({
+                    items: [
+                        { track: { id: 'track-1' } },
+                        { track: { id: 'track-2' } },
+                    ],
+                    total: 2,
+                }),
+            })
+
+            const result = await getUserSavedTracks('token')
+
+            expect(result).toEqual(['track-1', 'track-2'])
+        })
+
+        it('paginates until all tracks are fetched', async () => {
+            let callCount = 0
+            fetchMock.mockImplementation(async () => {
+                callCount++
+                if (callCount === 1) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            items: Array.from({ length: 50 }, (_, i) => ({ track: { id: `track-${i}` } })),
+                            total: 60,
+                        }),
+                    }
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        items: Array.from({ length: 10 }, (_, i) => ({ track: { id: `track-${50 + i}` } })),
+                        total: 60,
                     }),
+                }
             })
-            ;(globalThis as { fetch: unknown }).fetch = fetchMock
 
             const result = await getUserSavedTracks('token')
-            expect(result).toEqual(['track-1', 'track-2', 'track-3'])
+
+            expect(result).toHaveLength(60)
+            expect(fetchMock).toHaveBeenCalledTimes(2)
+        })
+
+        it('stops when maxTracks (200) is reached', async () => {
+            fetchMock.mockImplementation(async () => ({
+                ok: true,
+                json: async () => ({
+                    items: Array.from({ length: 50 }, (_, i) => ({ track: { id: `t${i}` } })),
+                    total: 1000,
+                }),
+            }))
+
+            const result = await getUserSavedTracks('token')
+
+            expect(result.length).toBeLessThanOrEqual(200)
+            expect(fetchMock).toHaveBeenCalledTimes(4)
         })
 
-        it('filters out items with missing track id', async () => {
+        it('stops when items array is empty', async () => {
             fetchMock.mockResolvedValue({
                 ok: true,
-                json: () =>
-                    Promise.resolve({
-                        items: [
-                            { track: { id: 'track-1' } },
-                            { track: {} },
-                            { track: null },
-                            {},
-                        ],
-                    }),
+                json: async () => ({ items: [], total: 100 }),
             })
-            ;(globalThis as { fetch: unknown }).fetch = fetchMock
 
             const result = await getUserSavedTracks('token')
-            expect(result).toEqual(['track-1'])
+
+            expect(result).toEqual([])
+            expect(fetchMock).toHaveBeenCalledTimes(1)
         })
 
-        it('returns empty array when response is not ok', async () => {
-            fetchMock.mockResolvedValue({ ok: false })
-            ;(globalThis as { fetch: unknown }).fetch = fetchMock
+        it('breaks on non-ok response mid-pagination', async () => {
+            let callCount = 0
+            fetchMock.mockImplementation(async () => {
+                callCount++
+                if (callCount === 1) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            items: [{ track: { id: 'track-1' } }],
+                            total: 100,
+                        }),
+                    }
+                }
+                return { ok: false, json: async () => ({}) }
+            })
 
             const result = await getUserSavedTracks('token')
-            expect(result).toEqual([])
+
+            expect(result).toEqual(['track-1'])
         })
 
-        it('returns empty array when json parse fails', async () => {
+        it('breaks on JSON parse error', async () => {
             fetchMock.mockResolvedValue({
                 ok: true,
-                json: () => Promise.reject(new Error('parse error')),
+                json: async () => { throw new Error('JSON error') },
             })
-            ;(globalThis as { fetch: unknown }).fetch = fetchMock
 
             const result = await getUserSavedTracks('token')
+
             expect(result).toEqual([])
         })
 
-        it('returns empty array when fetch throws', async () => {
+        it('returns empty array on network error', async () => {
             fetchMock.mockRejectedValue(new Error('network error'))
-            ;(globalThis as { fetch: unknown }).fetch = fetchMock
 
             const result = await getUserSavedTracks('token')
+
             expect(result).toEqual([])
         })
 
-        it('caps limit at 50', async () => {
+        it('skips items without a track id', async () => {
+            fetchMock
+                .mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => ({
+                        items: [
+                            { track: { id: 'valid-1' } },
+                            { track: {} },
+                            { track: null },
+                            {},
+                            { track: { id: 'valid-2' } },
+                        ],
+                        total: 5,
+                    }),
+                })
+                .mockResolvedValue({
+                    ok: true,
+                    json: async () => ({ items: [], total: 5 }),
+                })
+
+            const result = await getUserSavedTracks('token')
+
+            expect(result).toEqual(['valid-1', 'valid-2'])
+        })
+
+        it('breaks when data has no items field', async () => {
             fetchMock.mockResolvedValue({
                 ok: true,
-                json: () => Promise.resolve({ items: [] }),
+                json: async () => ({ total: 10 }),
             })
-            ;(globalThis as { fetch: unknown }).fetch = fetchMock
 
-            await getUserSavedTracks('token', 200)
-            const url = (fetchMock.mock.calls[0] as [string])[0]
-            expect(url).toContain('limit=50')
+            const result = await getUserSavedTracks('token')
+
+            expect(result).toEqual([])
+        })
+
+        it('stops early when data.total matches accumulated count', async () => {
+            let callCount = 0
+            fetchMock.mockImplementation(async () => {
+                callCount++
+                return {
+                    ok: true,
+                    json: async () => ({
+                        items: [{ track: { id: `t${callCount}` } }],
+                        total: 1,
+                    }),
+                }
+            })
+
+            const result = await getUserSavedTracks('token')
+
+            expect(result).toHaveLength(1)
+            expect(fetchMock).toHaveBeenCalledTimes(1)
         })
     })
 })

packages/bot/src/spotify/spotifyApi.ts

@@ -1,5 +1,5 @@
 import { logAndSwallow } from '@lucky/shared/utils/error'
 import { debugLog, warnLog } from '@lucky/shared/utils/general/log'
 
 export interface SpotifyRecommendationTrack {
     id: string
@@ -465,26 +465,69 @@
     }
 }
 
 export async function getUserSavedTracks(
     accessToken: string,
-    limit = 50,
+    limit = 200,
 ): Promise<string[]> {
+    const savedTrackIds: string[] = []
+    const pageLimit = 50
+    const maxTracks = Math.min(limit, 200)
+    let offset = 0
+
     try {
-        const params = new URLSearchParams({ limit: String(Math.min(limit, 50)), offset: '0' })
-        const res = await fetch(
-            'https://api.spotify.com/v1/me/tracks?' + params.toString(),
-            { method: 'GET', headers: { Authorization: `Bearer ${accessToken}` } },
-        )
-        if (!res.ok) {
-            warnLog({ message: 'Spotify saved tracks fetch failed', data: { status: res.status } })
-            return []
-        }
-        const data = (await res.json().catch(() => null)) as {
-            items?: Array<{ track?: { id?: string } }>
+        while (offset < maxTracks) {
+            const params = new URLSearchParams({
+                limit: String(pageLimit),
+                offset: String(offset),
+            })
+            const res = await fetch(
+                `https://api.spotify.com/v1/me/tracks?${params.toString()}`,
+                {
+                    method: 'GET',
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                },
+            )
+
+            if (!res.ok) {
+                logAndSwallow(
+                    new Error(`HTTP ${res.status}`),
+                    'spotify.getUserSavedTracks.request',
+                    { status: res.status, offset },
+                )
+                await res.body?.cancel().catch(() => undefined)
+                break
+            }
+
+            type SavedTracksPage = { items: Array<{ track?: { id?: string } }>; total?: number }
+            let data: SavedTracksPage | null = null
+            try {
+                data = (await res.json()) as SavedTracksPage
+            } catch (parseErr) {
+                logAndSwallow(parseErr, 'spotify.getUserSavedTracks.parse', { offset })
+                break
+            }
+
+            if (!data?.items) {
+                break
+            }
+
+            for (const item of data.items) {
+                if (item.track?.id) {
+                    savedTrackIds.push(item.track.id)
+                }
+            }
+
+            const allFetched = data.total !== undefined && savedTrackIds.length >= data.total
+            if (savedTrackIds.length >= maxTracks || !data.items.length || allFetched) {
+                break
+            }
+
+            offset += pageLimit
         }
-        return (data?.items ?? [])
-            .map((item) => item.track?.id)
-            .filter((id): id is string => Boolean(id))
+
+        return savedTrackIds.slice(0, maxTracks)
     } catch (err) {
         logAndSwallow(err, 'spotify.getUserSavedTracks')
         return []

packages/bot/src/spotify/spotifyUserSeeds.spec.ts

@@ -20,6 +20,7 @@ describe('spotifyUserSeeds', () => {
         jest.clearAllMocks()
         ;(spotifyApi.getUserSavedTracks as jest.Mock).mockResolvedValue([])
         clearUserSeedsCache('test-user-id')
+        ;(spotifyApi.getUserSavedTracks as jest.Mock).mockResolvedValue([])
     })
 
     it('should fetch and cache user Spotify seeds', async () => {
@@ -165,7 +166,7 @@ describe('spotifyUserSeeds', () => {
         expect(result).toBeNull()
     })
 
-    it('should cache results for 5 minutes', async () => {
+    it('should cache results for 30 minutes', async () => {
         const mockLink = {
             spotifyId: 'spotify-123',
             accessToken: 'token',

packages/bot/src/spotify/spotifyUserSeeds.ts

@@ -15,13 +15,13 @@ interface SeededUserEntry {
     fetched: number
 }
 
+const CACHE_TTL_MS = 30 * 60 * 1000
+
 const userSeedsCache = new LRUCache<string, SeededUserEntry>({
     max: 500,
-    ttl: 5 * 60 * 1000,
+    ttl: CACHE_TTL_MS,
 })
 
-const CACHE_TTL_MS = 5 * 60 * 1000
-
 export async function getUserSpotifySeeds(userId: string): Promise<UserSpotifySeeds | null> {
     const now = Date.now()
     const cached = userSeedsCache.get(userId)
@@ -78,6 +78,7 @@ export async function getUserSpotifySeeds(userId: string): Promise<UserSpotifySe
                 userId,
                 artistCount: seeds.artistIds.length,
                 trackCount: seeds.trackIds.length,
+                likedTrackCount: likedTrackIds.length,
             },
         })