feat(subsonic): add OS readonly and validUntil properties in playlists (#4993)

* feat(subsonic): add OS readonly and validUntil properties

* remove duplicated test

* test: fix and enable disabled child smart playlist tests

Fixed the XContext("child smart playlists") tests that were disabled with
a TODO comment. The tests had several issues: nested playlists were missing
Public: true (required by InPlaylist criteria), the criteria matched no
test fixtures, the "not expired" test set EvaluatedAt on the parent too
(preventing it from refreshing at all), and the "expired" test dereferenced
a nil EvaluatedAt. Added proper cleanup with DeferCleanup and config
restoration via configtest.

* fix(subsonic): always include readonly field in JSON playlist responses

Removed omitempty from the JSON tag of the Readonly field in
OpenSubsonicPlaylist so that readonly: false is always serialized in
JSON responses, per the OpenSubsonic spec requirement that supported
fields must be returned with default values. Added a test case with an
empty OpenSubsonicPlaylist to verify the behavior.

---------

Co-authored-by: Deluan Quintão <deluan@navidrome.org>

.dockerignore

@@ -15,4 +15,5 @@ dist
 binaries
 cache
 music
+music.old
 !Dockerfile

.gitignore

@@ -20,6 +20,7 @@ cache/*
 coverage.out
 dist
 music
+music.old
 *.db*
 .gitinfo
 docker-compose.yml

adapters/lastfm/agent.go

@@ -31,6 +31,12 @@ var ignoredContent = []string{
 	`<a href="https://www.last.fm/music/`,
 }
 
+var lastFMReadMoreRegex = regexp.MustCompile(`\s*<a href="https://www\.last\.fm/music/[^"]*">Read more on Last\.fm</a>\.?`)
+
+func cleanContent(content string) string {
+	return strings.TrimSpace(lastFMReadMoreRegex.ReplaceAllString(content, ""))
+}
+
 type lastfmAgent struct {
 	ds           model.DataStore
 	sessionKeys  *agents.SessionKeys
@@ -95,7 +101,7 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin
 		resp.MBID = a.MBID
 		resp.URL = a.URL
 		if isValidContent(a.Description.Summary) {
-			resp.Description = strings.TrimSpace(a.Description.Summary)
+			resp.Description = cleanContent(a.Description.Summary)
 			return &resp, nil
 		}
 		log.Debug(ctx, "LastFM/album.getInfo returned empty/ignored description, trying next language", "album", name, "artist", artist, "lang", lang)
@@ -171,7 +177,7 @@ func (l *lastfmAgent) GetArtistBiography(ctx context.Context, id, name, mbid str
 			return "", err
 		}
 		if isValidContent(a.Bio.Summary) {
-			return strings.TrimSpace(a.Bio.Summary), nil
+			return cleanContent(a.Bio.Summary), nil
 		}
 		log.Debug(ctx, "LastFM/artist.getInfo returned empty/ignored biography, trying next language", "artist", name, "lang", lang)
 	}

adapters/lastfm/agent_test.go

@@ -80,7 +80,7 @@ var _ = Describe("lastfmAgent", func() {
 		It("returns the biography", func() {
 			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
 			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			Expect(agent.GetArtistBiography(ctx, "123", "U2", "")).To(Equal("U2 é uma das mais importantes bandas de rock de todos os tempos. Formada em 1976 em Dublin, composta por Bono (vocalista  e guitarrista), The Edge (guitarrista, pianista e backing vocal), Adam Clayton (baixista), Larry Mullen, Jr. (baterista e percussionista).\n\nDesde a década de 80, U2 é uma das bandas mais populares no mundo. Seus shows são únicos e um verdadeiro festival de efeitos especiais, além de serem um dos que mais arrecadam anualmente. <a href=\"https://www.last.fm/music/U2\">Read more on Last.fm</a>"))
+			Expect(agent.GetArtistBiography(ctx, "123", "U2", "")).To(Equal("U2 é uma das mais importantes bandas de rock de todos os tempos. Formada em 1976 em Dublin, composta por Bono (vocalista  e guitarrista), The Edge (guitarrista, pianista e backing vocal), Adam Clayton (baixista), Larry Mullen, Jr. (baterista e percussionista).\n\nDesde a década de 80, U2 é uma das bandas mais populares no mundo. Seus shows são únicos e um verdadeiro festival de efeitos especiais, além de serem um dos que mais arrecadam anualmente."))
 			Expect(httpClient.RequestCount).To(Equal(1))
 			Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("U2"))
 		})
@@ -535,7 +535,7 @@ var _ = Describe("lastfmAgent", func() {
 			Expect(agent.GetAlbumInfo(ctx, "Believe", "Cher", "03c91c40-49a6-44a7-90e7-a700edf97a62")).To(Equal(&agents.AlbumInfo{
 				Name:        "Believe",
 				MBID:        "03c91c40-49a6-44a7-90e7-a700edf97a62",
-				Description: "Believe is the twenty-third studio album by American singer-actress Cher, released on November 10, 1998 by Warner Bros. Records. The RIAA certified it Quadruple Platinum on December 23, 1999, recognizing four million shipments in the United States; Worldwide, the album has sold more than 20 million copies, making it the biggest-selling album of her career. In 1999 the album received three Grammy Awards nominations including \"Record of the Year\", \"Best Pop Album\" and winning \"Best Dance Recording\" for the single \"Believe\". It was released by Warner Bros. Records at the end of 1998. The album was executive produced by Rob <a href=\"https://www.last.fm/music/Cher/Believe\">Read more on Last.fm</a>.",
+				Description: "Believe is the twenty-third studio album by American singer-actress Cher, released on November 10, 1998 by Warner Bros. Records. The RIAA certified it Quadruple Platinum on December 23, 1999, recognizing four million shipments in the United States; Worldwide, the album has sold more than 20 million copies, making it the biggest-selling album of her career. In 1999 the album received three Grammy Awards nominations including \"Record of the Year\", \"Best Pop Album\" and winning \"Best Dance Recording\" for the single \"Believe\". It was released by Warner Bros. Records at the end of 1998. The album was executive produced by Rob",
 				URL:         "https://www.last.fm/music/Cher/Believe",
 			}))
 			Expect(httpClient.RequestCount).To(Equal(1))

model/mediafile.go

@@ -354,7 +354,7 @@ type MediaFileCursor iter.Seq2[MediaFile, error]
 type MediaFileRepository interface {
 	CountAll(options ...QueryOptions) (int64, error)
 	CountBySuffix(options ...QueryOptions) (map[string]int64, error)
-	Exists(ids ...string) (bool, error)
+	Exists(id string) (bool, error)
 	Put(m *MediaFile) error
 	Get(id string) (*MediaFile, error)
 	GetWithParticipants(id string) (*MediaFile, error)

model/metadata/metadata.go

@@ -250,7 +250,15 @@ func processPairMapping(name model.TagName, mapping model.TagConf, lowered model
 	id3Base := parseID3Pairs(name, lowered)
 
 	if len(aliasValues) > 0 {
-		id3Base = append(id3Base, parseVorbisPairs(aliasValues)...)
+		// For lyrics, don't use parseVorbisPairs as parentheses in lyrics content
+		// should not be interpreted as language keys (e.g. "(intro)" is not a language)
+		if name == model.TagLyrics {
+			for _, v := range aliasValues {
+				id3Base = append(id3Base, NewPair("xxx", v))
+			}
+		} else {
+			id3Base = append(id3Base, parseVorbisPairs(aliasValues)...)
+		}
 	}
 	return id3Base
 }

model/metadata/metadata_test.go

@@ -246,6 +246,18 @@ var _ = Describe("Metadata", func() {
 					metadata.NewPair("eng", "Lyrics"),
 				))
 			})
+
+			It("should preserve lyrics starting with parentheses from alias tags", func() {
+				props.Tags = model.RawTags{
+					"LYRICS": {"(line one)\nline two\nline three"},
+				}
+				md = metadata.New(filePath, props)
+
+				Expect(md.All()).To(HaveKey(model.TagLyrics))
+				Expect(md.Strings(model.TagLyrics)).To(ContainElements(
+					metadata.NewPair("xxx", "(line one)\nline two\nline three"),
+				))
+			})
 		})
 
 		Describe("ReplayGain", func() {

persistence/mediafile_repository.go

@@ -143,29 +143,8 @@ func (r *mediaFileRepository) CountBySuffix(options ...model.QueryOptions) (map[
 	return counts, nil
 }
 
-// Exists checks if all given media file IDs exist in the database and are accessible to the current user.
-// If no IDs are provided, it returns true. Duplicate IDs are handled correctly.
-// If any of the IDs do not exist or are not accessible, it returns false.
-func (r *mediaFileRepository) Exists(ids ...string) (bool, error) {
-	if len(ids) == 0 {
-		return true, nil
-	}
-	uniqueIds := slice.Unique(ids)
-
-	// Process in batches to avoid hitting SQLITE_MAX_VARIABLE_NUMBER limit (default 999)
-	const batchSize = 300
-	var totalCount int64
-	for batch := range slices.Chunk(uniqueIds, batchSize) {
-		existsQuery := Select("count(*) as exist").From("media_file").Where(Eq{"media_file.id": batch})
-		existsQuery = r.applyLibraryFilter(existsQuery)
-		var res struct{ Exist int64 }
-		err := r.queryOne(existsQuery, &res)
-		if err != nil {
-			return false, err
-		}
-		totalCount += res.Exist
-	}
-	return totalCount == int64(len(uniqueIds)), nil
+func (r *mediaFileRepository) Exists(id string) (bool, error) {
+	return r.exists(Eq{"media_file.id": id})
 }
 
 func (r *mediaFileRepository) Put(m *model.MediaFile) error {

persistence/playlist_repository.go

@@ -285,13 +285,16 @@ func (r *playlistRepository) refreshSmartPlaylist(pls *model.Playlist) bool {
 	}
 
 	// Update when the playlist was last refreshed (for cache purposes)
-	updSql := Update(r.tableName).Set("evaluated_at", time.Now()).Where(Eq{"id": pls.ID})
+	now := time.Now()
+	updSql := Update(r.tableName).Set("evaluated_at", now).Where(Eq{"id": pls.ID})
 	_, err = r.executeSQL(updSql)
 	if err != nil {
 		log.Error(r.ctx, "Error updating smart playlist", "playlist", pls.Name, "id", pls.ID, err)
 		return false
 	}
 
+	pls.EvaluatedAt = &now
+
 	log.Debug(r.ctx, "Refreshed playlist", "playlist", pls.Name, "id", pls.ID, "numTracks", pls.SongCount, "elapsed", time.Since(start))
 
 	return true

persistence/playlist_repository_test.go

@@ -4,6 +4,7 @@ import (
 	"time"
 
 	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/criteria"
@@ -160,14 +161,23 @@ var _ = Describe("PlaylistRepository", func() {
 			})
 		})
 
-		// TODO Validate these tests
-		XContext("child smart playlists", func() {
-			When("refresh day has expired", func() {
+		Context("child smart playlists", func() {
+			BeforeEach(func() {
+				DeferCleanup(configtest.SetupConfig())
+			})
+
+			When("refresh delay has expired", func() {
 				It("should refresh tracks for smart playlist referenced in parent smart playlist criteria", func() {
 					conf.Server.SmartPlaylistRefreshDelay = -1 * time.Second
 
-					nestedPls := model.Playlist{Name: "Nested", OwnerID: "userid", Rules: rules}
+					childRules := &criteria.Criteria{
+						Expression: criteria.All{
+							criteria.Contains{"title": "Day"},
+						},
+					}
+					nestedPls := model.Playlist{Name: "Nested", OwnerID: "userid", Public: true, Rules: childRules}
 					Expect(repo.Put(&nestedPls)).To(Succeed())
+					DeferCleanup(func() { _ = repo.Delete(nestedPls.ID) })
 
 					parentPls := model.Playlist{Name: "Parent", OwnerID: "userid", Rules: &criteria.Criteria{
 						Expression: criteria.All{
@@ -175,45 +185,69 @@ var _ = Describe("PlaylistRepository", func() {
 						},
 					}}
 					Expect(repo.Put(&parentPls)).To(Succeed())
+					DeferCleanup(func() { _ = repo.Delete(parentPls.ID) })
 
+					// Nested playlist has not been evaluated yet
 					nestedPlsRead, err := repo.Get(nestedPls.ID)
 					Expect(err).ToNot(HaveOccurred())
+					Expect(nestedPlsRead.EvaluatedAt).To(BeNil())
 
-					_, err = repo.GetWithTracks(parentPls.ID, true, false)
+					// Getting parent with refresh should recursively refresh the nested playlist
+					pls, err := repo.GetWithTracks(parentPls.ID, true, false)
 					Expect(err).ToNot(HaveOccurred())
+					Expect(pls.EvaluatedAt).ToNot(BeNil())
+					Expect(*pls.EvaluatedAt).To(BeTemporally("~", time.Now(), 2*time.Second))
 
-					// Check that the nested playlist was refreshed by parent get by verifying evaluatedAt is updated since first nestedPls get
+					// Parent should have tracks from the nested playlist
+					Expect(pls.Tracks).To(HaveLen(1))
+					Expect(pls.Tracks[0].MediaFileID).To(Equal(songDayInALife.ID))
+
+					// Nested playlist should now have been refreshed (EvaluatedAt set)
 					nestedPlsAfterParentGet, err := repo.Get(nestedPls.ID)
 					Expect(err).ToNot(HaveOccurred())
-
-					Expect(*nestedPlsAfterParentGet.EvaluatedAt).To(BeTemporally(">", *nestedPlsRead.EvaluatedAt))
+					Expect(nestedPlsAfterParentGet.EvaluatedAt).ToNot(BeNil())
+					Expect(*nestedPlsAfterParentGet.EvaluatedAt).To(BeTemporally("~", time.Now(), 2*time.Second))
 				})
 			})
 
-			When("refresh day has not expired", func() {
+			When("refresh delay has not expired", func() {
 				It("should NOT refresh tracks for smart playlist referenced in parent smart playlist criteria", func() {
 					conf.Server.SmartPlaylistRefreshDelay = 1 * time.Hour
+					childEvaluatedAt := time.Now().Add(-30 * time.Minute)
 
-					nestedPls := model.Playlist{Name: "Nested", OwnerID: "userid", Rules: rules}
+					childRules := &criteria.Criteria{
+						Expression: criteria.All{
+							criteria.Contains{"title": "Day"},
+						},
+					}
+					nestedPls := model.Playlist{Name: "Nested", OwnerID: "userid", Public: true, Rules: childRules, EvaluatedAt: &childEvaluatedAt}
 					Expect(repo.Put(&nestedPls)).To(Succeed())
+					DeferCleanup(func() { _ = repo.Delete(nestedPls.ID) })
 
+					// Parent has no EvaluatedAt, so it WILL refresh, but the child should not
 					parentPls := model.Playlist{Name: "Parent", OwnerID: "userid", Rules: &criteria.Criteria{
 						Expression: criteria.All{
 							criteria.InPlaylist{"id": nestedPls.ID},
 						},
 					}}
 					Expect(repo.Put(&parentPls)).To(Succeed())
+					DeferCleanup(func() { _ = repo.Delete(parentPls.ID) })
 
 					nestedPlsRead, err := repo.Get(nestedPls.ID)
 					Expect(err).ToNot(HaveOccurred())
 
-					_, err = repo.GetWithTracks(parentPls.ID, true, false)
+					// Getting parent with refresh should NOT recursively refresh the nested playlist
+					parent, err := repo.GetWithTracks(parentPls.ID, true, false)
 					Expect(err).ToNot(HaveOccurred())
 
-					// Check that the nested playlist was not refreshed by parent get by verifying evaluatedAt is not updated since first nestedPls get
+					// Parent should have been refreshed (its EvaluatedAt was nil)
+					Expect(parent.EvaluatedAt).ToNot(BeNil())
+					Expect(*parent.EvaluatedAt).To(BeTemporally("~", time.Now(), 2*time.Second))
+
+					// Nested playlist should NOT have been refreshed (still within delay window)
 					nestedPlsAfterParentGet, err := repo.Get(nestedPls.ID)
 					Expect(err).ToNot(HaveOccurred())
-
+					Expect(*nestedPlsAfterParentGet.EvaluatedAt).To(BeTemporally("~", childEvaluatedAt, time.Second))
 					Expect(*nestedPlsAfterParentGet.EvaluatedAt).To(Equal(*nestedPlsRead.EvaluatedAt))
 				})
 			})

server/subsonic/media_annotation.go

@@ -168,26 +168,15 @@ func (api *Router) Scrobble(r *http.Request) (*responses.Subsonic, error) {
 	position := p.IntOr("position", 0)
 	ctx := r.Context()
 
-	// Validate all IDs exist before processing (OpenSubsonic compliance)
-	exists, err := api.ds.MediaFile(ctx).Exists(ids...)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, newError(responses.ErrorDataNotFound, "Media file not found")
-	}
-
 	if submission {
 		err := api.scrobblerSubmit(ctx, ids, times)
 		if err != nil {
 			log.Error(ctx, "Error registering scrobbles", "ids", ids, "times", times, err)
-			return nil, err
 		}
 	} else {
 		err := api.scrobblerNowPlaying(ctx, ids[0], position)
 		if err != nil {
 			log.Error(ctx, "Error setting NowPlaying", "id", ids[0], err)
-			return nil, err
 		}
 	}
 

server/subsonic/media_annotation_test.go

@@ -31,12 +31,6 @@ var _ = Describe("MediaAnnotationController", func() {
 	})
 
 	Describe("Scrobble", func() {
-		BeforeEach(func() {
-			// Populate mock with valid media files
-			_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "12"})
-			_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "34"})
-		})
-
 		It("submit all scrobbles with only the id", func() {
 			submissionTime := time.Now()
 			r := newGetRequest("id=12", "id=34")
@@ -77,27 +71,10 @@ var _ = Describe("MediaAnnotationController", func() {
 			Expect(playTracker.Submissions).To(BeEmpty())
 		})
 
-		It("returns error when any id is invalid", func() {
-			r := newGetRequest("id=invalid")
-
-			_, err := router.Scrobble(r)
-
-			Expect(err).To(MatchError(ContainSubstring("not found")))
-			Expect(playTracker.Submissions).To(BeEmpty())
-		})
-
-		It("returns error and does not scrobble when mix of valid and invalid ids", func() {
-			r := newGetRequest("id=12", "id=invalid")
-
-			_, err := router.Scrobble(r)
-
-			Expect(err).To(MatchError(ContainSubstring("not found")))
-			Expect(playTracker.Submissions).To(BeEmpty())
-		})
-
 		Context("submission=false", func() {
 			var req *http.Request
 			BeforeEach(func() {
+				_ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "12"})
 				ctx = request.WithPlayer(ctx, model.Player{ID: "player-1"})
 				req = newGetRequest("id=12", "submission=false")
 				req = req.WithContext(ctx)
@@ -117,16 +94,6 @@ var _ = Describe("MediaAnnotationController", func() {
 				Expect(playTracker.Playing).To(HaveLen(1))
 				Expect(playTracker.Playing).To(HaveKey("player-1"))
 			})
-
-			It("returns error when id is invalid", func() {
-				req = newGetRequest("id=invalid", "submission=false")
-				req = req.WithContext(ctx)
-
-				_, err := router.Scrobble(req)
-
-				Expect(err).To(MatchError(ContainSubstring("not found")))
-				Expect(playTracker.Playing).To(BeEmpty())
-			})
 		})
 	})
 })

server/subsonic/playlists.go

@@ -12,6 +12,7 @@ import (
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/model/request"
 	"github.com/navidrome/navidrome/server/subsonic/responses"
+	. "github.com/navidrome/navidrome/utils/gg"
 	"github.com/navidrome/navidrome/utils/req"
 	"github.com/navidrome/navidrome/utils/slice"
 )
@@ -162,7 +163,11 @@ func (api *Router) buildPlaylist(ctx context.Context, p model.Playlist) response
 	pls.Duration = int32(p.Duration)
 	pls.Created = p.CreatedAt
 	if p.IsSmartPlaylist() {
-		pls.Changed = time.Now()
+		if p.EvaluatedAt != nil {
+			pls.Changed = *p.EvaluatedAt
+		} else {
+			pls.Changed = time.Now()
+		}
 	} else {
 		pls.Changed = p.UpdatedAt
 	}
@@ -176,6 +181,24 @@ func (api *Router) buildPlaylist(ctx context.Context, p model.Playlist) response
 	pls.Owner = p.OwnerName
 	pls.Public = p.Public
 	pls.CoverArt = p.CoverArtID().String()
+	pls.OpenSubsonicPlaylist = buildOSPlaylist(ctx, p)
 
 	return pls
 }
+
+func buildOSPlaylist(ctx context.Context, p model.Playlist) *responses.OpenSubsonicPlaylist {
+	pls := responses.OpenSubsonicPlaylist{}
+
+	if p.IsSmartPlaylist() {
+		pls.Readonly = true
+
+		if p.EvaluatedAt != nil {
+			pls.ValidUntil = P(p.EvaluatedAt.Add(conf.Server.SmartPlaylistRefreshDelay))
+		}
+	} else {
+		user, ok := request.UserFrom(ctx)
+		pls.Readonly = !ok || p.OwnerID != user.ID
+	}
+
+	return &pls
+}

server/subsonic/playlists_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/criteria"
 	"github.com/navidrome/navidrome/model/request"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
@@ -25,96 +26,194 @@ var _ = Describe("buildPlaylist", func() {
 		ds = &tests.MockDataStore{}
 		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		ctx = context.Background()
-
-		createdAt := time.Date(2023, 1, 15, 10, 30, 0, 0, time.UTC)
-		updatedAt := time.Date(2023, 2, 20, 14, 45, 0, 0, time.UTC)
-
-		playlist = model.Playlist{
-			ID:        "pls-1",
-			Name:      "My Playlist",
-			Comment:   "Test comment",
-			OwnerName: "admin",
-			Public:    true,
-			SongCount: 10,
-			Duration:  600,
-			CreatedAt: createdAt,
-			UpdatedAt: updatedAt,
-		}
 	})
 
-	Context("with minimal client", func() {
+	Describe("normal playlist", func() {
 		BeforeEach(func() {
-			conf.Server.Subsonic.MinimalClients = "minimal-client"
-			player := model.Player{Client: "minimal-client"}
-			ctx = request.WithPlayer(ctx, player)
+			createdAt := time.Date(2023, 1, 15, 10, 30, 0, 0, time.UTC)
+			updatedAt := time.Date(2023, 2, 20, 14, 45, 0, 0, time.UTC)
+
+			playlist = model.Playlist{
+				ID:        "pls-1",
+				Name:      "My Playlist",
+				Comment:   "Test comment",
+				OwnerName: "admin",
+				OwnerID:   "1234",
+				Public:    true,
+				SongCount: 10,
+				Duration:  600,
+				CreatedAt: createdAt,
+				UpdatedAt: updatedAt,
+			}
 		})
 
-		It("returns only basic fields", func() {
-			result := router.buildPlaylist(ctx, playlist)
+		Context("with minimal client", func() {
+			BeforeEach(func() {
+				conf.Server.Subsonic.MinimalClients = "minimal-client"
+				player := model.Player{Client: "minimal-client"}
+				ctx = request.WithPlayer(ctx, player)
+			})
 
-			Expect(result.Id).To(Equal("pls-1"))
-			Expect(result.Name).To(Equal("My Playlist"))
-			Expect(result.SongCount).To(Equal(int32(10)))
-			Expect(result.Duration).To(Equal(int32(600)))
-			Expect(result.Created).To(Equal(playlist.CreatedAt))
-			Expect(result.Changed).To(Equal(playlist.UpdatedAt))
+			It("returns only basic fields", func() {
+				result := router.buildPlaylist(ctx, playlist)
 
-			// These should not be set
-			Expect(result.Comment).To(BeEmpty())
-			Expect(result.Owner).To(BeEmpty())
-			Expect(result.Public).To(BeFalse())
-			Expect(result.CoverArt).To(BeEmpty())
+				Expect(result.Id).To(Equal("pls-1"))
+				Expect(result.Name).To(Equal("My Playlist"))
+				Expect(result.SongCount).To(Equal(int32(10)))
+				Expect(result.Duration).To(Equal(int32(600)))
+				Expect(result.Created).To(Equal(playlist.CreatedAt))
+				Expect(result.Changed).To(Equal(playlist.UpdatedAt))
+
+				// These should not be set
+				Expect(result.Comment).To(BeEmpty())
+				Expect(result.Owner).To(BeEmpty())
+				Expect(result.Public).To(BeFalse())
+				Expect(result.CoverArt).To(BeEmpty())
+			})
+		})
+
+		Context("with non-minimal client", func() {
+			BeforeEach(func() {
+				conf.Server.Subsonic.MinimalClients = "minimal-client"
+				player := model.Player{Client: "regular-client"}
+				ctx = request.WithPlayer(ctx, player)
+			})
+
+			It("returns all fields", func() {
+				result := router.buildPlaylist(ctx, playlist)
+
+				Expect(result.Id).To(Equal("pls-1"))
+				Expect(result.Name).To(Equal("My Playlist"))
+				Expect(result.SongCount).To(Equal(int32(10)))
+				Expect(result.Duration).To(Equal(int32(600)))
+				Expect(result.Created).To(Equal(playlist.CreatedAt))
+				Expect(result.Changed).To(Equal(playlist.UpdatedAt))
+				Expect(result.Comment).To(Equal("Test comment"))
+				Expect(result.Owner).To(Equal("admin"))
+				Expect(result.Public).To(BeTrue())
+				Expect(result.Readonly).To(BeTrue())
+			})
+
+			It("returns all fields when as owner", func() {
+				ctx = request.WithUser(ctx, model.User{ID: "1234", UserName: "admin"})
+
+				result := router.buildPlaylist(ctx, playlist)
+
+				Expect(result.Id).To(Equal("pls-1"))
+				Expect(result.Name).To(Equal("My Playlist"))
+				Expect(result.SongCount).To(Equal(int32(10)))
+				Expect(result.Duration).To(Equal(int32(600)))
+				Expect(result.Created).To(Equal(playlist.CreatedAt))
+				Expect(result.Changed).To(Equal(playlist.UpdatedAt))
+				Expect(result.Comment).To(Equal("Test comment"))
+				Expect(result.Owner).To(Equal("admin"))
+				Expect(result.Public).To(BeTrue())
+				Expect(result.Readonly).To(BeFalse())
+			})
+		})
+
+		Context("when minimal clients list is empty", func() {
+			BeforeEach(func() {
+				conf.Server.Subsonic.MinimalClients = ""
+				player := model.Player{Client: "any-client"}
+				ctx = request.WithPlayer(ctx, player)
+			})
+
+			It("returns all fields", func() {
+				result := router.buildPlaylist(ctx, playlist)
+
+				Expect(result.Comment).To(Equal("Test comment"))
+				Expect(result.Owner).To(Equal("admin"))
+				Expect(result.Public).To(BeTrue())
+			})
+		})
+
+		Context("when no player in context", func() {
+			It("returns all fields", func() {
+				result := router.buildPlaylist(ctx, playlist)
+
+				Expect(result.Comment).To(Equal("Test comment"))
+				Expect(result.Owner).To(Equal("admin"))
+				Expect(result.Public).To(BeTrue())
+			})
 		})
 	})
 
-	Context("with non-minimal client", func() {
+	Describe("smart playlist", func() {
+		evaluatedAt := time.Date(2023, 2, 20, 15, 45, 0, 0, time.UTC)
+		validUntil := evaluatedAt.Add(5 * time.Second)
+
 		BeforeEach(func() {
-			conf.Server.Subsonic.MinimalClients = "minimal-client"
-			player := model.Player{Client: "regular-client"}
-			ctx = request.WithPlayer(ctx, player)
+			createdAt := time.Date(2023, 1, 15, 10, 30, 0, 0, time.UTC)
+			updatedAt := time.Date(2023, 2, 20, 14, 45, 0, 0, time.UTC)
+
+			playlist = model.Playlist{
+				ID:          "pls-1",
+				Name:        "My Playlist",
+				Comment:     "Test comment",
+				OwnerName:   "admin",
+				OwnerID:     "1234",
+				Public:      true,
+				SongCount:   10,
+				Duration:    600,
+				CreatedAt:   createdAt,
+				UpdatedAt:   updatedAt,
+				EvaluatedAt: &evaluatedAt,
+				Rules: &criteria.Criteria{
+					Expression: criteria.All{criteria.Contains{"title": "title"}},
+				},
+			}
 		})
 
-		It("returns all fields", func() {
-			result := router.buildPlaylist(ctx, playlist)
+		Context("with minimal client", func() {
+			BeforeEach(func() {
+				conf.Server.Subsonic.MinimalClients = "minimal-client"
+				player := model.Player{Client: "minimal-client"}
+				ctx = request.WithPlayer(ctx, player)
+			})
 
-			Expect(result.Id).To(Equal("pls-1"))
-			Expect(result.Name).To(Equal("My Playlist"))
-			Expect(result.SongCount).To(Equal(int32(10)))
-			Expect(result.Duration).To(Equal(int32(600)))
-			Expect(result.Created).To(Equal(playlist.CreatedAt))
-			Expect(result.Changed).To(Equal(playlist.UpdatedAt))
-			Expect(result.Comment).To(Equal("Test comment"))
-			Expect(result.Owner).To(Equal("admin"))
-			Expect(result.Public).To(BeTrue())
+			It("returns only basic fields", func() {
+				result := router.buildPlaylist(ctx, playlist)
+
+				Expect(result.Id).To(Equal("pls-1"))
+				Expect(result.Name).To(Equal("My Playlist"))
+				Expect(result.SongCount).To(Equal(int32(10)))
+				Expect(result.Duration).To(Equal(int32(600)))
+				Expect(result.Created).To(Equal(playlist.CreatedAt))
+				Expect(result.Changed).To(Equal(evaluatedAt))
+
+				// These should not be set
+				Expect(result.Comment).To(BeEmpty())
+				Expect(result.Owner).To(BeEmpty())
+				Expect(result.Public).To(BeFalse())
+				Expect(result.CoverArt).To(BeEmpty())
+				Expect(result.OpenSubsonicPlaylist).To(BeNil())
+			})
+		})
+
+		Context("with non-minimal client", func() {
+			BeforeEach(func() {
+				conf.Server.Subsonic.MinimalClients = "minimal-client"
+				player := model.Player{Client: "regular-client"}
+				ctx = request.WithPlayer(ctx, player)
+			})
+
+			It("returns all fields", func() {
+				result := router.buildPlaylist(ctx, playlist)
+				Expect(result.Id).To(Equal("pls-1"))
+				Expect(result.Name).To(Equal("My Playlist"))
+				Expect(result.SongCount).To(Equal(int32(10)))
+				Expect(result.Duration).To(Equal(int32(600)))
+				Expect(result.Created).To(Equal(playlist.CreatedAt))
+				Expect(result.Changed).To(Equal(*playlist.EvaluatedAt))
+				Expect(result.Comment).To(Equal("Test comment"))
+				Expect(result.Owner).To(Equal("admin"))
+				Expect(result.Public).To(BeTrue())
+				Expect(result.Readonly).To(BeTrue())
+				Expect(result.ValidUntil).To(Equal(&validUntil))
+			})
 		})
 	})
-
-	Context("when minimal clients list is empty", func() {
-		BeforeEach(func() {
-			conf.Server.Subsonic.MinimalClients = ""
-			player := model.Player{Client: "any-client"}
-			ctx = request.WithPlayer(ctx, player)
-		})
-
-		It("returns all fields", func() {
-			result := router.buildPlaylist(ctx, playlist)
-
-			Expect(result.Comment).To(Equal("Test comment"))
-			Expect(result.Owner).To(Equal("admin"))
-			Expect(result.Public).To(BeTrue())
-		})
-	})
-
-	Context("when no player in context", func() {
-		It("returns all fields", func() {
-			result := router.buildPlaylist(ctx, playlist)
-
-			Expect(result.Comment).To(Equal("Test comment"))
-			Expect(result.Owner).To(Equal("admin"))
-			Expect(result.Public).To(BeTrue())
-		})
-	})
-
 })
 
 var _ = Describe("UpdatePlaylist", func() {

server/subsonic/responses/.snapshots/Responses Playlists with data should match .JSON

@@ -14,9 +14,20 @@
         "duration": 120,
         "public": true,
         "owner": "admin",
+        "created": "2023-02-20T14:45:00Z",
+        "changed": "2023-02-20T14:45:00Z",
+        "coverArt": "pl-123123123123",
+        "readonly": true,
+        "validUntil": "2023-02-20T14:45:00Z"
+      },
+      {
+        "id": "333",
+        "name": "ccc",
+        "songCount": 0,
+        "duration": 0,
         "created": "0001-01-01T00:00:00Z",
         "changed": "0001-01-01T00:00:00Z",
-        "coverArt": "pl-123123123123"
+        "readonly": false
       },
       {
         "id": "222",

server/subsonic/responses/.snapshots/Responses Playlists with data should match .XML

@@ -1,6 +1,7 @@
 <subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="v0.55.0" openSubsonic="true">
   <playlists>
-    <playlist id="111" name="aaa" comment="comment" songCount="2" duration="120" public="true" owner="admin" created="0001-01-01T00:00:00Z" changed="0001-01-01T00:00:00Z" coverArt="pl-123123123123"></playlist>
+    <playlist id="111" name="aaa" comment="comment" songCount="2" duration="120" public="true" owner="admin" created="2023-02-20T14:45:00Z" changed="2023-02-20T14:45:00Z" coverArt="pl-123123123123" readonly="true" validUntil="2023-02-20T14:45:00Z"></playlist>
+    <playlist id="333" name="ccc" songCount="0" duration="0" created="0001-01-01T00:00:00Z" changed="0001-01-01T00:00:00Z"></playlist>
     <playlist id="222" name="bbb" songCount="0" duration="0" created="0001-01-01T00:00:00Z" changed="0001-01-01T00:00:00Z"></playlist>
   </playlists>
 </subsonic-response>

server/subsonic/responses/responses.go

@@ -298,16 +298,17 @@ type AlbumList2 struct {
 }
 
 type Playlist struct {
-	Id        string    `xml:"id,attr"                       json:"id"`
-	Name      string    `xml:"name,attr"                     json:"name"`
-	Comment   string    `xml:"comment,attr,omitempty"        json:"comment,omitempty"`
-	SongCount int32     `xml:"songCount,attr"                json:"songCount"`
-	Duration  int32     `xml:"duration,attr"                 json:"duration"`
-	Public    bool      `xml:"public,attr,omitempty"         json:"public,omitempty"`
-	Owner     string    `xml:"owner,attr,omitempty"          json:"owner,omitempty"`
-	Created   time.Time `xml:"created,attr"                  json:"created"`
-	Changed   time.Time `xml:"changed,attr"                  json:"changed"`
-	CoverArt  string    `xml:"coverArt,attr,omitempty"       json:"coverArt,omitempty"`
+	Id                    string    `xml:"id,attr"                       json:"id"`
+	Name                  string    `xml:"name,attr"                     json:"name"`
+	Comment               string    `xml:"comment,attr,omitempty"        json:"comment,omitempty"`
+	SongCount             int32     `xml:"songCount,attr"                json:"songCount"`
+	Duration              int32     `xml:"duration,attr"                 json:"duration"`
+	Public                bool      `xml:"public,attr,omitempty"         json:"public,omitempty"`
+	Owner                 string    `xml:"owner,attr,omitempty"          json:"owner,omitempty"`
+	Created               time.Time `xml:"created,attr"                  json:"created"`
+	Changed               time.Time `xml:"changed,attr"                  json:"changed"`
+	CoverArt              string    `xml:"coverArt,attr,omitempty"       json:"coverArt,omitempty"`
+	*OpenSubsonicPlaylist `xml:",omitempty" json:",omitempty"`
 	/*
 		<xs:sequence>
 		    <xs:element name="allowedUser" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> <!--Added in 1.8.0-->
@@ -315,6 +316,11 @@ type Playlist struct {
 	*/
 }
 
