nik/navidrome
1
0
Fork 0
mirror of https://github.com/navidrome/navidrome.git synced 2026-08-01 07:21:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(model): content-hash artwork id suffix and hydratable per-entity image state

Browse Source
This commit is contained in:
Deluan 2026-07-22 20:06:13 -04:00
parent 39e939686b
commit 3b7cbf41dd
11 changed files with 115 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
core/artwork/artwork_internal_test.go
View File

@ -281,14 +281,14 @@ var _ = Describe("Artwork", func() {
Expect(err).ToNot(HaveOccurred())
_, path, err := aw.Reader(ctx)
Expect(err).ToNot(HaveOccurred())
Expect(path).To(Equal("al-444_0"))
Expect(path).To(Equal("al-444"))
})
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_0"))
Expect(path).To(Equal("al-444"))
})
It("falls back to disc cover art when media file has a disc number on a multi-disc album", func() {
mfWithDisc := model.MediaFile{ID: "46", Path: "tests/fixtures/test.ogg", AlbumID: "444", DiscNumber: 2}
@ -299,7 +299,7 @@ var _ = Describe("Artwork", func() {
_, path, err := aw.Reader(ctx)
Expect(err).ToNot(HaveOccurred())
// Should fall back to disc art, which itself falls back to album art
Expect(path).To(Equal("dc-444:2_0"))
Expect(path).To(Equal("dc-444:2"))
})
It("falls back to album cover art for single-disc albums even with a disc number", func() {
mfOnSingleDisc := model.MediaFile{ID: "47", Path: "tests/fixtures/test.ogg", AlbumID: "888", DiscNumber: 1}
@ -310,7 +310,7 @@ var _ = Describe("Artwork", func() {
_, path, err := aw.Reader(ctx)
Expect(err).ToNot(HaveOccurred())
// Single-disc album should skip disc art and go straight to album art
Expect(path).To(Equal("al-888_0"))
Expect(path).To(Equal("al-888"))
})
})
})

1
model/album.go
View File

