🎧 Your Personal Streaming Service
Go airsonicmadsonicmedia-servermusicmusic-servernavidromeopensubsonicraspberry-piself-hostedstreamerstreaming-apistreaming-audiosubsonicsubsonic-server
feat(jellyfin): filter items by year and record label (#5817)
Deluan Quintão5927e693d128
diff --git a/model/album.go b/model/album.goindex 16727ea39..0afeb2760 100644--- a/model/album.go+++ b/model/album.go@@ -144,6 +144,7 @@ type AlbumRepository interface {Get(id string) (*Album, error)GetAll(...QueryOptions) (Albums, error)GetCursor(...QueryOptions) (AlbumCursor, error)+ GetYears(libraryIDs ...int) ([]int, error)// The following methods are used exclusively by the scanner:Touch(ids ...string) errordiff --git a/model/tag.go b/model/tag.goindex 02ccac05d..1bc011495 100644--- a/model/tag.go+++ b/model/tag.go@@ -153,6 +153,7 @@ func (t Tags) Add(name TagName, v string) {type TagRepository interface {Add(libraryID int, tags ...Tag) errorUpdateCounts() error+ GetAll(name TagName, options ...QueryOptions) (TagList, error)}type TagName stringdiff --git a/persistence/album_repository.go b/persistence/album_repository.goindex 53e8efe32..2bb541003 100644--- a/persistence/album_repository.go+++ b/persistence/album_repository.go@@ -3,6 +3,7 @@ package persistenceimport ("context""encoding/json"+ "errors""fmt""iter""maps"@@ -262,6 +263,20 @@ func (r *albumRepository) GetCursor(options ...model.QueryOptions) (model.AlbumCreturn wrapAlbumCursor(cursor), nil}+func (r *albumRepository) GetYears(libraryIDs ...int) ([]int, error) {+ cond := And{Gt{"max_year": 0}, Eq{"missing": false}}+ if len(libraryIDs) > 0 {+ cond = append(cond, Eq{"library_id": libraryIDs})+ }+ sq := r.applyLibraryFilter(Select("distinct max_year").From("album").Where(cond).OrderBy("max_year"))+ years := []int{}+ err := r.queryAllSlice(sq, &years)+ if err != nil && !errors.Is(err, model.ErrNotFound) {+ return nil, err+ }+ return years, nil+}+func (r *albumRepository) CopyAttributes(fromID, toID string, columns ...string) error {var from dbx.NullStringMaperr := r.queryOne(Select(columns...).From(r.tableName).Where(Eq{"id": fromID}), &from)diff --git a/persistence/album_repository_test.go b/persistence/album_repository_test.goindex 761255b7d..465617b10 100644--- a/persistence/album_repository_test.go+++ b/persistence/album_repository_test.go@@ -3,6 +3,7 @@ package persistenceimport ("errors""fmt"+ "sort""time""github.com/Masterminds/squirrel"@@ -851,6 +852,65 @@ var _ = Describe("AlbumRepository", func() {})})+ Describe("GetYears", func() {+ It("returns distinct album years ascending, excluding zero", func() {+ years, err := albumRepo.GetYears()+ Expect(err).ToNot(HaveOccurred())+ // Sorted ascending, no duplicates, no zero-year entries.+ Expect(sort.IsSorted(sort.IntSlice(years))).To(BeTrue())+ Expect(years).ToNot(ContainElement(0))+ for i := 1; i < len(years); i++ {+ Expect(years[i]).To(BeNumerically(">", years[i-1])) // strictly increasing = distinct+ }+ })++ It("deduplicates repeated years", func() {+ // Regression test: verify that DISTINCT is applied in the SQL.+ // Insert two albums with the same non-zero max_year (2005).+ album1 := &model.Album{LibraryID: 1, ID: "dedup-test-1", Name: "Album 1", MaxYear: 2005}+ album2 := &model.Album{LibraryID: 1, ID: "dedup-test-2", Name: "Album 2", MaxYear: 2005}+ Expect(albumRepo.Put(album1)).To(Succeed())+ Expect(albumRepo.Put(album2)).To(Succeed())+ DeferCleanup(func() {+ _, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": []string{"dedup-test-1", "dedup-test-2"}}))+ })++ years, err := albumRepo.GetYears()+ Expect(err).ToNot(HaveOccurred())++ // Count occurrences of 2005 in the result+ count := 0+ for _, y := range years {+ if y == 2005 {+ count+++ }+ }+ Expect(count).To(Equal(1), "year 2005 should appear exactly once despite two albums having it")+ })++ It("scopes years to the given libraries", func() {+ all, err := albumRepo.GetYears()+ Expect(err).ToNot(HaveOccurred())+ // A library with no albums yields no years.+ scoped, err := albumRepo.GetYears(99999)+ Expect(err).ToNot(HaveOccurred())+ Expect(scoped).To(BeEmpty())+ Expect(all).ToNot(BeEmpty())+ })++ It("excludes years that belong only to missing albums", func() {+ gone := &model.Album{LibraryID: 1, ID: "missing-year-1", Name: "Gone", MaxYear: 1911, Missing: true}+ Expect(albumRepo.Put(gone)).To(Succeed())+ DeferCleanup(func() {+ _, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": "missing-year-1"}))+ })++ years, err := albumRepo.GetYears()+ Expect(err).ToNot(HaveOccurred())+ Expect(years).ToNot(ContainElement(1911))+ })+ })+Describe("wrapAlbumCursor", func() {It("does not panic when the cursor yields a dbAlbum with nil Album", func() {// Simulate what queryWithStableResults does on the rows.Err() path:diff --git a/persistence/tag_repository.go b/persistence/tag_repository.goindex 5bb8b3832..f2093c9d8 100644--- a/persistence/tag_repository.go+++ b/persistence/tag_repository.go@@ -74,13 +74,20 @@ DO UPDATE SET %[1]s_count = excluded.%[1]s_count;return nil}+func (r *tagRepository) GetAll(name model.TagName, options ...model.QueryOptions) (model.TagList, error) {+ sq := r.newSelect(options...).Where(Eq{"tag.tag_name": name})+ res := model.TagList{}+ err := r.queryAll(sq, &res)+ return res, err+}+func (r *tagRepository) purgeUnused() error {- del := Delete(r.tableName).Where(`+ del := Delete(r.tableName).Where(`id not in (select jt.valuefrom album left join json_tree(album.tags, '$') as jtwhere atom is not nulland key = 'id'- UNION+ UNIONselect jt.valuefrom media_file left join json_tree(media_file.tags, '$') as jtwhere atom is not nulldiff --git a/server/filter/filters.go b/server/filter/filters.goindex 5fa53daba..067f7b1f9 100644--- a/server/filter/filters.go+++ b/server/filter/filters.go@@ -194,6 +194,16 @@ func ByAlbumID(albumIds []string) Sqlizer {return Eq{"album_id": albumIds}}+// AlbumsByYears matches albums whose production year (max_year) is in years.+func AlbumsByYears(years []int) Sqlizer {+ return Eq{"max_year": years}+}++// SongsByYears matches media files whose year is in years.+func SongsByYears(years []int) Sqlizer {+ return Eq{"year": years}+}+// ArtistsByGenreID matches artists credited as album artist on an album with any of the given// genre tag ids. Non-correlated semi-join: the correlated EXISTS form rescans albums per artist row.func ArtistsByGenreID(genreIds []string) Sqlizer {@@ -204,10 +214,17 @@ func ArtistsByGenreID(genreIds []string) Sqlizer {)}-// genreTagFilter builds an EXISTS over the genre entries in the tags JSON, matching each entry-// against cond (its name via Like, or its tag id via Eq/IN). Shared by the name- and id-based lookups.-func genreTagFilter(cond Sqlizer) Sqlizer {- return persistence.Exists(`json_tree(tags, "$.genre")`, And{NotEq{"atom": nil}, cond})+// tagIDFilter builds an EXISTS over the given tag role's entries in the tags JSON, matching each+// entry against cond (its name via Like, or its tag id via Eq/IN).+func tagIDFilter(tagName string, cond Sqlizer) Sqlizer {+ return persistence.Exists(`json_tree(tags, "$.`+tagName+`")`, And{NotEq{"atom": nil}, cond})+}++func genreTagFilter(cond Sqlizer) Sqlizer { return tagIDFilter("genre", cond) }++// ByStudioID matches items (albums or songs) whose record-label tag id is in ids.+func ByStudioID(ids []string) Sqlizer {+ return tagIDFilter("recordlabel", Eq{"value": ids})}func filterByGenre(genre string) Sqlizer {diff --git a/server/jellyfin/api.go b/server/jellyfin/api.goindex 0f79011c7..1f46c08b4 100644--- a/server/jellyfin/api.go+++ b/server/jellyfin/api.go@@ -146,6 +146,8 @@ func (api *Router) routes() http.Handler {r.Get("/items/{itemId}/instantmix", api.getInstantMix)r.Get("/genres", api.getGenres)r.Get("/musicgenres", api.getGenres)+ r.Get("/studios", api.getStudios)+ r.Get("/items/filters", api.getQueryFiltersLegacy)r.Post("/playlists", api.createPlaylist)r.Get("/playlists/{playlistId}", api.getPlaylist)diff --git a/server/jellyfin/browsing.go b/server/jellyfin/browsing.goindex fae21fc0b..29fe48c2b 100644--- a/server/jellyfin/browsing.go+++ b/server/jellyfin/browsing.go@@ -6,6 +6,7 @@ import ("github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/server/jellyfin/dto""github.com/navidrome/navidrome/utils/req"+ "github.com/navidrome/navidrome/utils/slice")// getArtists handles GET /Artists (performing artists, Finamp's "Artists" tab); getAlbumArtists@@ -27,7 +28,7 @@ func (api *Router) listArtistsByRole(w http.ResponseWriter, r *http.Request, rolopts := model.QueryOptions{Offset: p.IntOr("startindex", 0), Max: p.IntOr("limit", 0)}applySort(&opts, "MusicArtist", p.StringOr("sortby", ""), p.StringOr("sortorder", ""))- scopeIDs, _ := resolveLibraryScope(ctx, dto.DecodeID(p.StringOr("parentid", "")))+ scopeIDs, _ := parentIDScope(ctx, r)// Only the fields listArtists reads; /Artists has no favorites filter, so favOnly stays false.// Finamp's artist tab sends GenreIds when a genre filter is active.q := itemsQuery{@@ -59,3 +60,44 @@ func (api *Router) getGenres(w http.ResponseWriter, r *http.Request) {}api.ok(w, r, res)}++// getStudios handles GET /Studios, exposing record labels (Jellyfin's audio "studio" source) as+// Studio items, scoped to ParentId's library when accessible.+func (api *Router) getStudios(w http.ResponseWriter, r *http.Request) {+ ctx := r.Context()+ p := req.Params(r)+ scope, _ := parentIDScope(ctx, r)+ opts := model.QueryOptions{Sort: "tag_value", Filters: libraryScopeFilter(scope)}+ labels, err := api.ds.Tag(ctx).GetAll(model.TagRecordLabel, opts)+ if err != nil {+ api.internalError(w, r, err)+ return+ }+ items := slice.Map(labels, dto.StudioToBaseItem)+ offset, max := p.IntOr("startindex", 0), p.IntOr("limit", 0)+ api.ok(w, r, result(paginate(items, offset, max), len(items), offset))+}++// getQueryFiltersLegacy handles GET /Items/Filters. Genres and Years are scoped to ParentId's+// library when accessible. Tags/OfficialRatings have no music source, so they are always empty.+func (api *Router) getQueryFiltersLegacy(w http.ResponseWriter, r *http.Request) {+ ctx := r.Context()+ scope, _ := parentIDScope(ctx, r)+ genreOpts := model.QueryOptions{Sort: "name", Filters: libraryScopeFilter(scope)}+ genres, err := api.ds.Genre(ctx).GetAll(genreOpts)+ if err != nil {+ api.internalError(w, r, err)+ return+ }+ years, err := api.ds.Album(ctx).GetYears(scope...)+ if err != nil {+ api.internalError(w, r, err)+ return+ }+ api.ok(w, r, dto.QueryFiltersLegacy{+ Genres: slice.Map(genres, func(g model.Genre) string { return g.Name }),+ Tags: []string{},+ OfficialRatings: []string{},+ Years: years,+ })+}diff --git a/server/jellyfin/browsing_test.go b/server/jellyfin/browsing_test.goindex 660e5d293..e346b56cb 100644--- a/server/jellyfin/browsing_test.go+++ b/server/jellyfin/browsing_test.go@@ -175,4 +175,52 @@ var _ = Describe("Browsing", func() {Expect(w.Code).To(Equal(http.StatusOK))})})++ Describe("getStudios", func() {+ It("scopes results to the user's accessible libraries", func() {+ tagRepo := ds.Tag(context.Background()).(*tests.MockTagRepo)+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Studios", nil).WithContext(ctxUser(model.Libraries{{ID: 1}, {ID: 2}}))+ invoke(api.getStudios, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ sql, args, err := tagRepo.Options.Filters.ToSql()+ Expect(err).NotTo(HaveOccurred())+ Expect(sql).To(ContainSubstring("library_tag.library_id"))+ Expect(args).To(ContainElements(1, 2))+ })++ // An empty scope (admin, or a non-admin with no explicit library grants) must be treated+ // as unrestricted, matching accessibleLibraryIDs' documented contract, not as "match nothing".+ It("does not restrict results for an admin user", func() {+ tagRepo := ds.Tag(context.Background()).(*tests.MockTagRepo)+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Studios", nil).WithContext(ctxAdmin())+ invoke(api.getStudios, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(tagRepo.Options.Filters).To(BeNil())+ })+ })++ Describe("getQueryFiltersLegacy", func() {+ It("scopes genres to the user's accessible libraries", func() {+ genreRepo := ds.Genre(context.Background()).(*tests.MockedGenreRepo)+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items/Filters", nil).WithContext(ctxUser(model.Libraries{{ID: 1}, {ID: 2}}))+ invoke(api.getQueryFiltersLegacy, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ sql, args, err := genreRepo.Options.Filters.ToSql()+ Expect(err).NotTo(HaveOccurred())+ Expect(sql).To(ContainSubstring("library_tag.library_id"))+ Expect(args).To(ContainElements(1, 2))+ })++ It("does not restrict genres for an admin user", func() {+ genreRepo := ds.Genre(context.Background()).(*tests.MockedGenreRepo)+ w := httptest.NewRecorder()+ r := httptest.NewRequest("GET", "/Items/Filters", nil).WithContext(ctxAdmin())+ invoke(api.getQueryFiltersLegacy, w, r)+ Expect(w.Code).To(Equal(http.StatusOK))+ Expect(genreRepo.Options.Filters).To(BeNil())+ })+ })})diff --git a/server/jellyfin/dto/dto.go b/server/jellyfin/dto/dto.goindex c8f7129cb..9b2c35c69 100644--- a/server/jellyfin/dto/dto.go+++ b/server/jellyfin/dto/dto.go@@ -71,6 +71,7 @@ type BaseItemDto struct {ArtistItems []NameGuidPair `json:"ArtistItems,omitempty"`Genres []string `json:"Genres,omitempty"`GenreItems []NameGuidPair `json:"GenreItems,omitempty"`+ Studios []NameGuidPair `json:"Studios,omitempty"`NormalizationGain *float64 `json:"NormalizationGain,omitempty"`AlbumNormalizationGain *float64 `json:"AlbumNormalizationGain,omitempty"`ChildCount *int `json:"ChildCount,omitempty"`@@ -288,3 +289,12 @@ type LyricLineCue struct {Start int64 `json:"Start"`End *int64 `json:"End,omitempty"`}++// QueryFiltersLegacy is the response for GET /Items/Filters. All four lists are always present;+// clients (jellyfin-web) render each unconditionally.+type QueryFiltersLegacy struct {+ Genres []string `json:"Genres"`+ Tags []string `json:"Tags"`+ OfficialRatings []string `json:"OfficialRatings"`+ Years []int `json:"Years"`+}diff --git a/server/jellyfin/dto/filters_test.go b/server/jellyfin/dto/filters_test.gonew file mode 100644index 000000000..ad3367264--- /dev/null+++ b/server/jellyfin/dto/filters_test.go@@ -0,0 +1,22 @@+package dto++import (+ "encoding/json"++ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("QueryFiltersLegacy", func() {+ It("marshals all four keys, empty ones as [] not null", func() {+ b, err := json.Marshal(QueryFiltersLegacy{+ Genres: []string{"Rock"}, Tags: []string{}, OfficialRatings: []string{}, Years: []int{1999},+ })+ Expect(err).ToNot(HaveOccurred())+ j := string(b)+ Expect(j).To(ContainSubstring(`"Genres":["Rock"]`))+ Expect(j).To(ContainSubstring(`"Tags":[]`))+ Expect(j).To(ContainSubstring(`"OfficialRatings":[]`))+ Expect(j).To(ContainSubstring(`"Years":[1999]`))+ })+})diff --git a/server/jellyfin/dto/mappers.go b/server/jellyfin/dto/mappers.goindex 036dfbd91..444a25cac 100644--- a/server/jellyfin/dto/mappers.go+++ b/server/jellyfin/dto/mappers.go@@ -200,7 +200,7 @@ func SongToBaseItem(mf model.MediaFile, fields Fields) BaseItemDto {return item}-func AlbumToBaseItem(al model.Album) BaseItemDto {+func AlbumToBaseItem(al model.Album, fields Fields) BaseItemDto {item := BaseItemDto{Name: al.Name,Id: EncodeID(al.ID),@@ -232,6 +232,14 @@ func AlbumToBaseItem(al model.Album) BaseItemDto {item.GenreItems = append(item.GenreItems, NameGuidPair{Id: EncodeID(g.ID), Name: g.Name})}}+ // Jellyfin leaves Studios empty for music; we expose record labels here to match our /Studios+ // list and StudioIds= filter, so a client can display and click through to filter by label.+ if fields.Has("Studios") {+ for _, label := range al.Tags.Values(model.TagRecordLabel) {+ id := EncodeID(model.NewTag(model.TagRecordLabel, label).ID)+ item.Studios = append(item.Studios, NameGuidPair{Name: label, Id: id})+ }+ }// The album's own ReplayGain gain (dB at the RG2 -18 LUFS reference) — same// convention as tracks; clients read it off the album item as NormalizationGain.item.NormalizationGain = al.RGAlbumGain@@ -264,6 +272,15 @@ func GenreToBaseItem(g model.Genre) BaseItemDto {}}+func StudioToBaseItem(t model.Tag) BaseItemDto {+ return BaseItemDto{+ Name: t.TagValue,+ Id: EncodeID(t.ID),+ Type: "Studio",+ BackdropImageTags: []string{},+ }+}+// PlaylistToBaseItem maps a playlist to a Playlist BaseItemDto.func PlaylistToBaseItem(p model.Playlist) BaseItemDto {// Finamp caches covers keyed by blurHash, so the tag (and blurhash) must change with the cover.diff --git a/server/jellyfin/dto/mappers_test.go b/server/jellyfin/dto/mappers_test.goindex c986e7f81..c11f38eaf 100644--- a/server/jellyfin/dto/mappers_test.go+++ b/server/jellyfin/dto/mappers_test.go@@ -244,7 +244,7 @@ var _ = Describe("mappers", func() {It("maps an album to a MusicAlbum folder item", func() {al := model.Album{ID: "alb-1", Name: "Alb", AlbumArtist: "AA", AlbumArtistID: "art-1", MaxYear: 1999, SongCount: 10, Genres: []model.Genre{{ID: "1", Name: "genre 1"}, {ID: "2", Name: "genre 2"}}}- item := AlbumToBaseItem(al)+ item := AlbumToBaseItem(al, nil)Expect(item.Type).To(Equal("MusicAlbum"))Expect(item.IsFolder).To(BeTrue())Expect(item.Id).To(Equal(EncodeID("alb-1")))@@ -260,9 +260,22 @@ var _ = Describe("mappers", func() {Expect(item.GenreItems).To(Equal([]NameGuidPair{{Id: EncodeID("1"), Name: "genre 1"}, {Id: EncodeID("2"), Name: "genre 2"}}))})+ It("populates album Studios from record-label tags only when Fields=Studios", func() {+ al := model.Album{ID: "alb-2", Name: "Alb2"}+ al.Tags = model.Tags{model.TagRecordLabel: []string{"Columbia", "Legacy"}}++ Expect(AlbumToBaseItem(al, nil).Studios).To(BeEmpty())++ item := AlbumToBaseItem(al, ParseFields("Studios"))+ Expect(item.Studios).To(Equal([]NameGuidPair{+ {Name: "Columbia", Id: EncodeID(model.NewTag(model.TagRecordLabel, "Columbia").ID)},+ {Name: "Legacy", Id: EncodeID(model.NewTag(model.TagRecordLabel, "Legacy").ID)},+ }))+ })+It("sets NormalizationGain on the album from its ReplayGain", func() {al := model.Album{ID: "al1", Name: "Album", RGAlbumGain: new(-6.0)}- b, err := json.Marshal(AlbumToBaseItem(al))+ b, err := json.Marshal(AlbumToBaseItem(al, nil))Expect(err).ToNot(HaveOccurred())Expect(string(b)).To(ContainSubstring(`"NormalizationGain":-6`))// Real Jellyfin never sets AlbumNormalizationGain on an album item.@@ -270,7 +283,7 @@ var _ = Describe("mappers", func() {})It("omits NormalizationGain when the album has no ReplayGain", func() {- b, err := json.Marshal(AlbumToBaseItem(model.Album{ID: "al1", Name: "Album"}))+ b, err := json.Marshal(AlbumToBaseItem(model.Album{ID: "al1", Name: "Album"}, nil))Expect(err).ToNot(HaveOccurred())Expect(string(b)).ToNot(ContainSubstring("NormalizationGain"))})@@ -293,6 +306,13 @@ var _ = Describe("mappers", func() {Expect(item.Name).To(Equal("Rock"))})+ It("maps a tag to a Studio BaseItemDto", func() {+ item := StudioToBaseItem(model.Tag{ID: "t1", TagValue: "Blue Note"})+ Expect(item.Type).To(Equal("Studio"))+ Expect(item.Name).To(Equal("Blue Note"))+ Expect(item.Id).To(Equal(EncodeID("t1")))+ })+Describe("premiereDate", func() {// Finamp re-sorts "Latest Releases" client-side by PremiereDate; absent values sort arbitrarily.It("serializes a full date", func() {@@ -321,9 +341,9 @@ var _ = Describe("mappers", func() {})It("is set on albums from their date, falling back to MaxYear", func() {- Expect(*AlbumToBaseItem(model.Album{ID: "a1", Date: "2013-09-06"}).PremiereDate).To(Equal("2013-09-06T00:00:00Z"))- Expect(*AlbumToBaseItem(model.Album{ID: "a2", MaxYear: 2013}).PremiereDate).To(Equal("2013-01-01T00:00:00Z"))- Expect(AlbumToBaseItem(model.Album{ID: "a3"}).PremiereDate).To(BeNil())+ Expect(*AlbumToBaseItem(model.Album{ID: "a1", Date: "2013-09-06"}, nil).PremiereDate).To(Equal("2013-09-06T00:00:00Z"))+ Expect(*AlbumToBaseItem(model.Album{ID: "a2", MaxYear: 2013}, nil).PremiereDate).To(Equal("2013-01-01T00:00:00Z"))+ Expect(AlbumToBaseItem(model.Album{ID: "a3"}, nil).PremiereDate).To(BeNil())})})diff --git a/server/jellyfin/e2e/browsing_test.go b/server/jellyfin/e2e/browsing_test.goindex a0632994e..be6d6bb5d 100644--- a/server/jellyfin/e2e/browsing_test.go+++ b/server/jellyfin/e2e/browsing_test.go@@ -2,6 +2,7 @@ package e2eimport ("net/http"+ "sort""time""github.com/navidrome/navidrome/server/jellyfin/dto"@@ -210,6 +211,44 @@ var _ = Describe("Browsing", func() {})})+ Describe("year filtering (Years=)", func() {+ It("filters items by Years=", func() {+ albums := queryResult(get("/Items?IncludeItemTypes=MusicAlbum&Recursive=true&Years=1959"))+ Expect(names(albums.Items)).To(ConsistOf("Kind of Blue"))++ songs := queryResult(get("/Items?IncludeItemTypes=Audio&Recursive=true&Years=1959"))+ for _, it := range songs.Items {+ Expect(it.ProductionYear).ToNot(BeNil())+ Expect(*it.ProductionYear).To(Equal(1959))+ }+ Expect(songs.Items).ToNot(BeEmpty())+ })+ })++ Describe("studio filtering (StudioIds=)", func() {+ It("filters items by StudioIds=", func() {+ studios := queryResult(get("/Studios"))+ var columbiaID string+ for _, it := range studios.Items {+ if it.Name == "Columbia" {+ columbiaID = it.Id+ }+ }+ Expect(columbiaID).ToNot(BeEmpty())++ albums := queryResult(get("/Items?IncludeItemTypes=MusicAlbum&Recursive=true&StudioIds=" + columbiaID))+ Expect(names(albums.Items)).To(ConsistOf("Kind of Blue"))+ })++ It("returns filter lists scoped to a ParentId library", func() {+ var filters dto.QueryFiltersLegacy+ parseInto(get("/Items/Filters?ParentId="+enc("1")+"&IncludeItemTypes=Audio&Recursive=true"), &filters)+ Expect(filters.Years).To(ContainElements(1959, 1965))+ studios := queryResult(get("/Studios?ParentId=" + enc("1")))+ Expect(names(studios.Items)).To(ContainElement("Columbia"))+ })+ })+// Finamp's genre screen sends ParentId=<libraryId> (scoping) plus GenreIds=<genreId>.Describe("genre filtering (GenreIds)", func() {lib1 := enc("1")@@ -482,5 +521,31 @@ var _ = Describe("Browsing", func() {Expect(q.Items).To(HaveLen(1))Expect(q.TotalRecordCount).To(Equal(3))})++ It("returns record labels as Studio items", func() {+ q := queryResult(get("/Studios"))+ names := make([]string, 0, len(q.Items))+ for _, it := range q.Items {+ Expect(it.Type).To(Equal("Studio"))+ names = append(names, it.Name)+ }+ Expect(names).To(ContainElement("Columbia"))+ })+ })++ Describe("GET /Items/Filters", func() {+ It("returns legacy query filters with genres, years, and empty tags/ratings", func() {+ var filters dto.QueryFiltersLegacy+ parseInto(get("/Items/Filters?IncludeItemTypes=Audio&Recursive=true"), &filters)+ Expect(filters.Genres).To(ContainElements("Rock", "Jazz"))+ Expect(filters.Years).To(ContainElements(1959, 1965, 1969, 1971))+ // Verify ascending sort by checking it equals itself sorted.+ sorted := make([]int, len(filters.Years))+ copy(sorted, filters.Years)+ sort.Ints(sorted)+ Expect(filters.Years).To(Equal(sorted))+ Expect(filters.Tags).To(BeEmpty())+ Expect(filters.OfficialRatings).To(BeEmpty())+ })})})diff --git a/server/jellyfin/e2e/e2e_suite_test.go b/server/jellyfin/e2e/e2e_suite_test.goindex 5a4c8c031..31d98d1d9 100644--- a/server/jellyfin/e2e/e2e_suite_test.go+++ b/server/jellyfin/e2e/e2e_suite_test.go@@ -111,7 +111,7 @@ func buildTestFS() storagetest.FakeFS {abbeyRoad := template(_t{"albumartist": "The Beatles", "artist": "The Beatles", "album": "Abbey Road", "year": 1969, "genre": "Rock"})help := template(_t{"albumartist": "The Beatles", "artist": "The Beatles", "album": "Help!", "year": 1965, "genre": "Rock"})ledZepIV := template(_t{"albumartist": "Led Zeppelin", "artist": "Led Zeppelin", "album": "IV", "year": 1971, "genre": "Rock"})- kindOfBlue := template(_t{"albumartist": "Miles Davis", "artist": "Miles Davis", "album": "Kind of Blue", "year": 1959, "genre": "Jazz"})+ kindOfBlue := template(_t{"albumartist": "Miles Davis", "artist": "Miles Davis", "album": "Kind of Blue", "year": 1959, "genre": "Jazz", "label": "Columbia"})singles := template(_t{"albumartist": "Solo Artist", "artist": "Solo Artist", "album": "Singles", "year": 2020, "genre": "Pop"})return harness.CreateFS(fstest.MapFS{diff --git a/server/jellyfin/items.go b/server/jellyfin/items.goindex c3c217cfc..7cf2a17ba 100644--- a/server/jellyfin/items.go+++ b/server/jellyfin/items.go@@ -222,6 +222,8 @@ type itemsQuery struct {contributingOnly boolgenreIds []stringalbumIds []string+ years []int+ studioIds []string}// parseItemsQuery also resolves the entity types (inferring them from the parent when@@ -245,7 +247,9 @@ func (api *Router) parseItemsQuery(ctx context.Context, r *http.Request) itemsQu// Finamp's genre screen sends ParentId=<libraryId> for scoping plus GenreIds for the genre.genreIds: decodedQueryIDs(r, "genreids"),// Feishin fetches an album's tracks with AlbumIds instead of ParentId.- albumIds: decodedQueryIDs(r, "albumids"),+ albumIds: decodedQueryIDs(r, "albumids"),+ years: parseYears(r),+ studioIds: decodedQueryIDs(r, "studioids"),}// An artist's page filters by artist, not ParentId: Finamp sends ParentId=<libraryId> for scoping// plus AlbumArtistIds/ArtistIds/contributingArtistIds for the artist.@@ -414,6 +418,17 @@ func decodedQueryIDs(r *http.Request, key string) []string {return slice.Map(queryIDs(r, key), dto.DecodeID)}+// parseYears reads Years= as a discrete list, accepting comma-separated and repeated params.+func parseYears(r *http.Request) []int {+ var years []int+ for _, v := range queryIDs(r, "years") {+ if y, err := strconv.Atoi(v); err == nil && y > 0 {+ years = append(years, y)+ }+ }+ return years+}+// parseTypes returns the recognized entries in IncludeItemTypes in order, defaulting to// {"MusicAlbum"} when none are recognized (so ParentId=<artistId> browses that artist's albums).func parseTypes(types string) []string {@@ -481,6 +496,7 @@ func searchPage[S ~[]E, E any](opts model.QueryOptions, search func(model.QueryO}func (api *Router) listAlbums(ctx context.Context, opts model.QueryOptions, q itemsQuery) (itemsResult, error) {+ toItem := func(al model.Album) dto.BaseItemDto { return dto.AlbumToBaseItem(al, q.fields) }repo := api.ds.Album(ctx)filters := squirrel.And{}// For albums, ParentId (browse an artist) and AlbumArtistIds/ArtistIds both mean "this artist's@@ -496,6 +512,12 @@ func (api *Router) listAlbums(ctx context.Context, opts model.QueryOptions, q itif len(q.genreIds) > 0 {filters = append(filters, filter.ByGenreID(q.genreIds))}+ if len(q.years) > 0 {+ filters = append(filters, filter.AlbumsByYears(q.years))+ }+ if len(q.studioIds) > 0 {+ filters = append(filters, filter.ByStudioID(q.studioIds))+ }if q.favOnly {filters = append(filters, filter.ByStarred().Filters)}@@ -509,12 +531,12 @@ func (api *Router) listAlbums(ctx context.Context, opts model.QueryOptions, q itif err != nil {return itemsResult{}, err}- return materialized(result(slice.Map(albums, dto.AlbumToBaseItem), total, opts.Offset)), nil+ return materialized(result(slice.Map(albums, toItem), total, opts.Offset)), nil}total, _ := repo.CountAll(model.QueryOptions{Filters: opts.Filters})open := streamCursor(func() (func(func(model.Album, error) bool), error) {return repo.GetCursor(opts)- }, dto.AlbumToBaseItem)+ }, toItem)return streamed(open, int(total), opts.Offset), nil}@@ -537,6 +559,12 @@ func (api *Router) listSongs(ctx context.Context, opts model.QueryOptions, q iteif len(q.genreIds) > 0 {filters = append(filters, filter.ByGenreID(q.genreIds))}+ if len(q.years) > 0 {+ filters = append(filters, filter.SongsByYears(q.years))+ }+ if len(q.studioIds) > 0 {+ filters = append(filters, filter.ByStudioID(q.studioIds))+ }if q.favOnly {filters = append(filters, filter.ByStarred().Filters)}@@ -665,7 +693,7 @@ func (api *Router) resolveItemByID(ctx context.Context, id string, fields dto.Fiif !u.HasLibraryAccess(al.LibraryID) {return dto.BaseItemDto{}, false}- return dto.AlbumToBaseItem(*al), true+ return dto.AlbumToBaseItem(*al, fields), true}if ar, err := api.ds.Artist(ctx).Get(id); err == nil {// TODO: an artist spans multiple libraries (library_artist), so there's no single@@ -754,13 +782,15 @@ func (api *Router) deleteItem(w http.ResponseWriter, r *http.Request) {// /Items/Latest, and why it writes directly instead of going through api.ok.func (api *Router) getLatest(w http.ResponseWriter, r *http.Request) {ctx := r.Context()+ p := req.Params(r)+ fields := dto.ParseFields(p.Strings("fields")...)opts := filter.AlbumsByNewest()- opts.Max = req.Params(r).IntOr("limit", 20)+ opts.Max = p.IntOr("limit", 20)opts = filter.ApplyLibraryFilter(opts, accessibleLibraryIDs(ctx))repo := api.ds.Album(ctx)open := streamCursor(func() (func(func(model.Album, error) bool), error) {return repo.GetCursor(opts)- }, dto.AlbumToBaseItem)+ }, func(al model.Album) dto.BaseItemDto { return dto.AlbumToBaseItem(al, fields) })api.writeItemsArray(w, r, streamed(open, 0, 0))}diff --git a/server/jellyfin/library.go b/server/jellyfin/library.goindex 2e486c36f..2830f1105 100644--- a/server/jellyfin/library.go+++ b/server/jellyfin/library.go@@ -2,11 +2,14 @@ package jellyfinimport ("context"+ "net/http""strconv"+ "github.com/Masterminds/squirrel""github.com/navidrome/navidrome/model""github.com/navidrome/navidrome/model/request""github.com/navidrome/navidrome/server/jellyfin/dto"+ "github.com/navidrome/navidrome/utils/req")// accessibleLibraryIDs returns the ids of the libraries the current user can access. An empty@@ -30,6 +33,20 @@ func resolveLibraryScope(ctx context.Context, parentId string) (scopeIDs []int,return accessibleLibraryIDs(ctx), false}+// parentIDScope resolves the request's ParentId param to a library scope (see resolveLibraryScope).+func parentIDScope(ctx context.Context, r *http.Request) (scopeIDs []int, isLibraryParent bool) {+ return resolveLibraryScope(ctx, dto.DecodeID(req.Params(r).StringOr("parentid", "")))+}++// libraryScopeFilter restricts a tag query to the given library scope. Empty scope means+// unrestricted (see accessibleLibraryIDs), so it returns nil rather than an impossible IN ().+func libraryScopeFilter(scope []int) squirrel.Sqlizer {+ if len(scope) == 0 {+ return nil+ }+ return squirrel.Eq{"library_tag.library_id": scope}+}+// libraryView builds the CollectionFolder BaseItemDto representing a library as a top-level node.// Shared by getUserViews and getItem, since Finamp fetches a UserView's id as a plain item.func libraryView(lib model.Library) dto.BaseItemDto {diff --git a/server/jellyfin/similar.go b/server/jellyfin/similar.goindex 085080850..661fb95cc 100644--- a/server/jellyfin/similar.go+++ b/server/jellyfin/similar.go@@ -177,7 +177,7 @@ func (api *Router) similarAlbums(ctx context.Context, id string, limit int) dto.}seen[s.AlbumID] = trueif al, err := api.ds.Album(ctx).Get(s.AlbumID); err == nil && u.HasLibraryAccess(al.LibraryID) {- items = append(items, dto.AlbumToBaseItem(*al))+ items = append(items, dto.AlbumToBaseItem(*al, nil))if len(items) >= limit {break}diff --git a/tests/mock_album_repo.go b/tests/mock_album_repo.goindex 03dfed879..cc7d66b4d 100644--- a/tests/mock_album_repo.go+++ b/tests/mock_album_repo.go@@ -209,4 +209,11 @@ func (m *MockAlbumRepo) SetStar(starred bool, itemIDs ...string) error {return nil}+func (m *MockAlbumRepo) GetYears(libraryIDs ...int) ([]int, error) {+ if m.Err {+ return nil, errors.New("error")+ }+ return []int{}, nil+}+var _ model.AlbumRepository = (*MockAlbumRepo)(nil)diff --git a/tests/mock_data_store.go b/tests/mock_data_store.goindex 754f0c084..e016a28de 100644--- a/tests/mock_data_store.go+++ b/tests/mock_data_store.go@@ -65,7 +65,7 @@ func (db *MockDataStore) Tag(ctx context.Context) model.TagRepository {if db.RealDS != nil {return db.RealDS.Tag(ctx)}- db.MockedTag = struct{ model.TagRepository }{}+ db.MockedTag = &MockTagRepo{}return db.MockedTag}diff --git a/tests/mock_genre_repo.go b/tests/mock_genre_repo.goindex 122ccc278..50796efc0 100644--- a/tests/mock_genre_repo.go+++ b/tests/mock_genre_repo.go@@ -5,8 +5,9 @@ import ()type MockedGenreRepo struct {- Error error- Data map[string]model.Genre+ Error error+ Data map[string]model.Genre+ Options model.QueryOptions}func (r *MockedGenreRepo) init() {@@ -15,7 +16,10 @@ func (r *MockedGenreRepo) init() {}}-func (r *MockedGenreRepo) GetAll(...model.QueryOptions) (model.Genres, error) {+func (r *MockedGenreRepo) GetAll(options ...model.QueryOptions) (model.Genres, error) {+ if len(options) > 0 {+ r.Options = options[0]+ }if r.Error != nil {return nil, r.Error}diff --git a/tests/mock_tag_repo.go b/tests/mock_tag_repo.gonew file mode 100644index 000000000..a59035ea6--- /dev/null+++ b/tests/mock_tag_repo.go@@ -0,0 +1,24 @@+package tests++import (+ "github.com/navidrome/navidrome/model"+)++// MockTagRepo records the QueryOptions passed to GetAll, mirroring MockArtistRepo, so tests can+// assert on which filters a caller attached (e.g. a library scope).+type MockTagRepo struct {+ model.TagRepository+ Data model.TagList+ Options model.QueryOptions+ Err error+}++func (r *MockTagRepo) GetAll(_ model.TagName, options ...model.QueryOptions) (model.TagList, error) {+ if len(options) > 0 {+ r.Options = options[0]+ }+ if r.Err != nil {+ return nil, r.Err+ }+ return r.Data, nil+}