+type OpenSubsonicPlaylist struct {
+	Readonly   bool       `xml:"readonly,attr,omitempty"   json:"readonly"`
+	ValidUntil *time.Time `xml:"validUntil,attr,omitempty" json:"validUntil,omitempty"`
+}
+
 type Playlists struct {
 	Playlist []Playlist `xml:"playlist"                           json:"playlist,omitempty"`
 }

server/subsonic/responses/responses_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/server/subsonic/responses"
 	. "github.com/navidrome/navidrome/server/subsonic/responses"
 	"github.com/navidrome/navidrome/utils/gg"
 	. "github.com/onsi/ginkgo/v2"
@@ -531,9 +532,9 @@ var _ = Describe("Responses", func() {
 		})
 
 		Context("with data", func() {
-			timestamp, _ := time.Parse(time.RFC3339, "2020-04-11T16:43:00Z04:00")
+			timestamp := time.Date(2023, 2, 20, 14, 45, 0, 0, time.UTC)
 			BeforeEach(func() {
-				pls := make([]Playlist, 2)
+				pls := make([]Playlist, 3)
 				pls[0] = Playlist{
 					Id:        "111",
 					Name:      "aaa",
@@ -545,8 +546,13 @@ var _ = Describe("Responses", func() {
 					CoverArt:  "pl-123123123123",
 					Created:   timestamp,
 					Changed:   timestamp,
+					OpenSubsonicPlaylist: &responses.OpenSubsonicPlaylist{
+						Readonly:   true,
+						ValidUntil: &timestamp,
+					},
 				}
-				pls[1] = Playlist{Id: "222", Name: "bbb"}
+				pls[1] = Playlist{Id: "333", Name: "ccc", OpenSubsonicPlaylist: &responses.OpenSubsonicPlaylist{}}
+				pls[2] = Playlist{Id: "222", Name: "bbb"}
 				response.Playlists.Playlist = pls
 			})
 

tests/mock_mediafile_repo.go

@@ -44,16 +44,12 @@ func (m *MockMediaFileRepo) SetData(mfs model.MediaFiles) {
 	}
 }
 
-func (m *MockMediaFileRepo) Exists(ids ...string) (bool, error) {
+func (m *MockMediaFileRepo) Exists(id string) (bool, error) {
 	if m.Err {
 		return false, errors.New("error")
 	}
-	for _, id := range ids {
-		if _, found := m.Data[id]; !found {
-			return false, nil
-		}
-	}
-	return true, nil
+	_, found := m.Data[id]
+	return found, nil
 }
 
 func (m *MockMediaFileRepo) Get(id string) (*model.MediaFile, error) {