fix(maintenance): sweep artist_metadata rows nothing references

artist_metadata was classified Cache/Swept but had no sweep and no
DELETE anywhere, so long-lived entity data (no TTL by design) grew for
the life of the install.  Sweep rows whose MBID is neither a library
artist nor holding cached artwork, and register the job with the
janitor.

Closes #248

backend/app.go

@@ -775,6 +775,7 @@ func (yj *YellowJacketApp) startJanitor() {
 	}
 
 	yj.janitor.Register(maintenance.ExpiredHTTPCacheJob(yj.database))
+	yj.janitor.Register(maintenance.StaleArtistMetadataJob(yj.database))
 	yj.janitor.Register(maintenance.OrphanedCoverFilesJob(
 		yj.database, coversDir, library.CoverArtFileSet,
 	))

backend/library/coverart.go

@@ -3,7 +3,6 @@ package library
 import (
 	"bytes"
 	"crypto/sha256"
-	"database/sql"
 	"encoding/hex"
 	"fmt"
 	"image"
@@ -70,77 +69,6 @@ func CoverArtFileSet(coverPath string) []string {
 	return paths
 }
 
-// sweepOrphanedCoverArt deletes the cover_art rows no album references
-// and returns their file paths, for the caller to remove from disk
-// after the transaction commits.  Cover art is referenced only by
-// albums.cover_art_id, so an orphan is a cover whose album is gone —
-// which is every album the caller just swept.
-//
-// One implementation because the scan path, RemoveFromLibrary and
-// RemoveLibrary all reach this state, and the scan side used to skip it
-// entirely while RemoveLibrary did it inline (#247).
-func (l *Library) sweepOrphanedCoverArt(tx *sql.Tx) ([]string, error) {
-	const orphanSQL = `
-		SELECT file_path FROM cover_art WHERE id NOT IN (
-			SELECT DISTINCT cover_art_id FROM albums
-			WHERE cover_art_id IS NOT NULL
-		)`
-
-	rows, err := tx.QueryContext(l.ctx, orphanSQL)
-	if err != nil {
-		return nil, fmt.Errorf("could not query orphaned cover art: %w", err)
-	}
-
-	var paths []string
-
-	for rows.Next() {
-		var filePath string
-
-		if err := rows.Scan(&filePath); err != nil {
-			l.logger.Warn("could not scan cover art path", "err", err)
-
-			continue
-		}
-
-		paths = append(paths, filePath)
-	}
-
-	// Close before the DELETE: the two run on the one writer connection.
-	if err := rows.Close(); err != nil {
-		l.logger.Warn("could not close cover art rows", "err", err)
-	}
-
-	if len(paths) > 0 {
-		if _, err := tx.ExecContext(l.ctx, `
-			DELETE FROM cover_art WHERE id NOT IN (
-				SELECT DISTINCT cover_art_id FROM albums
-				WHERE cover_art_id IS NOT NULL
-			)`); err != nil {
-			return nil, fmt.Errorf("could not delete orphaned cover_art: %w", err)
-		}
-	}
-
-	return paths, nil
-}
-
-// removeCoverArtFiles removes a cover original and its derived size
-// variants.  Only the original is stored in cover_art.file_path; the
-// _sm/_md/_lg tiers are derived filenames beside it, so they have to be
-// removed by name or they accumulate forever.
-func (l *Library) removeCoverArtFiles(coverPaths []string) {
-	for _, coverPath := range coverPaths {
-		for _, path := range CoverArtFileSet(coverPath) {
-			if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
-				l.logger.Warn(
-					"could not remove orphaned cover art file",
-					"path", path,
-					"err", err,
-				)
-			}
-		}
-	}
-}
-
 // saveCoverArt saves embedded cover art to the cache directory.
 // Returns the file path where the art was saved, or empty string
 // if no picture data.  Timing is recorded in the provided metrics.

backend/library/crud.go