@ -13,6 +13,7 @@ import (
type Album struct {
Annotations `structs:"-" hash:"ignore"`
ItemImage `structs:"-" json:"-" hash:"ignore"`
ID string `structs:"id" json:"id"`
LibraryID int `structs:"library_id" json:"libraryId"`

1
model/artist.go
View File

@ -11,6 +11,7 @@ import (
type Artist struct {
Annotations `structs:"-"`
ItemImage `structs:"-" json:"-"`
ID string `structs:"id" json:"id"`

7
model/artwork.go
View File

@ -15,6 +15,13 @@ type Artwork struct {
const ImageTypePrimary = "primary"
// ItemImage is per-entity artwork state hydrated at query time; never persisted
// (structs:"-" keeps it out of upserts) nor exposed via the native API (json:"-").
type ItemImage struct {
ImageHash string `structs:"-" json:"-"`
ImageAbsent bool `structs:"-" json:"-"`
}
// ItemArtwork is an entity's resolved artwork state. Hash=="" means known absent.
type ItemArtwork struct {
ItemKind string `structs:"item_kind"`

70
model/artwork_id.go
View File

@ -38,7 +38,8 @@ var artworkKindMap = map[string]Kind{
type ArtworkID struct {
Kind Kind
ID string
LastUpdate time.Time
Hash string // content-hash suffix; "" = unknown/none
LastUpdate time.Time // legacy: populated only when parsing old _<hexTimestamp> tokens
}
func (id ArtworkID) String() string {
@ -46,14 +47,14 @@ func (id ArtworkID) String() string {
return ""
}
s := fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)
if lu := id.LastUpdate.Unix(); lu > 0 {
return fmt.Sprintf("%s_%x", s, lu)
if id.Hash != "" {
return s + "_" + id.Hash
}
return s + "_0"
return s
}
func NewArtworkID(kind Kind, id string, lastUpdate *time.Time) ArtworkID {
artID := ArtworkID{kind, id, time.Time{}}
artID := ArtworkID{Kind: kind, ID: id}
if lastUpdate != nil {
artID.LastUpdate = *lastUpdate
}
@ -75,18 +76,34 @@ func ParseArtworkID(id string) (ArtworkID, error) {
}
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]
suffix := parts[1]
switch {
// Hash detection must come first: a 16-hex value with the high bit set overflows int64.
case isImageHash(suffix):
parsedID.Hash = suffix
case suffix != "0":
if lastUpdate, err := strconv.ParseInt(suffix, 16, 64); err == nil {
parsedID.LastUpdate = time.Unix(lastUpdate, 0)
}
}
}
return parsedID, nil
}
// isImageHash reports whether s is a 16-char lowercase-hex XXH3-64 content hash.
func isImageHash(s string) bool {
if len(s) != 16 {
return false
}
for _, c := range s {
if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
return false
}
}
return true
}
func MustParseArtworkID(id string) ArtworkID {
artID, err := ParseArtworkID(id)
if err != nil {
@ -112,40 +129,21 @@ func ParseDiscArtworkID(id string) (albumID string, discNumber int, err error) {
}
func artworkIDFromAlbum(al Album) ArtworkID {
return ArtworkID{
Kind: KindAlbumArtwork,
ID: al.ID,
LastUpdate: al.UpdatedAt,
}
return ArtworkID{Kind: KindAlbumArtwork, ID: al.ID, Hash: al.ImageHash}
}
func artworkIDFromMediaFile(mf MediaFile) ArtworkID {
return ArtworkID{
Kind: KindMediaFileArtwork,
ID: mf.ID,
LastUpdate: mf.UpdatedAt,
}
return ArtworkID{Kind: KindMediaFileArtwork, ID: mf.ID, Hash: mf.ImageHash}
}
func artworkIDFromPlaylist(pls Playlist) ArtworkID {
return ArtworkID{
Kind: KindPlaylistArtwork,
ID: pls.ID,
LastUpdate: pls.UpdatedAt,
}
return ArtworkID{Kind: KindPlaylistArtwork, ID: pls.ID, Hash: pls.ImageHash}
}
func artworkIDFromArtist(ar Artist) ArtworkID {
return ArtworkID{
Kind: KindArtistArtwork,
ID: ar.ID,
}
return ArtworkID{Kind: KindArtistArtwork, ID: ar.ID, Hash: ar.ImageHash}
}
func artworkIDFromRadio(r Radio) ArtworkID {
return ArtworkID{
Kind: KindRadioArtwork,
ID: r.ID,
LastUpdate: r.UpdatedAt,
}
return ArtworkID{Kind: KindRadioArtwork, ID: r.ID, Hash: r.ImageHash}
}

63
model/artwork_id_test.go
View File

@ -9,14 +9,31 @@ import (
)
var _ = Describe("ArtworkID", func() {
Describe("String()", func() {
It("returns a bare id when there is no hash", func() {
id := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1234"}
Expect(id.String()).To(Equal("al-1234"))
})
It("appends the hash suffix when set", func() {
id := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1234", Hash: "abcdef0123456789"}
Expect(id.String()).To(Equal("al-1234_abcdef0123456789"))
})
It("never emits a legacy timestamp/_0 suffix", func() {
id := model.NewArtworkID(model.KindAlbumArtwork, "1234", new(time.Now()))
Expect(id.String()).To(Equal("al-1234"))
})
It("returns empty string for an empty id", func() {
Expect(model.ArtworkID{Kind: model.KindAlbumArtwork}.String()).To(BeEmpty())
})
})
Describe("NewArtworkID()", func() {
It("creates a valid parseable ArtworkID", func() {
It("round-trips Kind and ID through String()", func() {
id := model.NewArtworkID(model.KindAlbumArtwork, "1234", new(time.Now()))
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)
@ -24,18 +41,16 @@ var _ = Describe("ArtworkID", func() {
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()))
})
})
Describe("ParseArtworkID - disc kind", func() {
It("parses a disc artwork ID with dc prefix", func() {
now := time.Now()
id := model.NewArtworkID(model.KindDiscArtwork, "albumid123:2", &now)
id := model.NewArtworkID(model.KindDiscArtwork, "albumid123:2", nil)
parsedId, err := model.ParseArtworkID(id.String())
Expect(err).ToNot(HaveOccurred())
Expect(parsedId.Kind).To(Equal(model.KindDiscArtwork))
Expect(parsedId.ID).To(Equal("albumid123:2"))
Expect(parsedId.LastUpdate.Unix()).To(Equal(now.Unix()))
})
})
@ -67,6 +82,7 @@ var _ = Describe("ArtworkID", func() {
Expect(err).ToNot(HaveOccurred())
Expect(id.Kind).To(Equal(model.KindAlbumArtwork))
Expect(id.ID).To(Equal("1234"))
Expect(id.Hash).To(BeEmpty())
})
It("parses media file artwork ids", func() {
id, err := model.ParseArtworkID("mf-a6f8d2b1")
@ -74,12 +90,45 @@ var _ = Describe("ArtworkID", func() {
Expect(id.Kind).To(Equal(model.KindMediaFileArtwork))
Expect(id.ID).To(Equal("a6f8d2b1"))
})
It("parses playlists artwork ids", func() {
It("parses playlist artwork ids with dashed UUID", func() {
id, err := model.ParseArtworkID("pl-18690de0-151b-4d86-81cb-f418a907315a")
Expect(err).ToNot(HaveOccurred())
Expect(id.Kind).To(Equal(model.KindPlaylistArtwork))
Expect(id.ID).To(Equal("18690de0-151b-4d86-81cb-f418a907315a"))
})
It("captures a 16-hex suffix as Hash", func() {
id, err := model.ParseArtworkID("al-1234_abcdef0123456789")
Expect(err).ToNot(HaveOccurred())
Expect(id.ID).To(Equal("1234"))
Expect(id.Hash).To(Equal("abcdef0123456789"))
Expect(id.LastUpdate.IsZero()).To(BeTrue())
})
It("captures a high-bit 16-hex suffix as Hash without error", func() {
id, err := model.ParseArtworkID("al-1234_ffffffffffffffff")
Expect(err).ToNot(HaveOccurred())
Expect(id.ID).To(Equal("1234"))
Expect(id.Hash).To(Equal("ffffffffffffffff"))
})
It("parses a legacy hex-timestamp suffix as LastUpdate", func() {
id, err := model.ParseArtworkID("al-123_688a1b2c")
Expect(err).ToNot(HaveOccurred())
Expect(id.ID).To(Equal("123"))
Expect(id.Hash).To(BeEmpty())
Expect(id.LastUpdate.Unix()).To(Equal(int64(0x688a1b2c)))
})
It("parses a legacy _0 suffix", func() {
id, err := model.ParseArtworkID("al-123_0")
Expect(err).ToNot(HaveOccurred())
Expect(id.ID).To(Equal("123"))
Expect(id.Hash).To(BeEmpty())
Expect(id.LastUpdate.IsZero()).To(BeTrue())
})
It("silently drops a garbage suffix", func() {
id, err := model.ParseArtworkID("al-123_zz")
Expect(err).ToNot(HaveOccurred())
Expect(id.ID).To(Equal("123"))
Expect(id.Hash).To(BeEmpty())
})
It("fails to parse malformed ids", func() {
_, err := model.ParseArtworkID("a6f8d2b1")
Expect(err).To(MatchError("invalid artwork id"))

7
model/mediafile.go
View File

@ -24,6 +24,7 @@ import (
type MediaFile struct {
Annotations `structs:"-" hash:"ignore"`
Bookmarkable `structs:"-" hash:"ignore"`
ItemImage `structs:"-" json:"-" hash:"ignore"`
ID string `structs:"id" json:"id" hash:"ignore"`
PID string `structs:"pid" json:"-" hash:"ignore"`
@ -139,13 +140,15 @@ func (mf MediaFile) CoverArtID() ArtworkID {
// otherwise it returns the album artwork ID.
func (mf MediaFile) DiscCoverArtID() ArtworkID {
if mf.DiscNumber > 0 {
return NewArtworkID(KindDiscArtwork, DiscArtworkID(mf.AlbumID, mf.DiscNumber), nil)
id := NewArtworkID(KindDiscArtwork, DiscArtworkID(mf.AlbumID, mf.DiscNumber), nil)
id.Hash = mf.ImageHash
return id
}
return mf.AlbumCoverArtID()
}
func (mf MediaFile) AlbumCoverArtID() ArtworkID {
return artworkIDFromAlbum(Album{ID: mf.AlbumID})
return artworkIDFromAlbum(Album{ID: mf.AlbumID, ItemImage: mf.ItemImage})
}
func (mf MediaFile) StructuredLyrics() (LyricList, error) {

1
model/playlist.go
View File

@ -13,6 +13,7 @@ import (
type Playlist struct {
Annotations `structs:"-"`
ItemImage `structs:"-" json:"-"`
ID string `structs:"id" json:"id"`
Name string `structs:"name" json:"name"`

2
model/radio.go
View File

@ -7,6 +7,8 @@ import (
)
type Radio struct {
ItemImage `structs:"-" json:"-"`
ID string `structs:"id" json:"id"`
StreamUrl string `structs:"stream_url" json:"streamUrl"`
Name string `structs:"name" json:"name"`

5
model/radio_test.go
View File

@ -14,12 +14,11 @@ import (
var _ = Describe("Radio", func() {
Describe("CoverArtID", func() {
It("returns a radio artwork ID", func() {
now := time.Now()
r := model.Radio{ID: "rd-1", UpdatedAt: now}
r := model.Radio{ID: "rd-1", UpdatedAt: time.Now()}
artID := r.CoverArtID()
Expect(artID.Kind).To(Equal(model.KindRadioArtwork))
Expect(artID.ID).To(Equal("rd-1"))
Expect(artID.LastUpdate).To(Equal(now))
Expect(artID.LastUpdate.IsZero()).To(BeTrue())
})
})

4
server/subsonic/radio_test.go
View File

@ -71,7 +71,7 @@ var _ = Describe("Radio", func() {
Expect(err).ToNot(HaveOccurred())
Expect(response.InternetRadioStations.Radios).To(HaveLen(2))
Expect(response.InternetRadioStations.Radios[0].OpenSubsonicRadio).ToNot(BeNil())
Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0"))
Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1"))
Expect(response.InternetRadioStations.Radios[1].OpenSubsonicRadio).ToNot(BeNil())
Expect(response.InternetRadioStations.Radios[1].CoverArt).To(BeEmpty())
})
@ -129,7 +129,7 @@ var _ = Describe("Radio", func() {
Expect(err).ToNot(HaveOccurred())
Expect(response.InternetRadioStations.Radios[0].OpenSubsonicRadio).ToNot(BeNil())
Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0"))
Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1"))
})
})