Added the import/cleanup functionality

src/routes/albums.rs

@@ -44,6 +44,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
             .route(web::get().to(list_albums))
             .route(web::post().to(add_album)),
     )
+    .service(web::resource("/albums/{mbid}/watch").route(web::delete().to(unwatch_album)))
     .service(web::resource("/albums/{mbid}").route(web::get().to(get_album)));
 }
 
@@ -194,3 +195,34 @@ async fn add_album(
         "errors": summary.errors,
     })))
 }
+
+async fn unwatch_album(
+    state: web::Data<AppState>,
+    session: Session,
+    path: web::Path<String>,
+) -> Result<HttpResponse, ApiError> {
+    auth::require_auth(&session)?;
+    let mbid = path.into_inner();
+    let conn = state.db.conn();
+
+    // Get the album's tracks from MB to find their recording MBIDs
+    let tracks = match state.mb_client.get_release_tracks(&mbid).await {
+        Ok(t) => t,
+        Err(_) => {
+            // Try as release-group
+            let release_mbid = resolve_release_from_group(&state, &mbid).await?;
+            state
+                .mb_client
+                .get_release_tracks(&release_mbid)
+                .await
+                .map_err(|e| ApiError::Internal(format!("MusicBrainz error: {e}")))?
+        }
+    };
+
+    let mut removed = 0u64;
+    for track in &tracks {
+        removed += queries::wanted::remove_by_mbid(conn, &track.recording_mbid).await?;
+    }
+
+    Ok(HttpResponse::Ok().json(serde_json::json!({"removed": removed})))
+}

src/routes/artists.rs

@@ -78,6 +78,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
             .route(web::post().to(set_monitored))
             .route(web::delete().to(unset_monitored)),
     )
+    .service(web::resource("/artists/{id}/watch").route(web::delete().to(unwatch_artist)))
     .service(
         web::resource("/artists/{id}")
             .route(web::get().to(get_artist))
@@ -839,12 +840,31 @@ async fn delete_artist(
     session: Session,
     path: web::Path<i32>,
 ) -> Result<HttpResponse, ApiError> {
-    auth::require_admin(&session)?;
+    auth::require_auth(&session)?;
     let id = path.into_inner();
-    queries::artists::delete(state.db.conn(), id).await?;
+    let conn = state.db.conn();
+
+    // Cascade: remove wanted items, tracks (DB only), albums, cache, then artist
+    queries::wanted::remove_by_artist(conn, id).await?;
+    queries::tracks::delete_by_artist(conn, id).await?;
+    queries::albums::delete_by_artist(conn, id).await?;
+    let _ = queries::cache::purge_prefix(conn, &format!("artist_totals:{id}")).await;
+    queries::artists::delete(conn, id).await?;
+
     Ok(HttpResponse::NoContent().finish())
 }
 
+async fn unwatch_artist(
+    state: web::Data<AppState>,
+    session: Session,
+    path: web::Path<i32>,
+) -> Result<HttpResponse, ApiError> {
+    auth::require_auth(&session)?;
+    let id = path.into_inner();
+    let removed = queries::wanted::remove_by_artist(state.db.conn(), id).await?;
+    Ok(HttpResponse::Ok().json(serde_json::json!({"removed": removed})))
+}
+
 async fn set_monitored(
     state: web::Data<AppState>,
     session: Session,

src/routes/tracks.rs

@@ -29,9 +29,13 @@ pub struct WatchTrackRequest {
 }
 
 pub fn configure(cfg: &mut web::ServiceConfig) {
-    cfg.service(web::resource("/tracks/watch").route(web::post().to(watch_track)))
-        .service(web::resource("/tracks").route(web::get().to(list_tracks)))
-        .service(web::resource("/tracks/{id}").route(web::get().to(get_track)));
+    cfg.service(
+        web::resource("/tracks/watch")
+            .route(web::post().to(watch_track))
+            .route(web::delete().to(unwatch_track)),
+    )
+    .service(web::resource("/tracks").route(web::get().to(list_tracks)))
+    .service(web::resource("/tracks/{id}").route(web::get().to(get_track)));
 }
 
 async fn list_tracks(
@@ -87,3 +91,17 @@ async fn watch_track(
         "artist_name": entry.artist_name,
     })))
 }
+
+async fn unwatch_track(
+    state: web::Data<AppState>,
+    session: Session,
+    body: web::Json<WatchTrackRequest>,
+) -> Result<HttpResponse, ApiError> {
+    auth::require_auth(&session)?;
+    let mbid = body
+        .mbid
+        .as_deref()
+        .ok_or_else(|| ApiError::BadRequest("provide recording mbid".into()))?;
+    let removed = queries::wanted::remove_by_mbid(state.db.conn(), mbid).await?;
+    Ok(HttpResponse::Ok().json(serde_json::json!({"removed": removed})))
+}