diff --git a/crates/arr-api/src/search.rs b/crates/arr-api/src/search.rs index b12f1d4..e424023 100644 --- a/crates/arr-api/src/search.rs +++ b/crates/arr-api/src/search.rs @@ -192,44 +192,7 @@ pub async fn search( } let database = state.database().ok_or(ApiError::Unavailable)?; - let tokens = like_tokens(input); - - // §9.2 keeps the two result sets grouped and the library first, so each - // kind lands in its own block: movies, then series. - let mut library: Vec = if matches!(kind, SearchInputKind::TmdbId) { - let tmdb_id = input - .strip_prefix("tmdb:") - .unwrap_or(input) - .trim() - .parse::() - .map_err(|_| ApiError::Invalid("invalid TMDB id".into()))?; - sqlx::query_as!(Movie, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", title AS "title!: String", year, original_language, root_id AS "root_id!: i64", wanted AS "wanted!: bool", overrides AS "overrides!: serde_json::Value", state AS "state!: String", blocked AS "blocked!: bool", search_attempts AS "search_attempts!: i64", last_searched_at, poster_path, vote_average, (SELECT f.waiver FROM media_files f WHERE f.owner_kind = 'movie' AND f.owner_id = movies.id AND f.waiver IS NOT NULL ORDER BY f.id LIMIT 1) AS "waiver?: serde_json::Value" FROM movies WHERE tmdb_id = ? OR NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY title, year, id"#, tmdb_id, tokens) - .fetch_all(database.pool()).await? - .into_iter() - .map(LibraryResult::Movie) - .collect() - } else { - sqlx::query_as!(Movie, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", title AS "title!: String", year, original_language, root_id AS "root_id!: i64", wanted AS "wanted!: bool", overrides AS "overrides!: serde_json::Value", state AS "state!: String", blocked AS "blocked!: bool", search_attempts AS "search_attempts!: i64", last_searched_at, poster_path, vote_average, (SELECT f.waiver FROM media_files f WHERE f.owner_kind = 'movie' AND f.owner_id = movies.id AND f.waiver IS NOT NULL ORDER BY f.id LIMIT 1) AS "waiver?: serde_json::Value" FROM movies WHERE NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY title, year, id"#, tokens) - .fetch_all(database.pool()).await? - .into_iter() - .map(LibraryResult::Movie) - .collect() - }; - - let series_rows = if matches!(kind, SearchInputKind::TmdbId) { - let tmdb_id = input - .strip_prefix("tmdb:") - .unwrap_or(input) - .trim() - .parse::() - .map_err(|_| ApiError::Invalid("invalid TMDB id".into()))?; - sqlx::query_as!(LibrarySeries, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.blocked AS "blocked!: bool", s.poster_path, s.vote_average FROM series s WHERE s.tmdb_id = ? OR NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE s.title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY s.title, s.year, s.id"#, tmdb_id, tokens) - .fetch_all(database.pool()).await? - } else { - sqlx::query_as!(LibrarySeries, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.blocked AS "blocked!: bool", s.poster_path, s.vote_average FROM series s WHERE NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE s.title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY s.title, s.year, s.id"#, tokens) - .fetch_all(database.pool()).await? - }; - library.extend(series_rows.into_iter().map(LibraryResult::Series)); + let mut library = library_hits(database, kind, input).await?; // A degraded TMDB must not discard the library results already in hand // (issue #168): the group goes empty and `tmdb_status` says why, so the @@ -253,28 +216,19 @@ pub async fn search( Err(error) => return Err(error), }; if matches!(kind, SearchInputKind::ImdbId) { - for result in &results { - match result { - TmdbResult::Movie(movie) => { - let tmdb_id = i64::from(movie.tmdb_id); - if let Some(found) = sqlx::query_as!(Movie, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", title AS "title!: String", year, original_language, root_id AS "root_id!: i64", wanted AS "wanted!: bool", overrides AS "overrides!: serde_json::Value", state AS "state!: String", blocked AS "blocked!: bool", search_attempts AS "search_attempts!: i64", last_searched_at, poster_path, vote_average, (SELECT f.waiver FROM media_files f WHERE f.owner_kind = 'movie' AND f.owner_id = movies.id AND f.waiver IS NOT NULL ORDER BY f.id LIMIT 1) AS "waiver?: serde_json::Value" FROM movies WHERE tmdb_id = ?"#, tmdb_id) - .fetch_optional(database.pool()).await? - { - library.push(LibraryResult::Movie(found)); - } - } - TmdbResult::Series(series) => { - let tmdb_id = i64::from(series.tmdb_id); - if let Some(found) = sqlx::query_as!(LibrarySeries, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.blocked AS "blocked!: bool", s.poster_path, s.vote_average FROM series s WHERE s.tmdb_id = ?"#, tmdb_id) - .fetch_optional(database.pool()).await? - { - library.push(LibraryResult::Series(found)); - } - } - } - } + push_tracked(database, &results, &mut library).await?; } + // The SQL orders each half by title so the two halves merge predictably; + // the merged set is then ranked against the query, same as the TMDB one. + let query_tokens = tokens(input); + library.sort_by(|left, right| { + let (left, right) = (library_title(left), library_title(right)); + match_tier(&tokens(left), &query_tokens) + .cmp(&match_tier(&tokens(right), &query_tokens)) + .then_with(|| left.cmp(right)) + }); + Ok(Json(SearchResponse { kind, library, @@ -284,6 +238,89 @@ pub async fn search( })) } +/// Every tracked title the query names (§9.2): movies, then series, each +/// ordered by title so the merge below has something stable to rank. +async fn library_hits( + database: &arr_db::Db, + kind: SearchInputKind, + input: &str, +) -> Result, ApiError> { + let like_tokens_json = like_tokens(input); + + let mut library: Vec = if matches!(kind, SearchInputKind::TmdbId) { + let tmdb_id = input + .strip_prefix("tmdb:") + .unwrap_or(input) + .trim() + .parse::() + .map_err(|_| ApiError::Invalid("invalid TMDB id".into()))?; + sqlx::query_as!(Movie, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", title AS "title!: String", year, original_language, root_id AS "root_id!: i64", wanted AS "wanted!: bool", overrides AS "overrides!: serde_json::Value", state AS "state!: String", blocked AS "blocked!: bool", search_attempts AS "search_attempts!: i64", last_searched_at, poster_path, vote_average, (SELECT f.waiver FROM media_files f WHERE f.owner_kind = 'movie' AND f.owner_id = movies.id AND f.waiver IS NOT NULL ORDER BY f.id LIMIT 1) AS "waiver?: serde_json::Value" FROM movies WHERE tmdb_id = ? OR NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY title, year, id"#, tmdb_id, like_tokens_json) + .fetch_all(database.pool()).await? + .into_iter() + .map(LibraryResult::Movie) + .collect() + } else { + sqlx::query_as!(Movie, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", title AS "title!: String", year, original_language, root_id AS "root_id!: i64", wanted AS "wanted!: bool", overrides AS "overrides!: serde_json::Value", state AS "state!: String", blocked AS "blocked!: bool", search_attempts AS "search_attempts!: i64", last_searched_at, poster_path, vote_average, (SELECT f.waiver FROM media_files f WHERE f.owner_kind = 'movie' AND f.owner_id = movies.id AND f.waiver IS NOT NULL ORDER BY f.id LIMIT 1) AS "waiver?: serde_json::Value" FROM movies WHERE NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY title, year, id"#, like_tokens_json) + .fetch_all(database.pool()).await? + .into_iter() + .map(LibraryResult::Movie) + .collect() + }; + + let series_rows = if matches!(kind, SearchInputKind::TmdbId) { + let tmdb_id = input + .strip_prefix("tmdb:") + .unwrap_or(input) + .trim() + .parse::() + .map_err(|_| ApiError::Invalid("invalid TMDB id".into()))?; + sqlx::query_as!(LibrarySeries, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.blocked AS "blocked!: bool", s.poster_path, s.vote_average FROM series s WHERE s.tmdb_id = ? OR NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE s.title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY s.title, s.year, s.id"#, tmdb_id, like_tokens_json) + .fetch_all(database.pool()).await? + } else { + sqlx::query_as!(LibrarySeries, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.blocked AS "blocked!: bool", s.poster_path, s.vote_average FROM series s WHERE NOT EXISTS (SELECT 1 FROM json_each(?) token WHERE s.title NOT LIKE '%' || token.value || '%' ESCAPE '\') ORDER BY s.title, s.year, s.id"#, like_tokens_json) + .fetch_all(database.pool()).await? + }; + library.extend(series_rows.into_iter().map(LibraryResult::Series)); + Ok(library) +} + +/// §9.2: an `IMDb` id names one title, so what the library set owes the +/// operator is whether TMDB's answer is already tracked. +async fn push_tracked( + database: &arr_db::Db, + results: &[TmdbResult], + library: &mut Vec, +) -> Result<(), ApiError> { + for result in results { + match result { + TmdbResult::Movie(movie) => { + let tmdb_id = i64::from(movie.tmdb_id); + if let Some(found) = sqlx::query_as!(Movie, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", title AS "title!: String", year, original_language, root_id AS "root_id!: i64", wanted AS "wanted!: bool", overrides AS "overrides!: serde_json::Value", state AS "state!: String", blocked AS "blocked!: bool", search_attempts AS "search_attempts!: i64", last_searched_at, poster_path, vote_average, (SELECT f.waiver FROM media_files f WHERE f.owner_kind = 'movie' AND f.owner_id = movies.id AND f.waiver IS NOT NULL ORDER BY f.id LIMIT 1) AS "waiver?: serde_json::Value" FROM movies WHERE tmdb_id = ?"#, tmdb_id) + .fetch_optional(database.pool()).await? + { + library.push(LibraryResult::Movie(found)); + } + } + TmdbResult::Series(series) => { + let tmdb_id = i64::from(series.tmdb_id); + if let Some(found) = sqlx::query_as!(LibrarySeries, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.blocked AS "blocked!: bool", s.poster_path, s.vote_average FROM series s WHERE s.tmdb_id = ?"#, tmdb_id) + .fetch_optional(database.pool()).await? + { + library.push(LibraryResult::Series(found)); + } + } + } + } + Ok(()) +} + +fn library_title(result: &LibraryResult) -> &str { + match result { + LibraryResult::Movie(movie) => &movie.title, + LibraryResult::Series(series) => &series.title, + } +} + /// Movie and series TMDB ids live in separate namespaces, so deduplication /// keys on the kind as well as the id. fn already_matched(matches: &[TmdbResult], candidate: &TmdbResult) -> bool { @@ -376,28 +413,52 @@ async fn search_tmdb( ); results } - SearchInputKind::Text => { - let mut results: Vec = tmdb - .search_movies(input, None) - .await - .map_err(|error| upstream_error(&error))? - .into_iter() - .map(|movie| TmdbResult::Movie(movie.into())) - .collect(); - results.extend( - tmdb.search_series(input) - .await - .map_err(|error| upstream_error(&error))? - .into_iter() - .map(|series| TmdbResult::Series(series.into())), - ); - results - } + SearchInputKind::Text => search_text(tmdb, input).await?, SearchInputKind::Magnet | SearchInputKind::TorrentUrl => Vec::new(), }; Ok(results) } +/// Both TMDB endpoints for one title query, merged and ranked together. +async fn search_text( + tmdb: &arr_meta::TmdbClient, + input: &str, +) -> Result, ApiError> { + let query = tokens(input); + let mut ranked: Vec<(Relevance, TmdbResult)> = tmdb + .search_movies(input, None) + .await + .map_err(|error| upstream_error(&error))? + .into_iter() + .map(|movie| { + let relevance = Relevance::of( + &[&movie.title, &movie.original_title], + movie.popularity, + movie.vote_count, + &query, + ); + (relevance, TmdbResult::Movie(movie.into())) + }) + .collect(); + ranked.extend( + tmdb.search_series(input) + .await + .map_err(|error| upstream_error(&error))? + .into_iter() + .map(|series| { + let relevance = Relevance::of( + &[&series.title], + series.popularity, + series.vote_count, + &query, + ); + (relevance, TmdbResult::Series(series.into())) + }), + ); + ranked.sort_by(|(left, _), (right, _)| left.order(right)); + Ok(ranked.into_iter().map(|(_, result)| result).collect()) +} + #[utoipa::path( get, path = "/api/releases", tag = "search", params(ReleasesQuery), responses( @@ -656,6 +717,79 @@ fn input_kind(input: &str) -> SearchInputKind { } } +/// Where one result sits against the query that found it. +/// +/// TMDB answers movies and series on two endpoints, each sorted on its own. +/// Concatenating them buries a series behind every loosely-matching film — +/// "dexter" put *Dexter: Resurrection* below twenty Dexter Gordon concert +/// recordings. Both halves are ranked together instead: how squarely the +/// title matches first, then TMDB's own popularity. +struct Relevance { + tier: u8, + popularity: f64, + vote_count: u32, +} + +/// Matched some way TMDB understood and these tiers do not. +const TIER_OTHER: u8 = 4; + +impl Relevance { + /// The best tier any of the title's spellings earns — a film listed + /// under its original title should not be punished for the translation. + fn of(titles: &[&str], popularity: f64, vote_count: u32, query: &[String]) -> Self { + let tier = titles + .iter() + .map(|title| match_tier(&tokens(title), query)) + .min() + .unwrap_or(TIER_OTHER); + Self { + tier, + popularity, + vote_count, + } + } + + fn order(&self, other: &Self) -> std::cmp::Ordering { + self.tier + .cmp(&other.tier) + .then_with(|| other.popularity.total_cmp(&self.popularity)) + .then_with(|| other.vote_count.cmp(&self.vote_count)) + } +} + +/// How squarely `title` answers `query`, lower being better: the whole +/// title, the start of it, every query word somewhere in it, every query +/// word starting one of its words, or none of those. +fn match_tier(title: &[String], query: &[String]) -> u8 { + if query.is_empty() { + return TIER_OTHER; + } + if title == query { + 0 + } else if title.starts_with(query) { + 1 + } else if query.iter().all(|word| title.contains(word)) { + 2 + } else if query + .iter() + .all(|word| title.iter().any(|token| token.starts_with(word.as_str()))) + { + 3 + } else { + TIER_OTHER + } +} + +/// Lowercased words, with punctuation dropped: "Dexter: Resurrection" and +/// "dexter resurrection" are the same query. +fn tokens(value: &str) -> Vec { + value + .split(|character: char| !character.is_alphanumeric()) + .filter(|token| !token.is_empty()) + .map(str::to_lowercase) + .collect() +} + /// A multi-word title query needs word-wise matching, not one literal /// phrase. The query's tokens travel as a JSON array the queries walk with /// `json_each`; LIKE metacharacters are escaped here rather than in SQL. @@ -1600,6 +1734,79 @@ mod tests { assert_ne!(classified.score, core_score.total); } + /// A series is answered on TMDB's other endpoint, so concatenating the + /// two halves buried it behind every film that merely shares a word. + /// The merged set leads with the titles that answer the query. + #[tokio::test] + async fn text_results_rank_across_both_tmdb_endpoints() { + let tmdb = MockServer::start().await; + let prowlarr = MockServer::start().await; + Mock::given(method("GET")) + .and(path("/search/movie")) + .respond_with( + ResponseTemplate::new(200).set_body_json(serde_json::json!({"results":[ + {"id": 1, "title": "Dexter Gordon: More Than You Know", + "original_title": "Dexter Gordon: More Than You Know", + "original_language": "en", "popularity": 0.4}, + {"id": 2, "title": "Dexter's Laboratory: Ego Trip", + "original_title": "Dexter's Laboratory: Ego Trip", + "original_language": "en", "popularity": 3.2} + ]})), + ) + .mount(&tmdb) + .await; + Mock::given(method("GET")) + .and(path("/search/tv")) + .respond_with( + ResponseTemplate::new(200).set_body_json(serde_json::json!({"results":[ + {"id": 3, "name": "Dexter: Resurrection", "original_language": "en", + "first_air_date": "2025-07-11", "popularity": 90.0}, + {"id": 4, "name": "Dexter", "original_language": "en", + "first_air_date": "2006-10-01", "popularity": 120.0} + ]})), + ) + .mount(&tmdb) + .await; + let (_dir, _state, base) = application(&tmdb, &prowlarr).await; + + let response: serde_json::Value = reqwest::get(format!("{base}/api/search?q=dexter")) + .await + .expect("search") + .json() + .await + .expect("json"); + let order: Vec<&str> = response["tmdb"] + .as_array() + .expect("tmdb") + .iter() + .map(|hit| hit["title"].as_str().expect("title")) + .collect(); + assert_eq!( + order, + [ + "Dexter", + "Dexter: Resurrection", + "Dexter's Laboratory: Ego Trip", + "Dexter Gordon: More Than You Know", + ] + ); + } + + /// Punctuation is not part of the query: "dexter resurrection" and + /// "Dexter: Resurrection" are the same two words. + #[test] + fn punctuation_does_not_break_a_title_match() { + let query = tokens("dexter resurrection"); + assert_eq!(match_tier(&tokens("Dexter: Resurrection"), &query), 0); + assert_eq!( + match_tier(&tokens("Dexter: Resurrection (2025)"), &query), + 1 + ); + assert_eq!(match_tier(&tokens("Resurrection of Dexter"), &query), 2); + assert_eq!(match_tier(&tokens("Dexter's Resurrections"), &query), 3); + assert_eq!(match_tier(&tokens("Dexter"), &query), TIER_OTHER); + } + #[test] fn manual_inputs_skip_title_upstreams() { assert!(matches!( diff --git a/crates/arr-meta/src/model.rs b/crates/arr-meta/src/model.rs index e3a6f71..cc46796 100644 --- a/crates/arr-meta/src/model.rs +++ b/crates/arr-meta/src/model.rs @@ -37,6 +37,9 @@ pub struct MovieSearchResult { pub vote_average: Option, /// How many votes the rating rests on. pub vote_count: u32, + /// TMDB's own popularity figure. Unbounded and only meaningful as a + /// comparison between two rows of the same search. + pub popularity: f64, } impl MovieSearchResult { @@ -127,6 +130,9 @@ pub struct SeriesSearchResult { pub vote_average: Option, /// How many votes the rating rests on. pub vote_count: u32, + /// TMDB's own popularity figure. Unbounded and only meaningful as a + /// comparison between two rows of the same search. + pub popularity: f64, } impl SeriesSearchResult { @@ -333,6 +339,8 @@ pub(crate) struct RawSeriesSearchResult { vote_average: f64, #[serde(default)] vote_count: u32, + #[serde(default)] + popularity: f64, } impl From for SeriesSearchResult { @@ -346,6 +354,7 @@ impl From for SeriesSearchResult { poster_path: non_empty(raw.poster_path), vote_average: rating(raw.vote_average), vote_count: raw.vote_count, + popularity: raw.popularity, } } } @@ -503,6 +512,8 @@ pub(crate) struct RawSearchResult { vote_average: f64, #[serde(default)] vote_count: u32, + #[serde(default)] + popularity: f64, } impl From for MovieSearchResult { @@ -517,6 +528,7 @@ impl From for MovieSearchResult { poster_path: non_empty(raw.poster_path), vote_average: rating(raw.vote_average), vote_count: raw.vote_count, + popularity: raw.popularity, } } } diff --git a/web/index.html b/web/index.html index 8b24aca..9e44276 100644 --- a/web/index.html +++ b/web/index.html @@ -115,6 +115,23 @@
+ +