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/api/requests.go

@@ -9,34 +9,32 @@ import (
 
 	"git.fabledsword.com/bvandeusen/minstrel/internal/apierror"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
-	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrrequests"
 	"git.fabledsword.com/bvandeusen/minstrel/internal/notifications"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/requests"
 )
 
 // requestView is the JSON shape returned by all /api/requests handlers.
 // Field names follow the lowercase snake_case convention for /api/* responses.
 type requestView struct {
-	ID               pgtype.UUID        `json:"id"`
-	UserID           pgtype.UUID        `json:"user_id"`
-	Status           string             `json:"status"`
-	Kind             string             `json:"kind"`
-	LidarrArtistMBID string             `json:"lidarr_artist_mbid"`
-	LidarrAlbumMBID  *string            `json:"lidarr_album_mbid,omitempty"`
-	LidarrTrackMBID  *string            `json:"lidarr_track_mbid,omitempty"`
-	ArtistName       string             `json:"artist_name"`
-	AlbumTitle       *string            `json:"album_title,omitempty"`
-	TrackTitle       *string            `json:"track_title,omitempty"`
-	QualityProfileID *int32             `json:"quality_profile_id,omitempty"`
-	RootFolderPath   *string            `json:"root_folder_path,omitempty"`
-	DecidedAt        pgtype.Timestamptz `json:"decided_at,omitempty"`
-	DecidedBy        pgtype.UUID        `json:"decided_by,omitempty"`
-	Notes            *string            `json:"notes,omitempty"`
-	CompletedAt      pgtype.Timestamptz `json:"completed_at,omitempty"`
-	MatchedTrackID   pgtype.UUID        `json:"matched_track_id,omitempty"`
-	MatchedAlbumID   pgtype.UUID        `json:"matched_album_id,omitempty"`
-	MatchedArtistID  pgtype.UUID        `json:"matched_artist_id,omitempty"`
-	RequestedAt      pgtype.Timestamptz `json:"requested_at"`
-	UpdatedAt        pgtype.Timestamptz `json:"updated_at"`
+	ID              pgtype.UUID        `json:"id"`
+	UserID          pgtype.UUID        `json:"user_id"`
+	Status          string             `json:"status"`
+	Kind            string             `json:"kind"`
+	ArtistMBID      string             `json:"artist_mbid"`
+	AlbumMBID       *string            `json:"album_mbid,omitempty"`
+	TrackMBID       *string            `json:"track_mbid,omitempty"`
+	ArtistName      string             `json:"artist_name"`
+	AlbumTitle      *string            `json:"album_title,omitempty"`
+	TrackTitle      *string            `json:"track_title,omitempty"`
+	DecidedAt       pgtype.Timestamptz `json:"decided_at,omitempty"`
+	DecidedBy       pgtype.UUID        `json:"decided_by,omitempty"`
+	Notes           *string            `json:"notes,omitempty"`
+	CompletedAt     pgtype.Timestamptz `json:"completed_at,omitempty"`
+	MatchedTrackID  pgtype.UUID        `json:"matched_track_id,omitempty"`
+	MatchedAlbumID  pgtype.UUID        `json:"matched_album_id,omitempty"`
+	MatchedArtistID pgtype.UUID        `json:"matched_artist_id,omitempty"`
+	RequestedAt     pgtype.Timestamptz `json:"requested_at"`
+	UpdatedAt       pgtype.Timestamptz `json:"updated_at"`
 	// Progress counters, computed at response time from the matched
 	// entity's children. 0 when nothing has been ingested yet (or when
 	// the request has no matched entity yet). For artist requests both
@@ -45,29 +43,27 @@ type requestView struct {
 	ImportedTrackCount int `json:"imported_track_count"`
 }
 
-func requestViewFrom(row dbq.LidarrRequest) requestView {
+func requestViewFrom(row dbq.Request) requestView {
 	return requestView{
-		ID:               row.ID,
-		UserID:           row.UserID,
-		Status:           string(row.Status),
-		Kind:             string(row.Kind),
-		LidarrArtistMBID: row.LidarrArtistMbid,
-		LidarrAlbumMBID:  row.LidarrAlbumMbid,
-		LidarrTrackMBID:  row.LidarrTrackMbid,
-		ArtistName:       row.ArtistName,
-		AlbumTitle:       row.AlbumTitle,
-		TrackTitle:       row.TrackTitle,
-		QualityProfileID: row.QualityProfileID,
-		RootFolderPath:   row.RootFolderPath,
-		DecidedAt:        row.DecidedAt,
-		DecidedBy:        row.DecidedBy,
-		Notes:            row.Notes,
-		CompletedAt:      row.CompletedAt,
-		MatchedTrackID:   row.MatchedTrackID,
-		MatchedAlbumID:   row.MatchedAlbumID,
-		MatchedArtistID:  row.MatchedArtistID,
-		RequestedAt:      row.RequestedAt,
-		UpdatedAt:        row.UpdatedAt,
+		ID:              row.ID,
+		UserID:          row.UserID,
+		Status:          string(row.Status),
+		Kind:            string(row.Kind),
+		ArtistMBID:      row.ArtistMbid,
+		AlbumMBID:       row.AlbumMbid,
+		TrackMBID:       row.TrackMbid,
+		ArtistName:      row.ArtistName,
+		AlbumTitle:      row.AlbumTitle,
+		TrackTitle:      row.TrackTitle,
+		DecidedAt:       row.DecidedAt,
+		DecidedBy:       row.DecidedBy,
+		Notes:           row.Notes,
+		CompletedAt:     row.CompletedAt,
+		MatchedTrackID:  row.MatchedTrackID,
+		MatchedAlbumID:  row.MatchedAlbumID,
+		MatchedArtistID: row.MatchedArtistID,
+		RequestedAt:     row.RequestedAt,
+		UpdatedAt:       row.UpdatedAt,
 	}
 }
 
@@ -81,9 +77,9 @@ func requestViewFrom(row dbq.LidarrRequest) requestView {
 // N+1 against the request list: acceptable at admin scale (dozens of
 // in-flight requests at most). Errors are swallowed — progress is a
 // reporting nicety, not a correctness gate.
-func fillProgress(ctx context.Context, q *dbq.Queries, row dbq.LidarrRequest, view *requestView) {
+func fillProgress(ctx context.Context, q *dbq.Queries, row dbq.Request, view *requestView) {
 	switch row.Kind {
-	case dbq.LidarrRequestKindArtist:
+	case dbq.RequestKindArtist:
 		if !row.MatchedArtistID.Valid {
 			return
 		}
@@ -93,7 +89,7 @@ func fillProgress(ctx context.Context, q *dbq.Queries, row dbq.LidarrRequest, vi
 		if n, err := q.CountTracksByArtist(ctx, row.MatchedArtistID); err == nil {
 			view.ImportedTrackCount = int(n)
 		}
-	case dbq.LidarrRequestKindAlbum:
+	case dbq.RequestKindAlbum:
 		if !row.MatchedAlbumID.Valid {
 			return
 		}
@@ -101,22 +97,23 @@ func fillProgress(ctx context.Context, q *dbq.Queries, row dbq.LidarrRequest, vi
 		if n, err := q.CountTracksByAlbum(ctx, row.MatchedAlbumID); err == nil {
 			view.ImportedTrackCount = int(n)
 		}
-	case dbq.LidarrRequestKindTrack:
+	case dbq.RequestKindTrack:
 		if row.MatchedTrackID.Valid {
 			view.ImportedTrackCount = 1
 		}
 	}
 }
 
-// createRequestBody is the decoded JSON for POST /api/requests.
+// createRequestBody is the decoded JSON for POST /api/requests. album_mbid
+// is the album's MusicBrainz release group, as catalogue search returns it.
 type createRequestBody struct {
-	Kind             string `json:"kind"`
-	LidarrArtistMBID string `json:"lidarr_artist_mbid"`
-	LidarrAlbumMBID  string `json:"lidarr_album_mbid"`
-	LidarrTrackMBID  string `json:"lidarr_track_mbid"`
-	ArtistName       string `json:"artist_name"`
-	AlbumTitle       string `json:"album_title"`
-	TrackTitle       string `json:"track_title"`
+	Kind       string `json:"kind"`
+	ArtistMBID string `json:"artist_mbid"`
+	AlbumMBID  string `json:"album_mbid"`
+	TrackMBID  string `json:"track_mbid"`
+	ArtistName string `json:"artist_name"`
+	AlbumTitle string `json:"album_title"`
+	TrackTitle string `json:"track_title"`
 }
 
 // handleCreateRequest implements POST /api/requests.
@@ -131,17 +128,17 @@ func (h *handlers) handleCreateRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	row, created, err := h.lidarrRequests.CreateTracked(r.Context(), user.ID, lidarrrequests.CreateParams{
-		Kind:             body.Kind,
-		LidarrArtistMBID: body.LidarrArtistMBID,
-		LidarrAlbumMBID:  body.LidarrAlbumMBID,
-		LidarrTrackMBID:  body.LidarrTrackMBID,
-		ArtistName:       body.ArtistName,
-		AlbumTitle:       body.AlbumTitle,
-		TrackTitle:       body.TrackTitle,
+	row, created, err := h.requests.CreateTracked(r.Context(), user.ID, requests.CreateParams{
+		Kind:       body.Kind,
+		ArtistMBID: body.ArtistMBID,
+		AlbumMBID:  body.AlbumMBID,
+		TrackMBID:  body.TrackMBID,
+		ArtistName: body.ArtistName,
+		AlbumTitle: body.AlbumTitle,
+		TrackTitle: body.TrackTitle,
 	})
 	if err != nil {
-		if errors.Is(err, lidarrrequests.ErrInvalidKindFields) {
+		if errors.Is(err, requests.ErrInvalidKindFields) {
 			writeErr(w, apierror.BadRequest("mbid_required", err.Error()))
 			return
 		}
@@ -150,22 +147,14 @@ func (h *handlers) handleCreateRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Auto-approve flow (#355 / #376 U2.5): when the user has the
-	// auto_approve_requests flag set by an admin, transition the
-	// just-created pending row through Approve so it dispatches to
-	// Lidarr immediately. Failures here (Lidarr disabled, defaults
-	// missing, network error) leave the row pending — same fallback
-	// as a manual admin approve that hits the same error path. The
-	// user gets a 201 with whatever status Approve produced; admin
-	// can still resolve the row in /admin/requests if it stayed
-	// pending.
-	//
-	// The "actor" id passed to Approve is the user themselves — the
-	// auto-approval is the user acting under the privilege the admin
-	// granted them via the toggle. The trail of "admin set the flag"
-	// already lives in audit_log (ActionAutoApproveToggle from U2).
+	// Auto-approve flow (#355 / #376 U2.5): when an admin has set the user's
+	// auto_approve_requests flag, the new request goes straight onto the
+	// wanted list as if approved. A failure leaves it pending for an admin,
+	// the same as a manual approval hitting the same error. The approver is
+	// the user themselves, acting under the privilege the admin granted; the
+	// grant is in audit_log (ActionAutoApproveToggle).
 	if user.AutoApproveRequests {
-		approved, aerr := h.lidarrRequests.Approve(r.Context(), row.ID, user.ID, lidarrrequests.ApproveOverrides{})
+		approved, aerr := h.requests.Approve(r.Context(), row.ID, user.ID, pgtype.UUID{})
 		if aerr == nil {
 			row = approved
 		} else {
@@ -180,7 +169,7 @@ func (h *handlers) handleCreateRequest(w http.ResponseWriter, r *http.Request) {
 	// (M489). One that deduped into a request already in flight was
 	// announced when it was first made, and the requester, if they are an
 	// admin themselves, needs no notice of their own request.
-	if created && row.Status == dbq.LidarrRequestStatusPending {
+	if created && row.Status == dbq.RequestStatusPending {
 		p := requestPayload(row)
 		p.Actor = userLabel(user)
 		h.notifier.NotifyLogged(r.Context(), notifications.KindRequestPending, notifications.ToAdmins(user.ID), p.Map())
@@ -197,7 +186,7 @@ func (h *handlers) handleListRequests(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	rows, err := h.lidarrRequests.ListForUser(r.Context(), user.ID, 100)
+	rows, err := h.requests.ListForUser(r.Context(), user.ID, 100)
 	if err != nil {
 		h.logger.Error("api: list requests", "err", err)
 		writeErr(w, apierror.InternalMsg("list failed", err))
@@ -222,7 +211,7 @@ func (h *handlers) handleGetRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	row, apiErr := resolveByID(r, "id", dbq.New(h.pool).GetLidarrRequestByID, "request")
+	row, apiErr := resolveByID(r, "id", dbq.New(h.pool).GetRequestByID, "request")
 	if apiErr != nil {
 		writeErr(w, apiErr)
 		return
@@ -252,12 +241,12 @@ func (h *handlers) handleCancelRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	row, err := h.lidarrRequests.Cancel(r.Context(), id, user.ID)
+	row, err := h.requests.Cancel(r.Context(), id, user.ID)
 	if err != nil {
 		switch {
-		case errors.Is(err, lidarrrequests.ErrNotPending):
+		case errors.Is(err, requests.ErrNotPending):
 			writeErr(w, apierror.Conflict("request_not_pending", "request is not pending"))
-		case errors.Is(err, lidarrrequests.ErrNotFound):
+		case errors.Is(err, requests.ErrNotFound):
 			writeErr(w, apierror.NotFound("request"))
 		default:
 			h.logger.Error("api: cancel request", "err", err)