feat: a wanted list — follow artists on release-type profiles; requests and re-acquisition become wants (M502 #5520)

Minstrel keeps its own list of what it is to get, keyed by MusicBrainz
release group. A want comes from an approved request, a new release by a
followed artist, or an album whose files went missing, and is held once the
library has a full edition of it.

- Migration 0081: release_type_profiles (Standard seeded: Album, EP,
  Single, studio only), follows, follow_seen_groups and wants.
  lidarr_requests becomes requests with plain *_mbid columns; approved
  album and track requests move onto the wanted list, approved artist
  requests become follows, and the library's album artists start out
  followed. missing_reacquisitions and the retry settings go.
- internal/wanted: follows are checked against MusicBrainz discographies
  daily. The first check sets a baseline, and only releases after it are
  wanted unless the follow asked for what already exists. Profiles filter
  by primary and secondary type, so live recordings stay out unless a
  profile ticks Live.
- internal/requests (was lidarrrequests): approving puts the request on
  the wanted list, and an artist request can be approved on a chosen
  profile. A request completes when its want is held.
- The re-acquisition sweeper wants a missing album back instead of asking
  Lidarr; searching for it is the search schedule's (#5521).
- Web: an admin Wanted page (Wanted, Missing files, Held, Following), a
  follow control on artist pages, a release-type profiles card on
  Integrations, "Approve on a profile" on Requests, and want state on
  Missing files. The artist detail API returns the artist's MBID.
- Android: the request body sends artist_mbid, album_mbid and track_mbid.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/reacquisition/sweeper_test.go

@@ -13,9 +13,6 @@ import (
 	"git.fabledsword.com/bvandeusen/minstrel/internal/db"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/dbtest"
-	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrconfig"
-	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrrequests"
-	"git.fabledsword.com/bvandeusen/minstrel/internal/notifications"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/tags"
 )
 
@@ -37,9 +34,6 @@ func newSweepPool(t *testing.T) *pgxpool.Pool {
 	}
 	t.Cleanup(pool.Close)
 	dbtest.ResetDB(t, pool)
-	if _, err := pool.Exec(context.Background(), "DELETE FROM lidarr_requests"); err != nil {
-		t.Fatalf("reset requests: %v", err)
-	}
 	return pool
 }
 
@@ -75,39 +69,25 @@ func lostAlbum(t *testing.T, pool *pgxpool.Pool, title, release, group string) p
 	return al.ID
 }
 
