@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-db/src/requests/search_queue.rs

@@ -0,0 +1,352 @@
+//! Which wanted rows an automatic search pass takes next, and their backoff.
+
+use anyhow::Result;
+use rusqlite::{params, Connection};
+
+use super::wanted::{row_to_wanted, WantedRow, WANTED_COLS};
+use crate::chunked::IN_CHUNK;
+use crate::pool::Pool;
+
+/// Rows ready for an automatic search pass: still wanted, aired or undated, and
+/// past their backoff. Ordered freshest air date first, so an episode that aired
+/// this morning is searched before a gap from years ago that no pass will ever
+/// close; `next_search_at` breaks ties in favour of the longest-waiting row.
+pub fn wanted_searchable(
+    conn: &Connection,
+    today: &str,
+    now_ms: i64,
+    limit: usize,
+) -> rusqlite::Result<Vec<WantedRow>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {WANTED_COLS} FROM wanted \
+         WHERE status = 'wanted' AND (air_date IS NULL OR air_date <= ?1) \
+           AND (next_search_at IS NULL OR next_search_at <= ?2) \
+         ORDER BY air_date IS NULL, air_date DESC, \
+                  next_search_at IS NOT NULL, next_search_at, season, episode LIMIT ?3"
+    ))?;
+    let rows = stmt.query_map(params![today, now_ms, limit as i64], row_to_wanted)?;
+    rows.collect()
+}
+
+fn update_wanted_chunked(
+    pool: &Pool,
+    ids: &[String],
+    set_sql: &str,
+    lead: &[&dyn rusqlite::ToSql],
+) -> Result<()> {
+    if ids.is_empty() {
+        return Ok(());
+    }
+    let conn = pool.get()?;
+    for chunk in ids.chunks(IN_CHUNK) {
+        let ph = vec!["?"; chunk.len()].join(",");
+        let mut params_vec: Vec<&dyn rusqlite::ToSql> = lead.to_vec();
+        for id in chunk {
+            params_vec.push(id);
+        }
+        conn.execute(
+            &format!("UPDATE wanted SET {set_sql} WHERE id IN ({ph})"),
+            params_vec.as_slice(),
+        )?;
+    }
+    Ok(())
+}
+
+pub fn set_wanted_status(pool: &Pool, ids: &[String], status: &str, now_ms: i64) -> Result<()> {
+    update_wanted_chunked(
+        pool,
+        ids,
+        "status = ?1, updated_at = ?2",
+        &[&status, &now_ms],
+    )
+}
+
+/// Longest a searched row ever waits for its next turn.
+pub const MAX_SEARCH_DELAY_MS: i64 = 7 * 24 * 60 * 60 * 1000;
+
+// A row that keeps coming up empty costs an indexer round trip every pass, so
+// each fruitless attempt stretches its gap - up to five times the base, capped.
+const MAX_ATTEMPT_FACTOR: i64 = 5;
+
+/// Stamp a searched batch and push its next turn out by `base_delay_ms` grown
+/// by how many fruitless attempts each row already has. Callers group ids by
+/// base delay (see the acquisition module's `search::backoff`).
+pub fn schedule_next_search(
+    pool: &Pool,
+    ids: &[String],
+    now_ms: i64,
+    base_delay_ms: i64,
+) -> Result<()> {
+    update_wanted_chunked(
+        pool,
+        ids,
+        "search_attempts = search_attempts + 1, \
+         last_search_at = ?1, \
+         next_search_at = ?1 + MIN(?2 * MIN(search_attempts + 1, ?3), ?4), \
+         updated_at = ?1",
+        &[
+            &now_ms,
+            &base_delay_ms,
+            &MAX_ATTEMPT_FACTOR,
+            &MAX_SEARCH_DELAY_MS,
+        ],
+    )
+}
+
+/// Put a row back at the front of the queue (a newly aired episode), clearing
+/// the backoff its earlier unaired attempts accumulated.
+pub fn reset_wanted_search(pool: &Pool, ids: &[String], now_ms: i64) -> Result<()> {
+    update_wanted_chunked(
+        pool,
+        ids,
+        "search_attempts = 0, next_search_at = NULL, updated_at = ?1",
+        &[&now_ms],
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::requests::tests::*;
+    use crate::requests::{insert_request, replace_wanted};
+    use kroma_domain::RequestKind;
+
+    #[test]
+    fn wanted_searchable_gates_on_air_date_and_status() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        let mk =
+            |id: &str, episode: u32, air: Option<&str>, status: &str, searched: Option<i64>| {
+                WantedRow {
+                    id: id.into(),
+                    request_id: "r1".into(),
+                    kind: "episode".into(),
+                    tmdb_id: 1396,
+                    imdb_id: None,
+                    title: "T".into(),
+                    year: None,
+                    season: Some(1),
+                    episode: Some(episode),
+                    air_date: air.map(str::to_string),
+                    status: status.into(),
+                    last_search_at: searched,
+                }
+            };
+        let rows = vec![
+            mk("w-aired", 1, Some("2020-01-01"), "wanted", Some(500)),
+            mk("w-unaired", 2, Some("2999-01-01"), "wanted", None),
+            mk("w-grabbed", 3, Some("2020-01-01"), "grabbed", None),
+            mk("w-undated", 4, None, "wanted", None),
+        ];
+        replace_wanted(&p, "r1", &rows, 1000).unwrap();
+
+        let conn = p.get().unwrap();
+        let due = wanted_searchable(&conn, "2026-07-05", 4000, 10).unwrap();
+        let ids: Vec<&str> = due.iter().map(|w| w.id.as_str()).collect();
+        assert_eq!(
+            ids,
+            vec!["w-aired", "w-undated"],
+            "dated rows lead, undated trail"
+        );
+        drop(conn);
+
+        set_wanted_status(&p, &["w-aired".to_string()], "available", 2000).unwrap();
+        schedule_next_search(&p, &["w-undated".to_string()], 3000, 1000).unwrap();
+        let conn = p.get().unwrap();
+        let due = wanted_searchable(&conn, "2026-07-05", 4000, 10).unwrap();
+        assert_eq!(due.len(), 1);
+        assert_eq!(due[0].id, "w-undated");
+        assert_eq!(due[0].last_search_at, Some(3000));
+    }
+
+    #[test]
+    fn wanted_searchable_puts_the_freshest_air_date_first() {
+        // The whole point of the ordering: a weekly show's new episode must not
+        // queue behind a years-old gap no pass will ever close.
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        let mk = |id: &str, episode: u32, air: &str| WantedRow {
+            id: id.into(),
+            request_id: "r1".into(),
+            kind: "episode".into(),
+            tmdb_id: 1396,
+            imdb_id: None,
+            title: "T".into(),
+            year: None,
+            season: Some(1),
+            episode: Some(episode),
+            air_date: Some(air.into()),
+            status: "wanted".into(),
+            last_search_at: None,
+        };
+        replace_wanted(
+            &p,
+            "r1",
+            &[
+                mk("w-old", 1, "2019-03-04"),
+                mk("w-fresh", 2, "2026-07-04"),
+                mk("w-mid", 3, "2024-01-01"),
+            ],
+            1000,
+        )
+        .unwrap();
+
+        let conn = p.get().unwrap();
+        let due = wanted_searchable(&conn, "2026-07-05", 2000, 10).unwrap();
+        let ids: Vec<&str> = due.iter().map(|w| w.id.as_str()).collect();
+        assert_eq!(ids, vec!["w-fresh", "w-mid", "w-old"]);
+    }
+
+    #[test]
+    fn schedule_next_search_backs_a_row_off_and_resetting_brings_it_straight_back() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        let row = WantedRow {
+            id: "w1".into(),
+            request_id: "r1".into(),
+            kind: "episode".into(),
+            tmdb_id: 1396,
+            imdb_id: None,
+            title: "T".into(),
+            year: None,
+            season: Some(1),
+            episode: Some(1),
+            air_date: Some("2020-01-01".into()),
+            status: "wanted".into(),
+            last_search_at: None,
+        };
+        replace_wanted(&p, "r1", &[row], 1000).unwrap();
+        let ids = vec!["w1".to_string()];
+
+        schedule_next_search(&p, &ids, 10_000, 1000).unwrap();
+        let conn = p.get().unwrap();
+        assert!(
+            wanted_searchable(&conn, "2026-07-05", 10_500, 10)
+                .unwrap()
+                .is_empty(),
+            "backed off"
+        );
+        assert_eq!(
+            wanted_searchable(&conn, "2026-07-05", 11_000, 10)
+                .unwrap()
+                .len(),
+            1,
+            "due again"
+        );
+        drop(conn);
+
+        // A second fruitless attempt costs twice the base, a third three times.
+        schedule_next_search(&p, &ids, 11_000, 1000).unwrap();
+        let conn = p.get().unwrap();
+        assert!(wanted_searchable(&conn, "2026-07-05", 12_500, 10)
+            .unwrap()
+            .is_empty());
+        assert_eq!(
+            wanted_searchable(&conn, "2026-07-05", 13_000, 10)
+                .unwrap()
+                .len(),
+            1
+        );
+        drop(conn);
+
+        reset_wanted_search(&p, &ids, 12_000).unwrap();
+        let conn = p.get().unwrap();
+        assert_eq!(
+            wanted_searchable(&conn, "2026-07-05", 12_001, 10)
+                .unwrap()
+                .len(),
+            1,
+            "a newly aired episode jumps its own backoff"
+        );
+    }
+
+    #[test]
+    fn schedule_next_search_never_pushes_a_row_past_a_week() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Movie, 603, None), 1000).unwrap();
+        replace_wanted(
+            &p,
+            "r1",
+            &[WantedRow {
+                id: "w1".into(),
+                request_id: "r1".into(),
+                kind: "movie".into(),
+                tmdb_id: 603,
+                imdb_id: None,
+                title: "T".into(),
+                year: None,
+                season: None,
+                episode: None,
+                air_date: Some("2019-01-01".into()),
+                status: "wanted".into(),
+                last_search_at: None,
+            }],
+            1000,
+        )
+        .unwrap();
+
+        let ids = vec!["w1".to_string()];
+        for _ in 0..6 {
+            schedule_next_search(&p, &ids, 0, MAX_SEARCH_DELAY_MS).unwrap();
+        }
+        let conn = p.get().unwrap();
+        assert_eq!(
+            wanted_searchable(&conn, "2026-07-05", MAX_SEARCH_DELAY_MS, 10)
+                .unwrap()
+                .len(),
+            1
+        );
+    }
+
+    #[test]
+    fn wanted_searchable_gates_unreleased_movies() {
+        // A movie's wanted row carries its release date as air_date, with
+        // season/episode NULL.
+        let p = pool();
+        insert_request(&p, &new_req("m1", RequestKind::Movie, 603, None), 1000).unwrap();
+        let mk = |id: &str, air: Option<&str>| WantedRow {
+            id: id.into(),
+            request_id: "m1".into(),
+            kind: "movie".into(),
+            tmdb_id: 603,
+            imdb_id: None,
+            title: "M".into(),
+            year: None,
+            season: None,
+            episode: None,
+            air_date: air.map(str::to_string),
+            status: "wanted".into(),
+            last_search_at: None,
+        };
+        // replace_wanted is per-request, so each movie row needs its own request.
+        insert_request(&p, &new_req("m2", RequestKind::Movie, 604, None), 1000).unwrap();
+        insert_request(&p, &new_req("m3", RequestKind::Movie, 605, None), 1000).unwrap();
+        replace_wanted(&p, "m1", &[mk("m-future", Some("2999-01-01"))], 1000).unwrap();
+        replace_wanted(
+            &p,
+            "m2",
+            &[WantedRow {
+                request_id: "m2".into(),
+                ..mk("m-out", Some("2020-01-01"))
+            }],
+            1000,
+        )
+        .unwrap();
+        replace_wanted(
+            &p,
+            "m3",
+            &[WantedRow {
+                request_id: "m3".into(),
+                ..mk("m-nodate", None)
+            }],
+            1000,
+        )
+        .unwrap();
+
+        let conn = p.get().unwrap();
+        let due = wanted_searchable(&conn, "2026-07-05", 2000, 10).unwrap();
+        let mut ids: Vec<&str> = due.iter().map(|w| w.id.as_str()).collect();
+        ids.sort_unstable();
+        assert_eq!(ids, vec!["m-nodate", "m-out"]);
+    }
+}