@@ -320,12 +320,43 @@ func (l *Library) RemoveLibrary(id int64) (*RemovalSummary, error) {
 
 	genresRemoved, _ := result.RowsAffected()
 
-	// Collect and delete orphaned cover_art rows before the commit.  The
-	// shared helper is the one place this sweep lives, so the scan path,
-	// RemoveFromLibrary and this removal cannot drift (#247).
-	orphanedCoverArtPaths, err := l.sweepOrphanedCoverArt(tx)
+	// 15. Collect orphaned cover_art file paths for post-commit cleanup.
+	// SAFETY: Hand-crafted SELECT for orphaned cover art identification.
+	// Parameterless.
+	rows, err := tx.QueryContext(l.ctx,
+		`SELECT file_path FROM cover_art WHERE id NOT IN (
+			SELECT DISTINCT cover_art_id FROM albums
+			WHERE cover_art_id IS NOT NULL
+		)`)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("could not query orphaned cover art: %w", err)
+	}
+
+	var orphanedCoverArtPaths []string
+
+	for rows.Next() {
+		var filePath string
+		if err := rows.Scan(&filePath); err != nil {
+			l.logger.Warn("could not scan cover art path", "err", err)
+
+			continue
+		}
+
+		orphanedCoverArtPaths = append(orphanedCoverArtPaths, filePath)
+	}
+
+	if err := rows.Close(); err != nil {
+		l.logger.Warn("could not close cover art rows", "err", err)
+	}
+
+	// 16. Delete orphaned cover_art rows.
+	// SAFETY: Hand-crafted orphan cleanup SQL. Parameterless.
+	if _, err := tx.ExecContext(l.ctx,
+		`DELETE FROM cover_art WHERE id NOT IN (
+			SELECT DISTINCT cover_art_id FROM albums
+			WHERE cover_art_id IS NOT NULL
+		)`); err != nil {
+		return nil, fmt.Errorf("could not delete orphaned cover_art: %w", err)
 	}
 
 	// 17. Delete the library's tagging queue.  tagging_items holds a
@@ -361,9 +392,20 @@ func (l *Library) RemoveLibrary(id int64) (*RemovalSummary, error) {
 	// avoids a costly full re-index of all remaining tracks (~10s for
 	// 25K tracks).
 
-	// Post-commit: remove the orphaned cover art files and their sized
-	// variants.
-	l.removeCoverArtFiles(orphanedCoverArtPaths)
+	// 21. Post-commit: Delete orphaned cover art files and their sized
+	// variants.  Only the original is stored in cover_art.file_path; the
+	// _sm/_md/_lg thumbnails are derived filenames beside it, so they
+	// have to be removed by name or they accumulate forever.
+	for _, coverPath := range orphanedCoverArtPaths {
+		for _, path := range CoverArtFileSet(coverPath) {
+			if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+				l.logger.Warn("could not remove orphaned cover art file",
+					"path", path,
+					"err", err,
+				)
+			}
+		}
+	}
 
 	// 22. Post-commit: Compact queue.
 	if l.removalHooks.CompactQueue != nil {

backend/library/library.go

@@ -1193,32 +1193,17 @@ func (l *Library) pruneEmptyEntities() {
 		}
 	}
 
-	// Cover art after albums: a cover whose album just went is
-	// unreferenced, and leaving the row behind keeps its files exempt
-	// from the janitor's covers sweep forever (#247).
-	orphanedCovers, err := l.sweepOrphanedCoverArt(tx)
-	if err != nil {
-		l.logger.Warn("could not sweep orphaned cover art", "err", err)
-
-		return
-	}
-
 	if err := tx.Commit(); err != nil {
 		l.logger.Warn("could not commit entity cleanup", "err", err)
 
 		return
 	}
 
-	// Post-commit: the rows are gone, so their files can go too.
-	l.removeCoverArtFiles(orphanedCovers)
-
-	if len(albumIDs) > 0 || len(artistIDs) > 0 || len(genreIDs) > 0 ||
-		len(orphanedCovers) > 0 {
+	if len(albumIDs) > 0 || len(artistIDs) > 0 || len(genreIDs) > 0 {
 		l.logger.Info("pruned empty library entities",
 			"albums", len(albumIDs),
 			"artists", len(artistIDs),
 			"genres", len(genreIDs),
-			"covers", len(orphanedCovers),
 		)
 	}
 }

backend/library/removal_test.go

@@ -198,53 +198,3 @@ func TestCoverArtFileSet(t *testing.T) {
 		}
 	}
 }
-
-// Removing the last track of an album must take the album's cover art
-// with it — both the row and every derived file — or the row keeps its
-// files exempt from the janitor's covers sweep forever (#247).
-func TestRemoveFromLibrary_DeletesOrphanedCoverArt(t *testing.T) {
-	t.Parallel()
-
-	lib, _ := setupTestLibrary(t)
-
-	dir := t.TempDir()
-
-	// The largest tier is what cover_art.file_path names; write every
-	// variant so the sweep has a real set to remove.
-	for _, tier := range thumbnailTiers {
-		p := filepath.Join(dir, coverart.SizedFilename("abc123.jpg", tier.Suffix))
-		if err := os.WriteFile(p, []byte("img"), 0o600); err != nil {
-			t.Fatalf("write %s: %v", p, err)
-		}
-	}
-
-	cover := filepath.Join(dir, coverart.SizedFilename("abc123.jpg", "_lg"))
-
-	seedRemovableLibrary(t, lib, cover)
-
-	// Link the album to the cover so it is not orphaned until the track
-	// (and with it the album) goes.
-	if _, err := lib.db.ExecContext(
-		`UPDATE albums SET cover_art_id =
-			(SELECT id FROM cover_art WHERE file_path = ?)
-		 WHERE name = 'Test Album'`,
-		cover,
-	); err != nil {
-		t.Fatalf("link cover art: %v", err)
-	}
-
-	if _, err := lib.RemoveFromLibrary([]string{"/music/song.mp3"}); err != nil {
-		t.Fatalf("RemoveFromLibrary: %v", err)
-	}
-
-	if n := countRows(t, lib, "cover_art"); n != 0 {
-		t.Errorf("cover_art has %d rows after removal, want 0", n)
-	}
-
-	for _, tier := range thumbnailTiers {
-		p := filepath.Join(dir, coverart.SizedFilename("abc123.jpg", tier.Suffix))
-		if _, err := os.Stat(p); !os.IsNotExist(err) {
-			t.Errorf("cover art file still present: %s", filepath.Base(p))
-		}
-	}
-}