-// #5241: re-acquisition asks Lidarr for the album's release group, never its
-// release id. A tag-supplied group is used as is; otherwise MusicBrainz names
-// it and the answer is cached onto the album; an album MusicBrainz cannot
-// name is skipped without spending an attempt.
-func TestSweep_RequestsAlbumsByReleaseGroup_Integration(t *testing.T) {
+// #5241: an album is wanted by its release group, never its release id. A
+// tag-supplied group is used as is; otherwise MusicBrainz names it and the
+// answer is cached onto the album; an album MusicBrainz cannot name is
+// skipped and tried again next pass.
+func TestSweep_WantsAlbumsByReleaseGroup_Integration(t *testing.T) {
 	pool := newSweepPool(t)
 	ctx := context.Background()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	q := dbq.New(pool)
 
-	admin, err := q.CreateUser(ctx, dbq.CreateUserParams{
-		Username: dbtest.TestUserPrefix + "sweepadmin", PasswordHash: "x", ApiTokenHash: "x", IsAdmin: true,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
 	settings, err := NewSettingsService(ctx, pool, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
-	cfg := Defaults
-	cfg.AutoApprove = false
-	if _, err := settings.Set(ctx, cfg); err != nil {
-		t.Fatal(err)
-	}
-
 	tagged := lostAlbum(t, pool, "Tagged", "release-tagged", "group-tagged")
 	resolved := lostAlbum(t, pool, "Resolved", "release-resolved", "")
-	unknown := lostAlbum(t, pool, "Unknown", "release-unknown", "")
+	_ = lostAlbum(t, pool, "Unknown", "release-unknown", "")
 
-	requests := lidarrrequests.NewService(pool, lidarrconfig.New(pool), nil, nil)
-	s := NewSweeper(pool, settings, requests, logger)
-	s.SetNotifier(notifications.New(pool, nil, nil))
+	s := NewSweeper(pool, settings, logger)
 	asked := map[string]int{}
 	s.releaseGroup = func(_ context.Context, release string) (string, error) {
 		asked[release]++
@@ -120,28 +100,21 @@ func TestSweep_RequestsAlbumsByReleaseGroup_Integration(t *testing.T) {
 		t.Fatalf("sweep: %v", err)
 	}
 
-	requested := func(album pgtype.UUID) (string, bool) {
+	wantFor := func(group string, album pgtype.UUID) {
 		t.Helper()
-		var mbid *string
-		err := pool.QueryRow(ctx, `
-SELECT lr.lidarr_album_mbid
-  FROM missing_reacquisitions r
-  JOIN lidarr_requests lr ON lr.id = r.last_request_id
- WHERE r.album_id = $1`, album).Scan(&mbid)
-		if err != nil || mbid == nil {
-			return "", false
+		w, err := q.GetWantByReleaseGroup(ctx, group)
+		if err != nil {
+			t.Fatalf("no want for %s: %v", group, err)
+		}
+		if w.Reason != "missing" || w.AlbumID != album || w.FulfilledAt.Valid {
+			t.Errorf("want %s = %+v: an open missing want about the album", group, w)
 		}
-		return *mbid, true
-	}
-	if got, ok := requested(tagged); !ok || got != "group-tagged" {
-		t.Errorf("tagged album requested as %q (ok=%v), want group-tagged", got, ok)
 	}
+	wantFor("group-tagged", tagged)
+	wantFor("group-resolved", resolved)
 	if asked["release-tagged"] != 0 {
 		t.Error("MusicBrainz asked about an album whose tags named its group")
 	}
-	if got, ok := requested(resolved); !ok || got != "group-resolved" {
-		t.Errorf("resolved album requested as %q (ok=%v), want group-resolved", got, ok)
-	}
 	var cached *string
 	if err := pool.QueryRow(ctx, "SELECT release_group_mbid FROM albums WHERE id = $1", resolved).Scan(&cached); err != nil {
 		t.Fatal(err)
@@ -149,32 +122,55 @@ SELECT lr.lidarr_album_mbid
 	if cached == nil || *cached != "group-resolved" {
 		t.Errorf("resolved group not cached on the album: %v", cached)
 	}
-	var attempts int
-	if err := pool.QueryRow(ctx, "SELECT count(*) FROM missing_reacquisitions WHERE album_id = $1", unknown).Scan(&attempts); err != nil {
+	var n int
+	if err := pool.QueryRow(ctx, "SELECT count(*) FROM wants").Scan(&n); err != nil {
 		t.Fatal(err)
 	}
-	if attempts != 0 {
-		t.Errorf("unresolvable album spent an attempt (%d state rows)", attempts)
+	if n != 2 {
+		t.Errorf("%d wants, want 2: the unresolvable album is skipped", n)
 	}
-	// M489: the two requests filed without auto-approval wait on an admin,
-	// so each reaches the admins' inbox; the unresolvable album filed none.
-	inbox, err := q.ListNotifications(ctx, dbq.ListNotificationsParams{UserID: admin.ID, PageLimit: 10})
+
+	// The next pass finds both already wanted and asks nothing new.
+	asked = map[string]int{}
+	if err := s.SweepOnce(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if asked["release-resolved"] != 0 || asked["release-unknown"] != 1 {
+		t.Errorf("second pass asked MusicBrainz %v: only the unresolved album again", asked)
+	}
+}
+
+// A want held after the files went missing means the library has a full copy
+// despite the missing rows (#5245): the album is not wanted again. One held
+// before they went missing is reopened.
+func TestSweep_HeldWantsAreReopenedOnlyForANewLoss_Integration(t *testing.T) {
+	pool := newSweepPool(t)
+	ctx := context.Background()
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	settings, err := NewSettingsService(ctx, pool, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(inbox) != 2 {
-		t.Errorf("admin inbox holds %d notifications, want 2", len(inbox))
-	}
-	for _, n := range inbox {
-		if n.Kind != string(notifications.KindRequestPending) {
-			t.Errorf("admin inbox holds %q, want request_pending", n.Kind)
+	stale := lostAlbum(t, pool, "Stale", "release-stale", "group-stale")
+	lost := lostAlbum(t, pool, "Lost Again", "release-lost", "group-lost")
+	for _, c := range []struct {
+		group, heldAgo string
+		album          pgtype.UUID
+	}{{"group-stale", "1 hour", stale}, {"group-lost", "3 days", lost}} {
+		if _, err := pool.Exec(ctx, `
+			INSERT INTO wants (release_group_mbid, artist_mbid, artist_name, title, reason, album_id, fulfilled_at)
+			VALUES ($1, 'a', 'A', 'T', 'request', $2, now() - $3::interval)`, c.group, c.album, c.heldAgo); err != nil {
+			t.Fatal(err)
 		}
 	}
-	var stray int
-	if err := pool.QueryRow(ctx, "SELECT count(*) FROM lidarr_requests WHERE lidarr_album_mbid LIKE 'release-%'").Scan(&stray); err != nil {
+	if err := NewSweeper(pool, settings, logger).SweepOnce(ctx); err != nil {
 		t.Fatal(err)
 	}
-	if stray != 0 {
-		t.Errorf("%d request(s) named an album by its release id", stray)
+	q := dbq.New(pool)
+	if w, _ := q.GetWantByReleaseGroup(ctx, "group-stale"); !w.FulfilledAt.Valid {
+		t.Error("a want held since the loss was reopened")
+	}
+	if w, _ := q.GetWantByReleaseGroup(ctx, "group-lost"); w.FulfilledAt.Valid || w.Reason != "missing" {
+		t.Errorf("a want held before the loss should reopen as missing: %+v", w)
 	}
 }