feat(db): store poster, backdrop and rating on titles

§9.6 keeps rich detail out of the database except for the three fields pure-SQL views need. Adds poster_path, backdrop_path and vote_average to movies and series, written by the daily metadata refresh in both lanes and filled at add time from the TMDB response the create flows already fetch.
2026-08-23 22:12:05 +01:00
parent 9bd037d1b6
commit 8478c0f8a9
14 changed files with 484 additions and 78 deletions
@@ -183,6 +183,50 @@ impl GrabAction {
        let tmdb_id =
            u32::try_from(movie.tmdb_id).map_err(|_| GrabError::InvalidTmdbId(movie.id))?;
        let metadata = tmdb.movie(tmdb_id).await?;
+        let changed = self.store_metadata(database, &movie, &metadata).await?;
+        if changed {
+            tracing::info!(
+                movie_id = movie.id,
+                "metadata changed; reset targeted search backoff"
+            );
+        }
+        let released = metadata.is_digitally_released(chrono::Utc::now().date_naive());
+        if !released {
+            tracing::debug!(
+                movie_id = movie.id,
+                "digital release has not happened; skipping targeted search"
+            );
+        }
+        let title = metadata.title.clone();
+        Ok((
+            PendingMovie {
+                id: movie.id,
+                tmdb_id: movie.tmdb_id,
+                title,
+                year: metadata.year().map(i64::from),
+                original_language: (!metadata.original_language.is_empty())
+                    .then_some(metadata.original_language.clone()),
+                search_attempts: if changed { 0 } else { movie.search_attempts },
+                last_searched_at: if changed {
+                    None
+                } else {
+                    movie.last_searched_at
+                },
+                digital_release: metadata.digital_release.map(|date| date.to_string()),
+                metadata_refreshed_at: None,
+            },
+            released,
+        ))
+    }
+
+    /// Write one refresh's fields to the row, guarded so unchanged data moves
+    /// nothing. Returns whether anything did.
+    async fn store_metadata(
+        &self,
+        database: &Db,
+        movie: &PendingMovie,
+        metadata: &arr_meta::Movie,
+    ) -> Result<bool, GrabError> {
        let title = metadata.title.clone();
        let year = metadata.year().map(i64::from);
        let original_language =
@@ -191,43 +235,53 @@ impl GrabAction {
        // §6.2: the id RSS matching prefers, and the one Torznab movie
        // searches take. TMDB does not know one for every title.
        let imdb_id = metadata.imdb_id.clone();
+        // §9.6: these three are the exception to "rich detail is not
+        // persisted" — pure-SQL views render artwork without a TMDB call.
+        let poster_path = metadata.poster_path.clone();
+        let backdrop_path = metadata.backdrop_path.clone();
+        let vote_average = metadata.vote_average;
        let title_ref = title.as_str();
        let original_language_ref = original_language.as_deref();
        let digital_release_ref = digital_release.as_deref();
        let imdb_id_ref = imdb_id.as_deref();
+        let poster_path_ref = poster_path.as_deref();
+        let backdrop_path_ref = backdrop_path.as_deref();
        let changed = sqlx::query!(
            r#"UPDATE movies
               SET title = ?, year = ?, original_language = ?, digital_release = ?,
-                   imdb_id = ?,
+                   imdb_id = ?, poster_path = ?, backdrop_path = ?, vote_average = ?,
                   metadata_refreshed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
                   search_attempts = 0, last_searched_at = NULL,
                   updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
               WHERE id = ? AND (
                   title IS NOT ? OR year IS NOT ? OR original_language IS NOT ?
                   OR digital_release IS NOT ? OR imdb_id IS NOT ?
+                   OR poster_path IS NOT ? OR backdrop_path IS NOT ?
+                   OR vote_average IS NOT ?
               )"#,
            title_ref,
            year,
            original_language_ref,
            digital_release_ref,
            imdb_id_ref,
+            poster_path_ref,
+            backdrop_path_ref,
+            vote_average,
            movie.id,
            title_ref,
            year,
            original_language_ref,
            digital_release_ref,
            imdb_id_ref,
+            poster_path_ref,
+            backdrop_path_ref,
+            vote_average,
        )
        .execute(database.pool())
        .await?
        .rows_affected()
            != 0;
-        if changed {
-            tracing::info!(
-                movie_id = movie.id,
-                "metadata changed; reset targeted search backoff"
-            );
-        } else {
+        if !changed {
            // Still stamp the refresh even when nothing changed, or the TTL
            // gate above never engages and every tick pays for TMDB again.
            sqlx::query!(
@@ -238,31 +292,7 @@ impl GrabAction {
            .execute(database.pool())
            .await?;
        }
-        let released = metadata.is_digitally_released(chrono::Utc::now().date_naive());
-        if !released {
-            tracing::debug!(
-                movie_id = movie.id,
-                "digital release has not happened; skipping targeted search"
-            );
-        }
-        Ok((
-            PendingMovie {
-                id: movie.id,
-                tmdb_id: movie.tmdb_id,
-                title,
-                year,
-                original_language,
-                search_attempts: if changed { 0 } else { movie.search_attempts },
-                last_searched_at: if changed {
-                    None
-                } else {
-                    movie.last_searched_at
-                },
-                digital_release,
-                metadata_refreshed_at: None,
-            },
-            released,
-        ))
+        Ok(changed)
    }

    /// Search every indexer for one title, cache each candidate with its
@@ -2417,6 +2447,56 @@ mod tests {
        assert_eq!(targeted_searches(&indexer).await, 3);
    }

+    /// §9.6: the daily refresh also writes the three stored artwork fields,
+    /// so pure-SQL views render a poster without a TMDB call per row.
+    #[tokio::test]
+    async fn metadata_refresh_writes_the_stored_artwork_fields() {
+        let (_dir, database) = wanted_movie().await;
+        let indexer = empty_prowlarr().await;
+        let artwork_metadata = RELEASED_METADATA.replace(
+            r#""original_language": "en","#,
+            r#""original_language": "en",
+              "poster_path": "/dune-two.jpg",
+              "backdrop_path": "/dune-two-wide.jpg",
+              "vote_average": 8.152,"#,
+        );
+        let metadata = tmdb(&artwork_metadata).await;
+        let (downloader, _fake) = transmission().await;
+
+        action_with_tmdb(&indexer, &downloader, &metadata)
+            .tick(&database)
+            .await
+            .unwrap();
+
+        let (poster, backdrop, vote): (Option<String>, Option<String>, Option<f64>) =
+            sqlx::query_as("SELECT poster_path, backdrop_path, vote_average FROM movies")
+                .fetch_one(database.pool())
+                .await
+                .unwrap();
+        assert_eq!(poster.as_deref(), Some("/dune-two.jpg"));
+        assert_eq!(backdrop.as_deref(), Some("/dune-two-wide.jpg"));
+        assert_eq!(vote, Some(8.152));
+
+        // Idempotent: an unchanged refresh neither rewrites nor re-reports,
+        // same as the fields above it.
+        sqlx::query(
+            "UPDATE movies SET metadata_refreshed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-7 hours')",
+        )
+        .execute(database.pool())
+        .await
+        .unwrap();
+        action_with_tmdb(&indexer, &downloader, &metadata)
+            .tick(&database)
+            .await
+            .unwrap();
+        let unchanged: (Option<String>, Option<String>, Option<f64>) =
+            sqlx::query_as("SELECT poster_path, backdrop_path, vote_average FROM movies")
+                .fetch_one(database.pool())
+                .await
+                .unwrap();
+        assert_eq!(unchanged, (poster, backdrop, vote));
+    }
+
    #[tokio::test]
    async fn metadata_changes_reset_a_title_backoff() {
        let (_dir, database) = wanted_movie().await;
@@ -74,7 +74,8 @@ impl SeriesRefreshAction {
            r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", tvdb_id,
                      title AS "title!: String", year, original_language,
                      root_id AS "root_id!: i64", auto_track AS "auto_track!: bool",
-                      upstream_ended AS "upstream_ended!: bool", metadata_refreshed_at
+                      upstream_ended AS "upstream_ended!: bool", metadata_refreshed_at,
+                      poster_path, backdrop_path, vote_average
               FROM series
               ORDER BY metadata_refreshed_at IS NOT NULL, metadata_refreshed_at, id"#
        )
@@ -222,6 +223,29 @@ impl SeriesRefreshAction {
            .await?;
            changed = true;
        }
+        // §9.6: these three are the exception to "rich detail is not
+        // persisted" — pure-SQL views render artwork without a TMDB call.
+        let poster_path = metadata.poster_path.clone();
+        let backdrop_path = metadata.backdrop_path.clone();
+        let vote_average = metadata.vote_average;
+        let poster_path_ref = poster_path.as_deref();
+        let backdrop_path_ref = backdrop_path.as_deref();
+        let artwork_moved =
+            stale.poster_path != poster_path || stale.backdrop_path != backdrop_path;
+        if artwork_moved || stale.vote_average != Some(vote_average) {
+            sqlx::query!(
+                "UPDATE series SET poster_path = ?, backdrop_path = ?, vote_average = ?,
+                                        updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+                 WHERE id = ?",
+                poster_path_ref,
+                backdrop_path_ref,
+                vote_average,
+                stale.id
+            )
+            .execute(&mut *executor)
+            .await?;
+            changed = true;
+        }
        Ok(changed)
    }

@@ -481,8 +505,11 @@ struct DueSeries {
    auto_track: bool,
    upstream_ended: bool,
    metadata_refreshed_at: Option<String>,
+    /// §9.6 artwork columns, compared against TMDB's on each refresh.
+    poster_path: Option<String>,
+    backdrop_path: Option<String>,
+    vote_average: Option<f64>,
 }
-
 /// TMDB numbers are unbounded; ours are `u16` (`CHECK (number >= 0)`,
 /// STRICT). A number past `u16::MAX` cannot match anything real and would
 /// never be grabbed anyway.
@@ -716,6 +743,42 @@ mod tests {
        .unwrap();
    }

+    /// §9.6: the daily refresh writes the three stored artwork fields, so
+    /// pure-SQL views render a poster without a TMDB call per row.
+    #[tokio::test]
+    async fn refresh_writes_the_stored_artwork_fields() {
+        let (_dir, database) = seeded_series(true).await;
+        let server = MockServer::start().await;
+        Mock::given(method("GET"))
+            .and(path("/tv/82728"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+                "id": 82_728,
+                "name": "Bluey",
+                "original_language": "en",
+                "first_air_date": "2018-10-01",
+                "status": "Returning Series",
+                "poster_path": "/bluey.jpg",
+                "backdrop_path": "/bluey-wide.jpg",
+                "vote_average": 8.417,
+                "seasons": []
+            })))
+            .mount(&server)
+            .await;
+
+        action(&server).tick(&database).await.unwrap();
+
+        let (poster, backdrop, vote): (Option<String>, Option<String>, Option<f64>) =
+            sqlx::query_as(
+                "SELECT poster_path, backdrop_path, vote_average FROM series WHERE tmdb_id = 82728",
+            )
+            .fetch_one(database.pool())
+            .await
+            .unwrap();
+        assert_eq!(poster.as_deref(), Some("/bluey.jpg"));
+        assert_eq!(backdrop.as_deref(), Some("/bluey-wide.jpg"));
+        assert_eq!(vote, Some(8.417));
+    }
+
    #[tokio::test]
    async fn first_refresh_reveals_seasons_and_applies_auto_track() {
        let (_dir, database) = seeded_series(true).await;