backend/maintenance/maintenance_test.go

@@ -666,3 +666,71 @@ func TestExpiredHTTPCacheJob_TrimsToBudget(t *testing.T) {
 		t.Errorf("kept %q, want the longest-lived row", kept)
 	}
 }
+
+// TestStaleArtistMetadataJob pins the sweep's two keep rules: an owned
+// artist's metadata survives, a browsed artist's survives while it still
+// holds cached artwork, and everything else goes (#248).
+func TestStaleArtistMetadataJob(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDB(t)
+
+	const (
+		ownedMBID   = "11111111-1111-1111-1111-111111111111"
+		browsedMBID = "22222222-2222-2222-2222-222222222222"
+		staleMBID   = "33333333-3333-3333-3333-333333333333"
+	)
+
+	// The owned artist is in the library - which means a *file* says
+	// so.  An artists row on its own is not ownership.
+	database.InsertTestTrack(t, db, database.TestTrack{
+		FilePath:   "/music/owned.mp3",
+		Artist:     "Owned",
+		ArtistMBID: ownedMBID,
+	})
+
+	for _, mbid := range []string{ownedMBID, browsedMBID, staleMBID} {
+		if _, err := db.ExecContext(
+			`INSERT INTO artist_metadata (mbid, source, data, fetched_at)
+			 VALUES (?, 'wikidata-p18', x'00', CURRENT_TIMESTAMP)`,
+			mbid,
+		); err != nil {
+			t.Fatalf("seed artist_metadata for %s: %v", mbid, err)
+		}
+	}
+
+	// The browsed artist holds cached artwork, so its metadata is still
+	// referenced and must survive.
+	if _, err := db.ExecContext(
+		`INSERT INTO artist_images
+		   (artist_mbid, source, source_url, file_path)
+		 VALUES (?, 'test', 'http://x', '/art/primary.jpg')`,
+		browsedMBID,
+	); err != nil {
+		t.Fatalf("seed artist_images: %v", err)
+	}
+
+	if _, err := StaleArtistMetadataJob(db).Run(context.Background()); err != nil {
+		t.Fatalf("run job: %v", err)
+	}
+
+	for _, tc := range []struct {
+		mbid string
+		want int
+	}{
+		{ownedMBID, 1},
+		{browsedMBID, 1},
+		{staleMBID, 0},
+	} {
+		var n int
+		if err := db.QueryRowWriter(
+			"SELECT COUNT(*) FROM artist_metadata WHERE mbid = ?", tc.mbid,
+		).Scan(&n); err != nil {
+			t.Fatalf("count %s: %v", tc.mbid, err)
+		}
+
+		if n != tc.want {
+			t.Errorf("artist_metadata rows for %s = %d, want %d", tc.mbid, n, tc.want)
+		}
+	}
+}

backend/maintenance/sweeps.go

@@ -628,3 +628,37 @@ func dirSize(dir string) (bytes, files int64) {
 
 	return bytes, files
 }
+
+// StaleArtistMetadataJob evicts long-lived artist metadata (bios, wiki
+// leads, relationships) for artists the user no longer has any reason
+// to keep around: not owned and holding no cached artwork.
+//
+// artist_metadata has no TTL by design — entity data changes rarely and
+// re-fetching spends someone else's rate limit — so without a sweep it
+// grows for the life of the install.  This is the "swept when the
+// artist is no longer referenced" contract the datamap always declared
+// for it and nothing ever performed (#248).
+func StaleArtistMetadataJob(db *database.DB) Job {
+	return Job{
+		Name:        "artist-metadata-sweep",
+		MinInterval: dailyInterval,
+		Run: func(_ context.Context) (Result, error) {
+			res, err := db.ExecContext(
+				`DELETE FROM artist_metadata
+				 WHERE mbid NOT IN (` + ownedArtistMBIDs + `)
+				   AND mbid NOT IN (
+				       SELECT artist_mbid FROM artist_images
+				   )`,
+			)
+			if err != nil {
+				return Result{}, fmt.Errorf(
+					"delete stale artist_metadata rows: %w", err,
+				)
+			}
+
+			rows, _ := res.RowsAffected()
+
+			return Result{RowsDeleted: rows}, nil
+		},
+	}
+}