Add lastUpdated to `coverArt` ids. Helps with invalidating art cache client-side.

core/artwork/artwork.go

@@ -73,6 +73,10 @@ func (a *artwork) Get(ctx context.Context, artID model.ArtworkID, size int) (rea
 	return r, artReader.LastUpdated(), nil
 }
 
+type coverArtGetter interface {
+	CoverArtID() model.ArtworkID
+}
+
 func (a *artwork) getArtworkId(ctx context.Context, id string) (model.ArtworkID, error) {
 	if id == "" {
 		return model.ArtworkID{}, ErrUnavailable
@@ -87,18 +91,17 @@ func (a *artwork) getArtworkId(ctx context.Context, id string) (model.ArtworkID,
 	if err != nil {
 		return model.ArtworkID{}, err
 	}
+	if e, ok := entity.(coverArtGetter); ok {
+		artID = e.CoverArtID()
+	}
 	switch e := entity.(type) {
 	case *model.Artist:
-		artID = model.NewArtworkID(model.KindArtistArtwork, e.ID)
 		log.Trace(ctx, "ID is for an Artist", "id", id, "name", e.Name, "artist", e.Name)
 	case *model.Album:
-		artID = model.NewArtworkID(model.KindAlbumArtwork, e.ID)
 		log.Trace(ctx, "ID is for an Album", "id", id, "name", e.Name, "artist", e.AlbumArtist)
 	case *model.MediaFile:
-		artID = model.NewArtworkID(model.KindMediaFileArtwork, e.ID)
 		log.Trace(ctx, "ID is for a MediaFile", "id", id, "title", e.Title, "album", e.Album)
 	case *model.Playlist:
-		artID = model.NewArtworkID(model.KindPlaylistArtwork, e.ID)
 		log.Trace(ctx, "ID is for a Playlist", "id", id, "name", e.Name)
 	}
 	return artID, nil

core/artwork/artwork_internal_test.go

@@ -49,7 +49,7 @@ var _ = Describe("Artwork", func() {
 	Describe("albumArtworkReader", func() {
 		Context("ID not found", func() {
 			It("returns ErrNotFound if album is not in the DB", func() {
-				_, err := newAlbumArtworkReader(ctx, aw, model.MustParseArtworkID("al-NOT_FOUND"), nil)
+				_, err := newAlbumArtworkReader(ctx, aw, model.MustParseArtworkID("al-NOT-FOUND"), nil)
 				Expect(err).To(MatchError(model.ErrNotFound))
 			})
 		})
@@ -157,14 +157,14 @@ var _ = Describe("Artwork", func() {
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(path).To(Equal("al-444"))
+				Expect(path).To(Equal("al-444_0"))
 			})
 			It("returns album cover if media file has no cover art", func() {
 				aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfWithoutEmbed.ID))
 				Expect(err).ToNot(HaveOccurred())
 				_, path, err := aw.Reader(ctx)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(path).To(Equal("al-444"))
+				Expect(path).To(Equal("al-444_0"))
 			})
 		})
 	})

core/artwork/image_cache.go

@@ -20,8 +20,9 @@ type cacheKey struct {
 
 func (k *cacheKey) Key() string {
 	return fmt.Sprintf(
-		"%s.%d",
+		"%s-%s.%d",
-		k.artID,
+		k.artID.Kind,
+		k.artID.ID,
 		k.lastUpdate.UnixMilli(),
 	)
 }

model/artwork_id.go

@@ -3,7 +3,9 @@ package model
 import (
 	"errors"
 	"fmt"
+	"strconv"
 	"strings"
+	"time"
 )
 
 type Kind struct {
@@ -30,19 +32,28 @@ var artworkKindMap = map[string]Kind{
 }
 
 type ArtworkID struct {
-	Kind Kind
+	Kind       Kind
-	ID   string
+	ID         string
+	LastUpdate time.Time
 }
 
 func (id ArtworkID) String() string {
 	if id.ID == "" {
 		return ""
 	}
-	return fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)
+	s := fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)
+	if lu := id.LastUpdate.Unix(); lu > 0 {
+		return fmt.Sprintf("%s_%x", s, lu)
+	}
+	return s + "_0"
 }
 
-func NewArtworkID(kind Kind, id string) ArtworkID {
+func NewArtworkID(kind Kind, id string, lastUpdate *time.Time) ArtworkID {
-	return ArtworkID{kind, id}
+	artID := ArtworkID{kind, id, time.Time{}}
+	if lastUpdate != nil {
+		artID.LastUpdate = *lastUpdate
+	}
+	return artID
 }
 
 func ParseArtworkID(id string) (ArtworkID, error) {
@@ -50,14 +61,26 @@ func ParseArtworkID(id string) (ArtworkID, error) {
 	if len(parts) != 2 {
 		return ArtworkID{}, errors.New("invalid artwork id")
 	}
-	if kind, ok := artworkKindMap[parts[0]]; !ok {
+	kind, ok := artworkKindMap[parts[0]]
+	if !ok {
 		return ArtworkID{}, errors.New("invalid artwork kind")
-	} else {
-		return ArtworkID{
-			Kind: kind,
-			ID:   parts[1],
-		}, nil
 	}
+	parsedID := ArtworkID{
+		Kind: kind,
+		ID:   parts[1],
+	}
+	parts = strings.SplitN(parts[1], "_", 2)
+	if len(parts) == 2 {
+		if parts[1] != "0" {
+			lastUpdate, err := strconv.ParseInt(parts[1], 16, 64)
+			if err != nil {
+				return ArtworkID{}, err
+			}
+			parsedID.LastUpdate = time.Unix(lastUpdate, 0)
+		}
+		parsedID.ID = parts[0]
+	}
+	return parsedID, nil
 }
 
 func MustParseArtworkID(id string) ArtworkID {
@@ -70,22 +93,25 @@ func MustParseArtworkID(id string) ArtworkID {
 
 func artworkIDFromAlbum(al Album) ArtworkID {
 	return ArtworkID{
-		Kind: KindAlbumArtwork,
+		Kind:       KindAlbumArtwork,
-		ID:   al.ID,
+		ID:         al.ID,
+		LastUpdate: al.UpdatedAt,
 	}
 }
 
 func artworkIDFromMediaFile(mf MediaFile) ArtworkID {
 	return ArtworkID{
-		Kind: KindMediaFileArtwork,
+		Kind:       KindMediaFileArtwork,
-		ID:   mf.ID,
+		ID:         mf.ID,
+		LastUpdate: mf.UpdatedAt,
 	}
 }
 
 func artworkIDFromPlaylist(pls Playlist) ArtworkID {
 	return ArtworkID{
-		Kind: KindPlaylistArtwork,
+		Kind:       KindPlaylistArtwork,
-		ID:   pls.ID,
+		ID:         pls.ID,
+		LastUpdate: pls.UpdatedAt,
 	}
 }
 

model/artwork_id_test.go

@@ -1,36 +1,59 @@
 package model_test
 
 import (
+	"time"
+
 	"github.com/navidrome/navidrome/model"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("ParseArtworkID()", func() {
+var _ = Describe("ArtworkID", func() {
-	It("parses album artwork ids", func() {
+	Describe("NewArtworkID()", func() {
-		id, err := model.ParseArtworkID("al-1234")
+		It("creates a valid parseable ArtworkID", func() {
-		Expect(err).ToNot(HaveOccurred())
+			now := time.Now()
-		Expect(id.Kind).To(Equal(model.KindAlbumArtwork))
+			id := model.NewArtworkID(model.KindAlbumArtwork, "1234", &now)
-		Expect(id.ID).To(Equal("1234"))
+			parsedId, err := model.ParseArtworkID(id.String())
+			Expect(err).ToNot(HaveOccurred())
+			Expect(parsedId.Kind).To(Equal(id.Kind))
+			Expect(parsedId.ID).To(Equal(id.ID))
+			Expect(parsedId.LastUpdate.Unix()).To(Equal(id.LastUpdate.Unix()))
+		})
+		It("creates a valid ArtworkID without lastUpdate info", func() {
+			id := model.NewArtworkID(model.KindPlaylistArtwork, "1234", nil)
+			parsedId, err := model.ParseArtworkID(id.String())
+			Expect(err).ToNot(HaveOccurred())
+			Expect(parsedId.Kind).To(Equal(id.Kind))
+			Expect(parsedId.ID).To(Equal(id.ID))
+			Expect(parsedId.LastUpdate.Unix()).To(Equal(id.LastUpdate.Unix()))
+		})
 	})
-	It("parses media file artwork ids", func() {
+	Describe("ParseArtworkID()", func() {
-		id, err := model.ParseArtworkID("mf-a6f8d2b1")
+		It("parses album artwork ids", func() {
-		Expect(err).ToNot(HaveOccurred())
+			id, err := model.ParseArtworkID("al-1234")
-		Expect(id.Kind).To(Equal(model.KindMediaFileArtwork))
+			Expect(err).ToNot(HaveOccurred())
-		Expect(id.ID).To(Equal("a6f8d2b1"))
+			Expect(id.Kind).To(Equal(model.KindAlbumArtwork))
-	})
+			Expect(id.ID).To(Equal("1234"))
-	It("parses playlists artwork ids", func() {
+		})
-		id, err := model.ParseArtworkID("pl-18690de0-151b-4d86-81cb-f418a907315a")
+		It("parses media file artwork ids", func() {
-		Expect(err).ToNot(HaveOccurred())
+			id, err := model.ParseArtworkID("mf-a6f8d2b1")
-		Expect(id.Kind).To(Equal(model.KindPlaylistArtwork))
+			Expect(err).ToNot(HaveOccurred())
-		Expect(id.ID).To(Equal("18690de0-151b-4d86-81cb-f418a907315a"))
+			Expect(id.Kind).To(Equal(model.KindMediaFileArtwork))
-	})
+			Expect(id.ID).To(Equal("a6f8d2b1"))
-	It("fails to parse malformed ids", func() {
+		})
-		_, err := model.ParseArtworkID("a6f8d2b1")
+		It("parses playlists artwork ids", func() {
-		Expect(err).To(MatchError("invalid artwork id"))
+			id, err := model.ParseArtworkID("pl-18690de0-151b-4d86-81cb-f418a907315a")
-	})
+			Expect(err).ToNot(HaveOccurred())
-	It("fails to parse ids with invalid kind", func() {
+			Expect(id.Kind).To(Equal(model.KindPlaylistArtwork))
-		_, err := model.ParseArtworkID("xx-a6f8d2b1")
+			Expect(id.ID).To(Equal("18690de0-151b-4d86-81cb-f418a907315a"))
-		Expect(err).To(MatchError("invalid artwork kind"))
+		})
+		It("fails to parse malformed ids", func() {
+			_, err := model.ParseArtworkID("a6f8d2b1")
+			Expect(err).To(MatchError("invalid artwork id"))
+		})
+		It("fails to parse ids with invalid kind", func() {
+			_, err := model.ParseArtworkID("xx-a6f8d2b1")
+			Expect(err).To(MatchError("invalid artwork kind"))
+		})
 	})
 })

server/public/encode_id_test.go

@@ -14,7 +14,7 @@ var _ = Describe("encodeArtworkID", func() {
 			auth.TokenAuth = jwtauth.New("HS256", []byte("super secret"), nil)
 		})
 		It("returns a reversible string representation", func() {
-			id := model.NewArtworkID(model.KindArtistArtwork, "1234")
+			id := model.NewArtworkID(model.KindArtistArtwork, "1234", nil)
 			encoded := encodeArtworkID(id)
 			decoded, err := decodeArtworkID(encoded)
 			Expect(err).ToNot(HaveOccurred())