package/rust/kroma-db/src/requests/tests.rs

@@ -0,0 +1,289 @@
+use super::*;
+use crate::testing::TempPool;
+
+pub(super) fn pool() -> TempPool {
+    crate::testing::temp_pool("req")
+}
+
+pub(super) fn seed_library(conn: &Connection) {
+    conn.execute(
+        "INSERT INTO libraries (id, name, kind, path, added_at) VALUES ('lib1','Films','movies','/x','now')",
+        [],
+    )
+    .unwrap();
+}
+
+pub(super) fn insert_movie_item(conn: &Connection, id: &str, tmdb: u64) {
+    conn.execute(
+        "INSERT INTO items (id, kind, title, container, library, added_at) \
+         VALUES (?1, 'movie', 'T', 'mkv', 'lib1', 'now')",
+        params![id],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO metadata_core (subject_kind, subject_id, tmdb_id, updated_at) \
+         VALUES ('item', ?1, ?2, 0)",
+        params![id, tmdb as i64],
+    )
+    .unwrap();
+}
+
+pub(super) fn new_req(
+    id: &str,
+    kind: RequestKind,
+    tmdb: u64,
+    seasons: Option<Vec<u32>>,
+) -> NewRequest {
+    NewRequest {
+        id: id.into(),
+        kind,
+        tmdb_id: tmdb,
+        title: "T".into(),
+        year: Some(2020),
+        poster_url: None,
+        seasons,
+        episodes: None,
+        status: RequestStatus::Pending,
+        requested_by: None,
+    }
+}
+
+pub(super) fn ep_row(id: &str, season: u32, episode: u32, status: &str) -> WantedRow {
+    WantedRow {
+        id: id.into(),
+        request_id: "r1".into(),
+        kind: "episode".into(),
+        tmdb_id: 1396,
+        imdb_id: None,
+        title: "T".into(),
+        year: None,
+        season: Some(season),
+        episode: Some(episode),
+        air_date: None,
+        status: status.into(),
+        last_search_at: None,
+    }
+}
+
+pub(super) fn seed_show(p: &Pool, show_id: &str) {
+    let conn = p.get().unwrap();
+    conn.execute(
+        "INSERT OR IGNORE INTO libraries (id, name, kind, path, added_at) \
+         VALUES ('lib1','Films','movies','/x','now')",
+        [],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO shows (id, library, title, added_at) VALUES (?1,'lib1','S','now')",
+        params![show_id],
+    )
+    .unwrap();
+}
+
+pub(super) fn gap(season: u32, episode: u32, air: &str) -> (u32, u32, Option<String>) {
+    (season, episode, Some(air.to_string()))
+}
+
+pub(super) fn seed_user(conn: &Connection, id: &str) {
+    conn.execute(
+        "INSERT OR IGNORE INTO users (id,email,username,password_hash,created_at) \
+         VALUES (?1, ?1 || '@t.dev', ?1, 'h', 'now')",
+        params![id],
+    )
+    .unwrap();
+}
+
+pub(super) fn req_by(pool: &Pool, id: &str, tmdb: u64, status: RequestStatus, owner: Option<&str>) {
+    {
+        let conn = pool.get().unwrap();
+        if let Some(o) = owner {
+            seed_user(&conn, o);
+        }
+    }
+    let mut new = new_req(id, RequestKind::Movie, tmdb, None);
+    new.status = status;
+    new.requested_by = owner.map(str::to_string);
+    new.title = format!("Title {id}");
+    insert_request(pool, &new, 1_000).unwrap();
+}
+
+pub(super) fn wanted_row(id: &str, request_id: &str, air: Option<&str>, status: &str) -> WantedRow {
+    WantedRow {
+        id: id.into(),
+        request_id: request_id.into(),
+        kind: "movie".into(),
+        tmdb_id: 1,
+        imdb_id: None,
+        title: "T".into(),
+        year: Some(2020),
+        season: None,
+        episode: None,
+        air_date: air.map(str::to_string),
+        status: status.into(),
+        last_search_at: None,
+    }
+}
+
+#[test]
+fn request_roundtrip_merge_and_cascade() {
+    let p = pool();
+    insert_request(
+        &p,
+        &new_req("r1", RequestKind::Show, 1396, Some(vec![1])),
+        1000,
+    )
+    .unwrap();
+
+    let conn = p.get().unwrap();
+    let open = find_open_request(&conn, RequestKind::Show, 1396)
+        .unwrap()
+        .unwrap();
+    assert_eq!(open.id, "r1");
+    assert_eq!(open.seasons.as_deref(), Some(&[1u32][..]));
+    assert_eq!(open.status, RequestStatus::Pending);
+    drop(conn);
+
+    set_request_seasons(&p, "r1", Some(&[1, 2]), 2000).unwrap();
+    let conn = p.get().unwrap();
+    assert_eq!(
+        get_request(&conn, "r1")
+            .unwrap()
+            .unwrap()
+            .seasons
+            .as_deref(),
+        Some(&[1u32, 2][..])
+    );
+    drop(conn);
+
+    set_request_episodes(
+        &p,
+        "r1",
+        Some(&[EpisodeRef {
+            season: 3,
+            episode: 5,
+        }]),
+        2100,
+    )
+    .unwrap();
+    let conn = p.get().unwrap();
+    assert_eq!(
+        get_request(&conn, "r1")
+            .unwrap()
+            .unwrap()
+            .episodes
+            .as_deref(),
+        Some(
+            &[EpisodeRef {
+                season: 3,
+                episode: 5
+            }][..]
+        )
+    );
+    drop(conn);
+
+    set_request_status(
+        &p,
+        "r1",
+        RequestStatus::Denied,
+        Some("boss"),
+        Some("non"),
+        3000,
+    )
+    .unwrap();
+    let conn = p.get().unwrap();
+    assert!(find_open_request(&conn, RequestKind::Show, 1396)
+        .unwrap()
+        .is_none());
+    let denied = get_request(&conn, "r1").unwrap().unwrap();
+    assert_eq!(denied.status, RequestStatus::Denied);
+    assert_eq!(denied.note.as_deref(), Some("non"));
+    drop(conn);
+
+    let rows = vec![WantedRow {
+        id: "w1".into(),
+        request_id: "r1".into(),
+        kind: "episode".into(),
+        tmdb_id: 1396,
+        imdb_id: None,
+        title: "T".into(),
+        year: None,
+        season: Some(1),
+        episode: Some(1),
+        air_date: Some("2020-01-01".into()),
+        status: "wanted".into(),
+        last_search_at: None,
+    }];
+    replace_wanted(&p, "r1", &rows, 4000).unwrap();
+    let conn = p.get().unwrap();
+    assert_eq!(wanted_for_request(&conn, "r1").unwrap().len(), 1);
+    drop(conn);
+    assert!(delete_request(&p, "r1").unwrap());
+    let conn = p.get().unwrap();
+    assert!(wanted_for_request(&conn, "r1").unwrap().is_empty());
+}
+
+#[test]
+fn set_request_air_roundtrips_and_last_refresh_is_internal() {
+    let p = pool();
+    insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+    set_request_air(&p, "r1", Some("Returning Series"), Some("2026-01-17"), 5000).unwrap();
+    let conn = p.get().unwrap();
+    let req = get_request(&conn, "r1").unwrap().unwrap();
+    assert_eq!(req.air_status.as_deref(), Some("Returning Series"));
+    assert_eq!(req.next_air_date.as_deref(), Some("2026-01-17"));
+    assert_eq!(req.last_refresh_at, Some(5000));
+    assert_eq!(req.updated_at, 1000);
+    drop(conn);
+    set_request_air(&p, "r1", Some("Ended"), None, 6000).unwrap();
+    let conn = p.get().unwrap();
+    let req = get_request(&conn, "r1").unwrap().unwrap();
+    assert_eq!(req.air_status.as_deref(), Some("Ended"));
+    assert_eq!(req.next_air_date, None);
+    let json = serde_json::to_value(&req).unwrap();
+    assert!(json.get("lastRefreshAt").is_none());
+    assert_eq!(
+        json.get("airStatus").and_then(serde_json::Value::as_str),
+        Some("Ended")
+    );
+}
+
+#[test]
+fn a_users_own_requests_are_the_only_ones_they_see() {
+    // Per-account: seeing another user's asks leaks what the household watches.
+    let pool = pool();
+    req_by(&pool, "r-ana", 1, RequestStatus::Pending, Some("ana"));
+    req_by(&pool, "r-bo", 2, RequestStatus::Pending, Some("bo"));
+    req_by(&pool, "r-old", 3, RequestStatus::Pending, None);
+
+    let conn = pool.get().unwrap();
+    let ana = list_requests(&conn, Some("ana")).unwrap();
+    assert_eq!(ana.len(), 1);
+    assert_eq!(ana[0].id, "r-ana");
+
+    assert_eq!(list_requests(&conn, None).unwrap().len(), 3);
+}
+
+#[test]
+fn the_latest_request_for_a_title_is_the_newest_one() {
+    let pool = pool();
+    let mut denied = new_req("r-old", RequestKind::Movie, 603, None);
+    denied.status = RequestStatus::Denied;
+    insert_request(&pool, &denied, 1_000).unwrap();
+    let mut fresh = new_req("r-new", RequestKind::Movie, 603, None);
+    fresh.status = RequestStatus::Pending;
+    insert_request(&pool, &fresh, 2_000).unwrap();
+
+    let conn = pool.get().unwrap();
+    let found = latest_request_for(&conn, RequestKind::Movie, 603)
+        .unwrap()
+        .unwrap();
+    assert_eq!(found.0, "r-new");
+    assert_eq!(found.1, RequestStatus::Pending);
+
+    assert!(latest_request_for(&conn, RequestKind::Movie, 999)
+        .unwrap()
+        .is_none());
+    assert!(latest_request_for(&conn, RequestKind::Show, 603)
+        .unwrap()
+        .is_none());
+}