🎧 Your Personal Streaming Service
Go airsonicmadsonicmedia-servermusicmusic-servernavidromeopensubsonicraspberry-piself-hostedstreamerstreaming-apistreaming-audiosubsonicsubsonic-server
fix(jellyfin): close the unbounded playlist and search paths left by #5783 (#5784)
Deluan Quintão3d438b08efc7
diff --git a/core/playlists/playlists.go b/core/playlists/playlists.goindex 3da24706c..1ef083bbb 100644--- a/core/playlists/playlists.go+++ b/core/playlists/playlists.go@@ -22,6 +22,7 @@ type Playlists interface {GetAll(ctx context.Context, options ...model.QueryOptions) (model.Playlists, error)Get(ctx context.Context, id string) (*model.Playlist, error)GetWithTracks(ctx context.Context, id string) (*model.Playlist, error)+ Tracks(ctx context.Context, id string) (model.PlaylistTrackRepository, error)GetPlaylists(ctx context.Context, mediaFileId string) (model.Playlists, error)// Mutations@@ -98,6 +99,21 @@ func (s *playlists) GetPlaylists(ctx context.Context, mediaFileId string) (modelreturn s.ds.Playlist(ctx).GetPlaylists(mediaFileId)}+// Tracks scopes a repository to one playlist's tracks, for callers that page or stream them rather+// than loading every one like GetWithTracks. Gets first because PlaylistRepository.Tracks discards+// its error behind a nil (and warns), and this is probed with ids that are usually not playlists.+func (s *playlists) Tracks(ctx context.Context, id string) (model.PlaylistTrackRepository, error) {+ repo := s.ds.Playlist(ctx)+ if _, err := repo.Get(id); err != nil {+ return nil, err+ }+ tracks := repo.Tracks(id, true)+ if tracks == nil {+ return nil, model.ErrNotFound+ }+ return tracks, nil+}+// --- Mutation operations ---// Create creates a new playlist (when name is provided) or replaces tracks on an existingdiff --git a/core/playlists/playlists_test.go b/core/playlists/playlists_test.goindex f849a0a21..0c9674bed 100644--- a/core/playlists/playlists_test.go+++ b/core/playlists/playlists_test.go@@ -73,6 +73,28 @@ var _ = Describe("Playlists", func() {})})+ Describe("Tracks", func() {+ var mockTracks *tests.MockPlaylistTrackRepo++ BeforeEach(func() {+ mockTracks = &tests.MockPlaylistTrackRepo{}+ mockPlsRepo.Data = map[string]*model.Playlist{+ "pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},+ }+ mockPlsRepo.TracksRepo = mockTracks+ ps = playlists.NewPlaylists(ds, core.NewImageUploadService())+ })++ It("returns the playlist's track repository", func() {+ Expect(ps.Tracks(ctx, "pls-1")).To(BeIdenticalTo(mockTracks))+ })++ It("returns ErrNotFound for an unknown or invisible playlist", func() {+ _, err := ps.Tracks(ctx, "nonexistent")+ Expect(err).To(MatchError(model.ErrNotFound))+ })+ })+Describe("Create", func() {BeforeEach(func() {mockPlsRepo.Data = map[string]*model.Playlist{diff --git a/model/playlist.go b/model/playlist.goindex f2586f52d..40adb8d0a 100644--- a/model/playlist.go+++ b/model/playlist.go@@ -157,10 +157,15 @@ func (plt PlaylistTracks) MediaFiles() MediaFiles {return mfs}+type PlaylistTrackCursor iter.Seq2[PlaylistTrack, error]+type PlaylistTrackRepository interface {ResourceRepository+ CountAll(options ...QueryOptions) (int64, error)GetAll(options ...QueryOptions) (PlaylistTracks, error)+ GetCursor(options ...QueryOptions) (PlaylistTrackCursor, error)GetAlbumIDs(options ...QueryOptions) ([]string, error)+ GetMediaFileIDs(options ...QueryOptions) ([]string, error)Add(mediaFileIds []string) (int, error)AddAlbums(albumIds []string) (int, error)AddArtists(artistIds []string) (int, error)diff --git a/persistence/playlist_repository.go b/persistence/playlist_repository.goindex 9626aad6a..e39f0bbd3 100644--- a/persistence/playlist_repository.go+++ b/persistence/playlist_repository.go@@ -298,10 +298,11 @@ func (r *playlistRepository) refreshCounters(pls *model.Playlist) error {return nil}-func (r *playlistRepository) loadTracks(sel SelectBuilder, id string) (model.PlaylistTracks, error) {- sel = r.applyLibraryFilter(sel, "f")+// tracksQuery is shared by loadTracks and GetCursor, so both hydrate rows identically.+func (r *playlistRepository) tracksQuery(query SelectBuilder, id string) SelectBuilder {+ query = r.applyLibraryFilter(query, "f")userID := loggedUser(r.ctx).ID- tracksQuery := sel.+ return query.Columns("coalesce(starred, 0) as starred","starred_at",@@ -321,8 +322,11 @@ func (r *playlistRepository) loadTracks(sel SelectBuilder, id string) (model.PlaJoin("media_file f on f.id = media_file_id").Join("library on f.library_id = library.id").Where(Eq{"playlist_id": id})+}++func (r *playlistRepository) loadTracks(query SelectBuilder, id string) (model.PlaylistTracks, error) {tracks := dbPlaylistTracks{}- err := r.queryAll(tracksQuery, &tracks)+ err := r.queryAll(r.tracksQuery(query, id), &tracks)if err != nil {return nil, err}diff --git a/persistence/playlist_track_repository.go b/persistence/playlist_track_repository.goindex 1a7062cc2..e51ff8ea6 100644--- a/persistence/playlist_track_repository.go+++ b/persistence/playlist_track_repository.go@@ -77,6 +77,14 @@ func (r *playlistRepository) Tracks(playlistId string, refreshSmartPlaylist boolreturn p}+func (r *playlistTrackRepository) CountAll(options ...model.QueryOptions) (int64, error) {+ query := Select().+ Join("media_file f on f.id = media_file_id").+ Where(Eq{"playlist_id": r.playlistId})+ query = r.applyLibraryFilter(query, "f")+ return r.count(query, options...)+}+func (r *playlistTrackRepository) Count(options ...rest.QueryOptions) (int64, error) {query := Select().LeftJoin("media_file f on f.id = media_file_id").@@ -116,6 +124,30 @@ func (r *playlistTrackRepository) GetAll(options ...model.QueryOptions) (model.Preturn tracks, err}+func (r *playlistTrackRepository) GetCursor(options ...model.QueryOptions) (model.PlaylistTrackCursor, error) {+ sel := r.playlistRepo.tracksQuery(r.newSelect(options...), r.playlistId)+ cursor, err := queryWithStableResults[dbPlaylistTrack](r.sqlRepository, sel)+ if err != nil {+ return nil, err+ }+ return model.PlaylistTrackCursor(wrapCursor(cursor, func(t dbPlaylistTrack) *model.PlaylistTrack {+ return t.PlaylistTrack+ })), nil+}++// GetMediaFileIDs returns the tracks' song ids, for callers that need every id but no track data.+func (r *playlistTrackRepository) GetMediaFileIDs(options ...model.QueryOptions) ([]string, error) {+ query := r.newSelect(options...).Columns("media_file_id").+ Join("media_file f on f.id = media_file_id").+ Where(Eq{"playlist_id": r.playlistId})+ query = r.applyLibraryFilter(query, "f")+ var ids []string+ if err := r.queryAllSlice(query, &ids); err != nil {+ return nil, err+ }+ return ids, nil+}+func (r *playlistTrackRepository) GetAlbumIDs(options ...model.QueryOptions) ([]string, error) {query := r.newSelect(options...).Columns("distinct mf.album_id").Join("media_file mf on mf.id = media_file_id").diff --git a/persistence/playlist_track_repository_test.go b/persistence/playlist_track_repository_test.gonew file mode 100644index 000000000..36f9ae4a9--- /dev/null+++ b/persistence/playlist_track_repository_test.go@@ -0,0 +1,61 @@+package persistence++import (+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("PlaylistTrackRepository", func() {+ var repo model.PlaylistTrackRepository++ BeforeEach(func() {+ ctx := log.NewContext(GinkgoT().Context())+ ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "userid", IsAdmin: true})+ repo = NewPlaylistRepository(ctx, GetDBXBuilder()).Tracks(plsBest.ID, true)+ })++ Describe("GetCursor", func() {+ It("yields the same tracks as GetAll", func() {+ opts := model.QueryOptions{Sort: "id"}+ want, err := repo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).To(HaveLen(2))++ Expect(collectCursor(repo.GetCursor(opts))).To(Equal([]model.PlaylistTrack(want)))+ })++ It("honors Max and Offset", func() {+ opts := model.QueryOptions{Sort: "id", Max: 1, Offset: 1}+ want, err := repo.GetAll(opts)+ Expect(err).ToNot(HaveOccurred())+ Expect(want).To(HaveLen(1))++ Expect(collectCursor(repo.GetCursor(opts))).To(Equal([]model.PlaylistTrack(want)))+ })+ })++ Describe("CountAll", func() {+ It("returns the number of tracks in the playlist", func() {+ Expect(repo.CountAll()).To(Equal(int64(2)))+ })++ It("ignores Max and Offset", func() {+ Expect(repo.CountAll(model.QueryOptions{Max: 1, Offset: 1})).To(Equal(int64(2)))+ })+ })++ Describe("GetMediaFileIDs", func() {+ It("returns the song ids in playlist order", func() {+ Expect(repo.GetMediaFileIDs(model.QueryOptions{Sort: "id"})).+ To(Equal([]string{songDayInALife.ID, songRadioactivity.ID}))+ })++ It("honors Max and Offset", func() {+ Expect(repo.GetMediaFileIDs(model.QueryOptions{Sort: "id", Max: 1, Offset: 1})).+ To(Equal([]string{songRadioactivity.ID}))+ })+ })+})diff --git a/server/jellyfin/api.go b/server/jellyfin/api.goindex d169a4c83..e94d64e85 100644--- a/server/jellyfin/api.go+++ b/server/jellyfin/api.go@@ -102,6 +102,7 @@ func (api *Router) routes() http.Handler {r.Get("/Users/{userId}/Items/Latest", api.getLatest)r.Get("/Artists", api.getArtists)r.Get("/Artists/AlbumArtists", api.getAlbumArtists)+ r.Get("/Playlists/{playlistId}/Items", api.getPlaylistItems)})r.Get("/Items/{itemId}", api.getItem)@@ -131,7 +132,6 @@ func (api *Router) routes() http.Handler {r.Post("/Playlists", api.createPlaylist)r.Get("/Playlists/{playlistId}", api.getPlaylist)r.Post("/Playlists/{playlistId}", api.updatePlaylist)- r.Get("/Playlists/{playlistId}/Items", api.getPlaylistItems)r.Post("/Playlists/{playlistId}/Items", api.addToPlaylist)r.Delete("/Playlists/{playlistId}/Items", api.removeFromPlaylist)r.Get("/Playlists/{playlistId}/Users", api.getPlaylistUsers)diff --git a/server/jellyfin/browsing.go b/server/jellyfin/browsing.goindex d5a00e492..fae21fc0b 100644--- a/server/jellyfin/browsing.go+++ b/server/jellyfin/browsing.go@@ -33,7 +33,10 @@ func (api *Router) listArtistsByRole(w http.ResponseWriter, r *http.Request, rolq := itemsQuery{scopeIDs: scopeIDs,genreIds: decodedQueryIDs(r, "genreids"),- search: p.StringOr("searchterm", ""),+ search: searchTerm(p),+ }+ if q.search != "" {+ opts.Max = clampLimit(opts.Max, defaultSearchLimit, maxSearchLimit)}res, err := api.listArtists(ctx, opts, q, role)diff --git a/server/jellyfin/browsing_test.go b/server/jellyfin/browsing_test.goindex 7f50355e1..660e5d293 100644--- a/server/jellyfin/browsing_test.go+++ b/server/jellyfin/browsing_test.go@@ -111,6 +111,23 @@ var _ = Describe("Browsing", func() {Expect(res.Items).To(HaveLen(1))})+ It("bounds a search the client left unbounded, and clamps an oversized one", func() {+ artistRepo := ds.Artist(context.Background()).(*tests.MockArtistRepo)+ artistRepo.SetData(model.Artists{{ID: "ar1", Name: "Artist"}})++ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Artists?SearchTerm=art", nil).WithContext(ctxUser(model.Libraries{{ID: 1}}))+ invoke(api.getArtists, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(artistRepo.Options.Max).To(Equal(defaultSearchLimit + 1))++ w = httptest.NewRecorder()+ r = httptest.NewRequest("GET", "/Artists?SearchTerm=art&Limit=999999", nil).WithContext(ctxUser(model.Libraries{{ID: 1}}))+ invoke(api.getArtists, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(artistRepo.Options.Max).To(Equal(maxSearchLimit + 1))+ })+It("forwards StartIndex/Limit as Offset/Max", func() {artistRepo := ds.Artist(context.Background()).(*tests.MockArtistRepo)artistRepo.SetData(model.Artists{{ID: "ar1", Name: "Artist"}})diff --git a/server/jellyfin/items.go b/server/jellyfin/items.goindex 0dca48938..ff38b6491 100644--- a/server/jellyfin/items.go+++ b/server/jellyfin/items.go@@ -24,6 +24,12 @@ import (// album, artist and media_file).var notMissing = squirrel.Eq{"missing": false}+// searchTerm trims, so a whitespace-only term is not a search: doSearch would read it as "match+// everything" and materialize the library, where the unfiltered path streams.+func searchTerm(p *req.Values) string {+ return strings.TrimSpace(p.StringOr("searchterm", ""))+}+func (api *Router) getItems(w http.ResponseWriter, r *http.Request) {res, err := api.queryItems(r.Context(), r)if err != nil {@@ -226,7 +232,7 @@ func (api *Router) parseItemsQuery(ctx context.Context, r *http.Request) itemsQufields: dto.ParseFields(p.StringOr("fields", "")),ids: decodedQueryIDs(r, "ids"),rawTypes: p.StringOr("includeitemtypes", ""),- search: p.StringOr("searchterm", ""),+ search: searchTerm(p),sortBy: p.StringOr("sortby", ""),sortOrder: p.StringOr("sortorder", ""),offset: p.IntOr("startindex", 0),@@ -281,8 +287,11 @@ func (api *Router) queryItems(ctx context.Context, r *http.Request) (itemsResultcase strings.Contains(q.rawTypes, "ManualPlaylistsFolder"):return materialized(result([]dto.BaseItemDto{playlistsFolder()}, 1, 0)), nil}- if res, ok := api.playlistTracks(ctx, q); ok {- return res, nil+ if repo, ok := api.playlistTracksRepo(ctx, q); ok {+ return api.playlistTrackPage(repo, q.fields, q.offset, q.limit)+ }+ if q.search != "" {+ q.limit = clampLimit(q.limit, defaultSearchLimit, maxSearchLimit)}if len(q.types) == 1 {opts := model.QueryOptions{Offset: q.offset, Max: q.limit}@@ -292,32 +301,39 @@ func (api *Router) queryItems(ctx context.Context, r *http.Request) (itemsResultreturn api.mergeTypes(ctx, q)}-// playlistTracks resolves a playlist parent to its tracks, whatever IncludeItemTypes says: Jellify-// opens a playlist with ParentId=<playlist>&IncludeItemTypes=Audio, and routing that through-// listSongs would treat the playlist id as an album id and return nothing.-func (api *Router) playlistTracks(ctx context.Context, q itemsQuery) (itemsResult, bool) {+// playlistTracksRepo resolves a playlist parent, whatever IncludeItemTypes says: Jellify opens a+// playlist with ParentId=<playlist>&IncludeItemTypes=Audio, and routing that through listSongs would+// treat the playlist id as an album id and return nothing.+//+// ok is false when ParentId isn't a visible playlist, so the caller falls through to the type+// dispatch: ParentId is usually an album or artist.+func (api *Router) playlistTracksRepo(ctx context.Context, q itemsQuery) (model.PlaylistTrackRepository, bool) {if q.parentId == "" || q.isLibraryParent || q.parentId == playlistsFolderID {- return itemsResult{}, false+ return nil, false}- pls, err := api.playlists.GetWithTracks(ctx, q.parentId)- if err != nil {- return itemsResult{}, false- }- // GetWithTracks enforces visibility (public or owned by the current user).- items := slice.Map(pls.Tracks, func(t model.PlaylistTrack) dto.BaseItemDto { return trackToBaseItem(t, q.fields) })- return materialized(result(paginate(items, q.offset, q.limit), len(items), q.offset)), true+ // Tracks enforces visibility.+ repo, err := api.playlists.Tracks(ctx, q.parentId)+ return repo, err == nil}func (api *Router) mergeTypes(ctx context.Context, q itemsQuery) (itemsResult, error) {// Each per-type query needs at most offset+limit rows (the worst case where one type fills the// whole [offset, offset+limit) window). Totals are unaffected — they come from CountAll.+ window := 0+ if q.limit > 0 {+ window = q.offset + q.limit+ }+ // A search can't stream, so the window is what each type materializes and StartIndex would drive+ // it without bound. Only below the window are the merged rows the true order, hence the clip+ // below too. Non-search stays unbounded in StartIndex: a known gap, fixable with per-type counts.+ if q.search != "" {+ window = min(window, maxSearchLimit)+ }var results []itemsResulttotal := 0for _, itemType := range q.types {var opts model.QueryOptions- if q.limit > 0 {- opts.Max = q.offset + q.limit- }+ opts.Max = windowapplySort(&opts, itemType, q.sortBy, q.sortOrder)res, err := api.queryItemsOfType(ctx, itemType, opts, q)if err != nil {@@ -339,6 +355,13 @@ func (api *Router) mergeTypes(ctx context.Context, q itemsQuery) (itemsResult, e}items = append(items, typeItems...)}+ if q.search != "" {+ // Past the window the merged order isn't the true one, so drop it rather than serve another+ // type's rows. The total is what's pageable overall, not this page, or a client paging on it+ // would stop after the first page.+ items = items[:min(window, len(items))]+ total = min(total, maxSearchLimit)+ }return materialized(result(paginate(items, q.offset, q.limit), total, q.offset)), nil}@@ -412,20 +435,37 @@ func paginate(items []dto.BaseItemDto, offset, limit int) []dto.BaseItemDto {return items}+// Search can't stream (Search returns a slice), so it needs both a default and a ceiling: without+// the ceiling, Limit=999999 still materializes every match.+const (+ defaultSearchLimit = 100+ maxSearchLimit = 2000+)++// clampLimit bounds a client-supplied limit, 0 or less meaning it sent none, so it can't drive an+// oversized allocation or provider fetch (flagged by CodeQL as a user-controlled allocation size).+//+// Searches clamp their Limit here rather than in searchPage, which also sees mergeTypes' larger+// offset+limit window: bounding that would truncate each type before the merged page is cut.+func clampLimit(limit, def, ceiling int) int {+ if limit <= 0 {+ return def+ }+ return min(limit, ceiling)+}+// searchPage runs a repository Search fetching one extra row to derive TotalRecordCount, since the// Search API returns no match count and CountAll can't see the search term. offset+len(rows) is// exact once matches end (and a growing lower bound before), so paging terminates at the last match.func searchPage[S ~[]E, E any](opts model.QueryOptions, search func(model.QueryOptions) (S, error)) (S, int, error) {fetch := opts- if fetch.Max > 0 {- fetch.Max++- }+ fetch.Max++rows, err := search(fetch)if err != nil {return nil, 0, err}total := opts.Offset + len(rows)- if opts.Max > 0 && len(rows) > opts.Max {+ if len(rows) > opts.Max {rows = rows[:opts.Max]}return rows, total, nildiff --git a/server/jellyfin/items_test.go b/server/jellyfin/items_test.goindex 801db9e3a..049151651 100644--- a/server/jellyfin/items_test.go+++ b/server/jellyfin/items_test.go@@ -3,6 +3,7 @@ package jellyfinimport ("context""encoding/json"+ "fmt""net/http""net/http/httptest"@@ -71,6 +72,59 @@ var _ = Describe("Items", func() {Expect(res.Items[0].Id).To(Equal(dto.EncodeID("s1")))})+ It("lists a playlist's tracks when ParentId is a playlist, whatever the type", func() {+ fp.getPls = &model.Playlist{ID: "pl1", Tracks: model.PlaylistTracks{+ {ID: "1", MediaFileID: "s1", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s1"}},+ {ID: "2", MediaFileID: "s2", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s2"}},+ }}+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?ParentId="+dto.EncodeID("pl1")+"&IncludeItemTypes=Audio", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).To(HaveLen(2))+ Expect(res.Items[0].Id).To(Equal(dto.EncodeID("s1")))+ Expect(res.Items[0].PlaylistItemId).To(Equal(dto.EncodeID("1")))+ Expect(res.TotalRecordCount).To(Equal(2))+ })++ It("pages a playlist parent's tracks in the query, not in memory", func() {+ fp.getPls = &model.Playlist{ID: "pl1", Tracks: model.PlaylistTracks{+ {ID: "1", MediaFileID: "s1", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s1"}},+ {ID: "2", MediaFileID: "s2", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s2"}},+ {ID: "3", MediaFileID: "s3", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s3"}},+ }}+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?ParentId="+dto.EncodeID("pl1")+"&StartIndex=1&Limit=1", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.TotalRecordCount).To(Equal(3))+ Expect(res.Items).To(HaveLen(1))+ Expect(res.Items[0].Id).To(Equal(dto.EncodeID("s2")))+ Expect(fp.tracksRepo.Options.Offset).To(Equal(1))+ Expect(fp.tracksRepo.Options.Max).To(Equal(1))+ })++ It("falls through to the type dispatch when ParentId is not a playlist", func() {+ fp.getErr = model.ErrNotFound+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{{ID: "s1", AlbumID: "a1"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?ParentId="+dto.EncodeID("a1")+"&IncludeItemTypes=Audio", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).To(HaveLen(1))+ Expect(res.Items[0].Id).To(Equal(dto.EncodeID("s1")))+ })+It("returns 500 when the song cursor fails to open, instead of a truncated 200", func() {ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetError(true)w := httptest.NewRecorder()@@ -220,6 +274,160 @@ var _ = Describe("Items", func() {Expect(res.Items).To(HaveLen(1))})+ It("caps a search the client left unbounded", func() {+ albumRepo := ds.Album(context.Background()).(*tests.MockAlbumRepo)+ albumRepo.SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=MusicAlbum&SearchTerm=one", nil).WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(albumRepo.Options.Max).To(Equal(defaultSearchLimit + 1))+ })++ It("honors an explicit search Limit up to the ceiling", func() {+ albumRepo := ds.Album(context.Background()).(*tests.MockAlbumRepo)+ albumRepo.SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=MusicAlbum&SearchTerm=one&Limit=500", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(albumRepo.Options.Max).To(Equal(501))+ })++ It("clamps a search Limit that would materialize the library", func() {+ albumRepo := ds.Album(context.Background()).(*tests.MockAlbumRepo)+ albumRepo.SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=MusicAlbum&SearchTerm=one&Limit=999999", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(albumRepo.Options.Max).To(Equal(maxSearchLimit + 1))+ })++ It("treats an all-whitespace SearchTerm as no search, streaming the unfiltered list", func() {+ albumRepo := ds.Album(context.Background()).(*tests.MockAlbumRepo)+ albumRepo.SetData(model.Albums{{ID: "a1", Name: "One"}, {ID: "a2", Name: "Two"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=MusicAlbum&SearchTerm=%20%20", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).To(HaveLen(2))+ Expect(albumRepo.SearchQuery).To(BeEmpty())+ })++ It("reports a multi-type search total past the page, so clients keep paging", func() {+ songs := make(model.MediaFiles, defaultSearchLimit*2)+ for i := range songs {+ songs[i] = model.MediaFile{ID: fmt.Sprintf("s%05d", i), Title: "Song"}+ }+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(songs)+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=Audio,MusicAlbum&SearchTerm=song&Limit=10", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).To(HaveLen(10))+ Expect(res.TotalRecordCount).To(BeNumerically(">", 10))+ })++ It("bounds the multi-type search window however large StartIndex is", func() {+ albumRepo := ds.Album(context.Background()).(*tests.MockAlbumRepo)+ albumRepo.SetData(model.Albums{{ID: "a1", Name: "One"}})+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{{ID: "s1", Title: "Song"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=Audio,MusicAlbum&SearchTerm=song&StartIndex=500000&Limit=1", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ // Without the bound this asks each type for ~500001 rows.+ Expect(albumRepo.Options.Max).To(Equal(maxSearchLimit + 1))+ })++ It("stops a multi-type search at the ceiling rather than serving another type's rows", func() {+ // Bounding the per-type window is what keeps StartIndex from driving it without limit, and+ // past that window the merged order is no longer the true one.+ songs := make(model.MediaFiles, maxSearchLimit+1)+ for i := range songs {+ songs[i] = model.MediaFile{ID: fmt.Sprintf("s%05d", i), Title: "Song"}+ }+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(songs)+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET",+ fmt.Sprintf("/Items?IncludeItemTypes=Audio,MusicAlbum&SearchTerm=song&StartIndex=%d&Limit=1", maxSearchLimit),+ nil).WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).To(BeEmpty())+ Expect(res.TotalRecordCount).To(Equal(maxSearchLimit))+ })++ It("serves the last page below the ceiling in full", func() {+ songs := make(model.MediaFiles, maxSearchLimit+1)+ for i := range songs {+ songs[i] = model.MediaFile{ID: fmt.Sprintf("s%05d", i), Title: "Song"}+ }+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(songs)+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET",+ fmt.Sprintf("/Items?IncludeItemTypes=Audio,MusicAlbum&SearchTerm=song&StartIndex=%d&Limit=10", maxSearchLimit-1),+ nil).WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ // Clipped to the window, and still the real row at that index — not the album behind it.+ Expect(res.Items).To(HaveLen(1))+ Expect(res.Items[0].Id).To(Equal(dto.EncodeID(songs[maxSearchLimit-1].ID)))+ })++ It("bounds an unbounded multi-type search to the default in total, not per type", func() {+ songs := make(model.MediaFiles, defaultSearchLimit*2)+ for i := range songs {+ songs[i] = model.MediaFile{ID: fmt.Sprintf("s%05d", i), Title: "Song"}+ }+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(songs)+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items?IncludeItemTypes=Audio,MusicAlbum&SearchTerm=song", nil).+ WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).To(HaveLen(defaultSearchLimit))+ })++ It("pages an unbounded multi-type search past the default without dropping matches", func() {+ songs := make(model.MediaFiles, defaultSearchLimit*2)+ for i := range songs {+ songs[i] = model.MediaFile{ID: fmt.Sprintf("s%05d", i), Title: "Song"}+ }+ ds.MediaFile(context.Background()).(*tests.MockMediaFileRepo).SetData(songs)+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET",+ fmt.Sprintf("/Items?IncludeItemTypes=Audio,MusicAlbum&SearchTerm=song&StartIndex=%d", defaultSearchLimit+50),+ nil).WithContext(ctxUser())+ invoke(api.getItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.Items).ToNot(BeEmpty())+ Expect(res.Items[0].Id).To(Equal(dto.EncodeID(songs[defaultSearchLimit+50].ID)))+ })+It("reports a search total beyond the fetched page instead of the page length", func() {ds.Artist(context.Background()).(*tests.MockArtistRepo).SetData(model.Artists{{ID: "r1", Name: "Alpha"}, {ID: "r2", Name: "Beta"}, {ID: "r3", Name: "Gamma"},diff --git a/server/jellyfin/playlists.go b/server/jellyfin/playlists.goindex ffc2c6543..a157aae2e 100644--- a/server/jellyfin/playlists.go+++ b/server/jellyfin/playlists.go@@ -125,6 +125,21 @@ func (api *Router) clearPlaylist(ctx context.Context, id string) error {return api.playlists.RemoveTracks(ctx, id, entryIDs)}+// playlistTrackPage streams one page of a playlist's tracks. Streams because a playlist can be the+// whole library (a smart playlist matching everything) and clients may omit Limit. Excludes missing+// tracks, and counts the same set, like GetWithTracks.+func (api *Router) playlistTrackPage(repo model.PlaylistTrackRepository, fields dto.Fields, offset, limit int) (itemsResult, error) {+ total, err := repo.CountAll(model.QueryOptions{Filters: notMissing})+ if err != nil {+ return itemsResult{}, err+ }+ opts := model.QueryOptions{Sort: "id", Offset: offset, Max: limit, Filters: notMissing}+ open := streamCursor(func() (func(func(model.PlaylistTrack, error) bool), error) {+ return repo.GetCursor(opts)+ }, func(t model.PlaylistTrack) dto.BaseItemDto { return trackToBaseItem(t, fields) })+ return streamed(open, int(total), offset), nil+}+// trackToBaseItem maps a playlist entry to a BaseItemDto, tagging it with PlaylistItemId (the// entry's id, model.PlaylistTrack.ID, not the song id). Clients echo it back via// DELETE .../Items?EntryIds= to remove a specific occurrence, so duplicates of the same song remain@@ -136,17 +151,28 @@ func trackToBaseItem(t model.PlaylistTrack, fields dto.Fields) dto.BaseItemDto {}// getPlaylist returns a playlist's visibility flag and item ids (Finamp reads OpenAccess before the-// edit screen). GetWithTracks enforces visibility; any error maps to 404 so private playlists can't+// edit screen). Get and Tracks enforce visibility; any error maps to 404 so private playlists can't// be probed.func (api *Router) getPlaylist(w http.ResponseWriter, r *http.Request) {ctx := r.Context()id := dto.DecodeID(chi.URLParam(r, "playlistId"))- pls, err := api.playlists.GetWithTracks(ctx, id)+ pls, err := api.playlists.Get(ctx, id)+ if err != nil {+ http.Error(w, "Not Found", http.StatusNotFound)+ return+ }+ repo, err := api.playlists.Tracks(ctx, id)if err != nil {http.Error(w, "Not Found", http.StatusNotFound)return}- itemIds := slice.Map(pls.Tracks, func(t model.PlaylistTrack) string { return dto.EncodeID(t.MediaFileID) })+ // PlaylistInfo carries every track id, so this can't be paged — but it needs no track data.+ trackIDs, err := repo.GetMediaFileIDs(model.QueryOptions{Sort: "id", Filters: notMissing})+ if err != nil {+ api.internalError(w, r, err)+ return+ }+ itemIds := slice.Map(trackIDs, dto.EncodeID)api.ok(w, r, dto.PlaylistInfo{OpenAccess: pls.Public,Shares: []dto.PlaylistUserPermissions{},@@ -154,19 +180,24 @@ func (api *Router) getPlaylist(w http.ResponseWriter, r *http.Request) {})}-// getPlaylistItems relies on GetWithTracks to enforce visibility; any error maps to a generic 404 so-// a playlist id can't probe for private playlists.+// getPlaylistItems relies on Tracks to enforce visibility; any error maps to a generic 404 so a+// playlist id can't probe for private playlists.func (api *Router) getPlaylistItems(w http.ResponseWriter, r *http.Request) {ctx := r.Context()id := dto.DecodeID(chi.URLParam(r, "playlistId"))- pls, err := api.playlists.GetWithTracks(ctx, id)+ repo, err := api.playlists.Tracks(ctx, id)if err != nil {http.Error(w, "Not Found", http.StatusNotFound)return}- fields := dto.ParseFields(req.Params(r).StringOr("fields", ""))- items := slice.Map(pls.Tracks, func(t model.PlaylistTrack) dto.BaseItemDto { return trackToBaseItem(t, fields) })- api.ok(w, r, dto.QueryResult{Items: items, TotalRecordCount: len(items)})+ p := req.Params(r)+ fields := dto.ParseFields(p.StringOr("fields", ""))+ res, err := api.playlistTrackPage(repo, fields, p.IntOr("startindex", 0), p.IntOr("limit", 0))+ if err != nil {+ api.internalError(w, r, err)+ return+ }+ api.ok(w, r, res)}// queryIDs reads an id-list query param that clients spell two ways: comma-separated in a singlediff --git a/server/jellyfin/playlists_test.go b/server/jellyfin/playlists_test.goindex 804123003..27264b280 100644--- a/server/jellyfin/playlists_test.go+++ b/server/jellyfin/playlists_test.go@@ -29,8 +29,9 @@ type fakePlaylists struct {createdIds []stringcreateErr error- getPls *model.Playlist- getErr error+ getPls *model.Playlist+ getErr error+ tracksRepo *tests.MockPlaylistTrackRepogetByIDPls *model.PlaylistgetByIDErr error@@ -92,6 +93,20 @@ func (f *fakePlaylists) GetWithTracks(_ context.Context, _ string) (*model.Playlreturn f.getPls, nil}+// Tracks serves the same getPls fixture as GetWithTracks. tracksRepo is kept so tests can assert+// what was pushed down to the query.+func (f *fakePlaylists) Tracks(_ context.Context, _ string) (model.PlaylistTrackRepository, error) {+ if f.getErr != nil {+ return nil, f.getErr+ }+ if f.getPls == nil {+ return nil, model.ErrNotFound+ }+ f.tracksRepo = &tests.MockPlaylistTrackRepo{}+ f.tracksRepo.SetData(f.getPls.Tracks)+ return f.tracksRepo, nil+}+func (f *fakePlaylists) AddTracks(_ context.Context, playlistID string, ids []string) (int, error) {f.addPlaylistID = playlistIDf.addIds = ids@@ -184,6 +199,30 @@ var _ = Describe("Playlists", func() {Expect(res.Items[1].PlaylistItemId).To(Equal(dto.EncodeID("2")))})+ It("pages with StartIndex/Limit, pushing them down to the query", func() {+ fp.getPls = &model.Playlist{+ ID: "pl1",+ Tracks: model.PlaylistTracks{+ {ID: "1", MediaFileID: "s1", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s1"}},+ {ID: "2", MediaFileID: "s2", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s2"}},+ {ID: "3", MediaFileID: "s3", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s3"}},+ },+ }+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Playlists/pl1/Items?StartIndex=1&Limit=1", nil).+ WithContext(context.Background())+ r = withChiURLParam(r, "playlistId", "pl1")+ invoke(api.getPlaylistItems, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ var res dto.QueryResult+ Expect(json.Unmarshal(w.Body.Bytes(), &res)).To(Succeed())+ Expect(res.TotalRecordCount).To(Equal(3))+ Expect(res.Items).To(HaveLen(1))+ Expect(res.Items[0].Id).To(Equal(dto.EncodeID("s2")))+ Expect(fp.tracksRepo.Options.Offset).To(Equal(1))+ Expect(fp.tracksRepo.Options.Max).To(Equal(1))+ })+It("returns 404 for a non-owned or absent playlist", func() {fp.getErr = model.ErrNotFoundw := httptest.NewRecorder()@@ -247,7 +286,7 @@ var _ = Describe("Playlists", func() {Describe("getPlaylist", func() {It("returns OpenAccess from Public and item ids (encoded media file ids, not entry ids)", func() {- fp.getPls = &model.Playlist{+ pls := &model.Playlist{ID: "pl1",Public: true,Tracks: model.PlaylistTracks{@@ -255,6 +294,7 @@ var _ = Describe("Playlists", func() {{ID: "2", MediaFileID: "s2", PlaylistID: "pl1", MediaFile: model.MediaFile{ID: "s2"}},},}+ fp.getPls, fp.getByIDPls = pls, plsw := httptest.NewRecorder()r := httptest.NewRequest("GET", "/Playlists/pl1", nil).WithContext(context.Background())r = withChiURLParam(r, "playlistId", "pl1")diff --git a/server/jellyfin/similar.go b/server/jellyfin/similar.goindex db3671fe4..33cdc4c88 100644--- a/server/jellyfin/similar.go+++ b/server/jellyfin/similar.go@@ -20,7 +20,10 @@ import (// tests can shorten it.var similarWait = 10 * time.Second-const maxSimilarLimit = 100+const (+ defaultSimilarLimit = 20+ maxSimilarLimit = 100+)// similarFetchTimeout bounds the detached background fetch so a hung provider can't hold a goroutine// indefinitely.@@ -51,7 +54,7 @@ func (api *Router) awaitSimilar(ctx context.Context, id string, limit int, fetch// returned. Any provider error degrades to an empty result, not a 404 the client would keep retrying.func (api *Router) getSimilarArtists(w http.ResponseWriter, r *http.Request) {id := api.resolveItemID(r.Context(), dto.DecodeID(chi.URLParam(r, "itemId")))- limit := clampLimit(req.Params(r).IntOr("limit", 20))+ limit := clampLimit(req.Params(r).IntOr("limit", 0), defaultSimilarLimit, maxSimilarLimit)api.ok(w, r, api.awaitSimilar(r.Context(), id, limit, func(ctx context.Context) dto.QueryResult {return api.similarArtists(ctx, id, limit)}))@@ -63,7 +66,7 @@ func (api *Router) getSimilarArtists(w http.ResponseWriter, r *http.Request) {func (api *Router) getSimilarItems(w http.ResponseWriter, r *http.Request) {ctx := r.Context()id := api.resolveItemID(ctx, dto.DecodeID(chi.URLParam(r, "itemId")))- limit := clampLimit(req.Params(r).IntOr("limit", 20))+ limit := clampLimit(req.Params(r).IntOr("limit", 0), defaultSimilarLimit, maxSimilarLimit)entity, err := model.GetEntityByID(ctx, api.ds, id)if err != nil {@@ -88,7 +91,7 @@ func (api *Router) getSimilarItems(w http.ResponseWriter, r *http.Request) {func (api *Router) getInstantMix(w http.ResponseWriter, r *http.Request) {ctx := r.Context()id := api.resolveItemID(ctx, dto.DecodeID(chi.URLParam(r, "itemId")))- limit := clampLimit(req.Params(r).IntOr("limit", 20))+ limit := clampLimit(req.Params(r).IntOr("limit", 0), defaultSimilarLimit, maxSimilarLimit)entity, err := model.GetEntityByID(ctx, api.ds, id)if err != nil {@@ -136,15 +139,6 @@ func (api *Router) similarArtists(ctx context.Context, id string, limit int) dtoreturn result(items, len(items), 0)}-// clampLimit bounds a client-supplied limit so it can't drive an oversized allocation or provider-// fetch (flagged by CodeQL as a user-controlled allocation size).-func clampLimit(limit int) int {- if limit <= 0 {- return 20- }- return min(limit, maxSimilarLimit)-}-func (api *Router) similarSongs(ctx context.Context, id string, limit int) dto.QueryResult {songs, err := api.provider.SimilarSongs(ctx, id, limit)if err != nil {diff --git a/tests/mock_album_repo.go b/tests/mock_album_repo.goindex 6635881b7..03dfed879 100644--- a/tests/mock_album_repo.go+++ b/tests/mock_album_repo.go@@ -20,6 +20,7 @@ type MockAlbumRepo struct {All model.AlbumsErr boolOptions model.QueryOptions+ SearchQuery string // last query passed to SearchReassignAnnotationCalls map[string]string // prevID -> newIDCopyAttributesCalls map[string]string // fromID -> toID}@@ -134,6 +135,7 @@ func (m *MockAlbumRepo) UpdateExternalInfo(album *model.Album) error {}func (m *MockAlbumRepo) Search(q string, options ...model.QueryOptions) (model.Albums, error) {+ m.SearchQuery = qif len(options) > 0 {m.Options = options[0]}diff --git a/tests/mock_playlist_track_repo.go b/tests/mock_playlist_track_repo.goindex c11b077d2..2835baadd 100644--- a/tests/mock_playlist_track_repo.go+++ b/tests/mock_playlist_track_repo.go@@ -1,9 +1,14 @@package tests-import "github.com/navidrome/navidrome/model"+import (+ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/utils/slice"+)type MockPlaylistTrackRepo struct {model.PlaylistTrackRepository+ Data model.PlaylistTracks+ Options model.QueryOptionsAddedIds []stringDeletedIds []stringReordered bool@@ -11,6 +16,63 @@ type MockPlaylistTrackRepo struct {Err error}+func (m *MockPlaylistTrackRepo) SetData(tracks model.PlaylistTracks) {+ m.Data = tracks+}++// page applies Max/Offset as the real repository's SQL would.+func (m *MockPlaylistTrackRepo) page(options ...model.QueryOptions) model.PlaylistTracks {+ var opts model.QueryOptions+ if len(options) > 0 {+ opts = options[0]+ m.Options = opts+ }+ tracks := m.Data+ if opts.Offset >= len(tracks) {+ return nil+ }+ tracks = tracks[opts.Offset:]+ if opts.Max > 0 && opts.Max < len(tracks) {+ tracks = tracks[:opts.Max]+ }+ return tracks+}++func (m *MockPlaylistTrackRepo) CountAll(_ ...model.QueryOptions) (int64, error) {+ if m.Err != nil {+ return 0, m.Err+ }+ return int64(len(m.Data)), nil+}++func (m *MockPlaylistTrackRepo) GetAll(options ...model.QueryOptions) (model.PlaylistTracks, error) {+ if m.Err != nil {+ return nil, m.Err+ }+ return m.page(options...), nil+}++func (m *MockPlaylistTrackRepo) GetCursor(options ...model.QueryOptions) (model.PlaylistTrackCursor, error) {+ if m.Err != nil {+ return nil, m.Err+ }+ tracks := m.page(options...)+ return func(yield func(model.PlaylistTrack, error) bool) {+ for _, t := range tracks {+ if !yield(t, nil) {+ return+ }+ }+ }, nil+}++func (m *MockPlaylistTrackRepo) GetMediaFileIDs(options ...model.QueryOptions) ([]string, error) {+ if m.Err != nil {+ return nil, m.Err+ }+ return slice.Map(m.page(options...), func(t model.PlaylistTrack) string { return t.MediaFileID }), nil+}+func (m *MockPlaylistTrackRepo) Add(ids []string) (int, error) {m.AddedIds = append(m.AddedIds, ids...)if m.Err != nil {