@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,351 @@
+//! The wanted ledger: one row per unit a request covers.
+
+use anyhow::Result;
+use rusqlite::{params, Connection, Row};
+
+use crate::chunked::IN_CHUNK;
+use crate::pool::Pool;
+
+/// One wanted unit: a movie, or one episode of a requested show season.
+#[derive(Debug, Clone)]
+pub struct WantedRow {
+    pub id: String,
+    pub request_id: String,
+    pub kind: String,
+    // The movie's TMDB id, or the SHOW's TMDB id for episodes.
+    pub tmdb_id: u64,
+    pub imdb_id: Option<String>,
+    pub title: String,
+    pub year: Option<u32>,
+    pub season: Option<u32>,
+    pub episode: Option<u32>,
+    // Unaired episodes (YYYY-MM-DD) are skipped by search until the date passes.
+    pub air_date: Option<String>,
+    pub status: String,
+    pub last_search_at: Option<i64>,
+}
+
+pub(super) fn row_to_wanted(r: &Row) -> rusqlite::Result<WantedRow> {
+    Ok(WantedRow {
+        id: r.get(0)?,
+        request_id: r.get(1)?,
+        kind: r.get(2)?,
+        tmdb_id: r.get::<_, i64>(3)? as u64,
+        imdb_id: r.get(4)?,
+        title: r.get(5)?,
+        year: r.get(6)?,
+        season: r.get(7)?,
+        episode: r.get(8)?,
+        air_date: r.get(9)?,
+        status: r.get(10)?,
+        last_search_at: r.get(11)?,
+    })
+}
+
+pub(super) const WANTED_COLS: &str =
+    "id, request_id, kind, tmdb_id, imdb_id, title, year, season, episode, air_date, status, last_search_at";
+
+// Append after an `INSERT INTO` / `INSERT OR IGNORE INTO` verb.
+const WANTED_INSERT_TAIL: &str =
+    "wanted (id, request_id, kind, tmdb_id, imdb_id, title, year, season, episode, air_date, status, last_search_at, updated_at) \
+     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)";
+
+fn insert_wanted_rows(
+    conn: &Connection,
+    sql: &str,
+    rows: &[WantedRow],
+    now_ms: i64,
+) -> rusqlite::Result<()> {
+    let mut stmt = conn.prepare(sql)?;
+    for w in rows {
+        stmt.execute(params![
+            w.id,
+            w.request_id,
+            w.kind,
+            w.tmdb_id as i64,
+            w.imdb_id,
+            w.title,
+            w.year,
+            w.season,
+            w.episode,
+            w.air_date,
+            w.status,
+            w.last_search_at,
+            now_ms
+        ])?;
+    }
+    Ok(())
+}
+
+/// Replace a request's wanted rows in one transaction.
+pub fn replace_wanted(
+    pool: &Pool,
+    request_id: &str,
+    rows: &[WantedRow],
+    now_ms: i64,
+) -> Result<()> {
+    let mut conn = pool.get()?;
+    let tx = conn.transaction()?;
+    tx.execute(
+        "DELETE FROM wanted WHERE request_id = ?1",
+        params![request_id],
+    )?;
+    insert_wanted_rows(
+        &tx,
+        &format!("INSERT INTO {WANTED_INSERT_TAIL}"),
+        rows,
+        now_ms,
+    )?;
+    tx.commit()?;
+    Ok(())
+}
+
+/// Additive: newly-aired episodes join the ledger without disturbing existing
+/// grabbed/available rows, and a duplicate deterministic id is a no-op.
+pub fn insert_wanted(pool: &Pool, rows: &[WantedRow], now_ms: i64) -> Result<()> {
+    if rows.is_empty() {
+        return Ok(());
+    }
+    let mut conn = pool.get()?;
+    let tx = conn.transaction()?;
+    insert_wanted_rows(
+        &tx,
+        &format!("INSERT OR IGNORE INTO {WANTED_INSERT_TAIL}"),
+        rows,
+        now_ms,
+    )?;
+    tx.commit()?;
+    Ok(())
+}
+
+/// Drop the request's wanted rows that are no longer wanted, keeping `keep_ids`.
+///
+/// The other half of a reconcile: [`insert_wanted`] adds what is newly covered
+/// without disturbing what was already there, and this removes what stopped
+/// being covered. Together they change a request's SCOPE while every surviving
+/// row keeps the state it had -- which [`replace_wanted`] cannot do, since it
+/// deletes the lot and re-inserts them all as `wanted`, forgetting what was
+/// already downloaded.
+pub fn prune_wanted(pool: &Pool, request_id: &str, keep_ids: &[String]) -> Result<usize> {
+    let mut conn = pool.get()?;
+    let tx = conn.transaction()?;
+    let removed = if keep_ids.is_empty() {
+        tx.execute(
+            "DELETE FROM wanted WHERE request_id = ?1",
+            params![request_id],
+        )?
+    } else {
+        let keep: std::collections::HashSet<&str> = keep_ids.iter().map(String::as_str).collect();
+        let present: Vec<String> = {
+            let mut stmt = tx.prepare("SELECT id FROM wanted WHERE request_id = ?1")?;
+            let rows = stmt.query_map(params![request_id], |r| r.get::<_, String>(0))?;
+            rows.collect::<rusqlite::Result<Vec<_>>>()?
+        };
+        // The set difference is taken here rather than as a chunked `NOT IN`:
+        // one chunk of the keep list does not know about the next, so it would
+        // delete rows a later chunk keeps.
+        let doomed: Vec<&String> = present
+            .iter()
+            .filter(|id| !keep.contains(id.as_str()))
+            .collect();
+        let mut removed = 0;
+        for chunk in doomed.chunks(IN_CHUNK) {
+            let holes = std::iter::repeat_n("?", chunk.len())
+                .collect::<Vec<_>>()
+                .join(",");
+            removed += tx.execute(
+                &format!("DELETE FROM wanted WHERE id IN ({holes})"),
+                rusqlite::params_from_iter(chunk.iter()),
+            )?;
+        }
+        removed
+    };
+    tx.commit()?;
+    Ok(removed)
+}
+
+/// Only fills a NULL `air_date`, so a known date is never overwritten, and never
+/// touches `status`.
+pub fn set_wanted_air_date(pool: &Pool, id: &str, air_date: &str, now_ms: i64) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "UPDATE wanted SET air_date = ?2, updated_at = ?3 WHERE id = ?1 AND air_date IS NULL",
+        params![id, air_date, now_ms],
+    )?;
+    Ok(())
+}
+
+pub fn wanted_for_request(conn: &Connection, request_id: &str) -> rusqlite::Result<Vec<WantedRow>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {WANTED_COLS} FROM wanted WHERE request_id = ?1 ORDER BY season, episode"
+    ))?;
+    let rows = stmt.query_map(params![request_id], row_to_wanted)?;
+    rows.collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::requests::tests::*;
+    use crate::requests::{insert_request, replace_show_gaps};
+    use kroma_domain::RequestKind;
+
+    #[test]
+    fn pruning_narrows_a_ledger_and_leaves_the_survivors_as_they_were() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        replace_wanted(
+            &p,
+            "r1",
+            &[
+                ep_row("w1", 1, 1, "available"),
+                ep_row("w2", 1, 2, "grabbed"),
+                ep_row("w3", 2, 1, "wanted"),
+            ],
+            1000,
+        )
+        .unwrap();
+
+        let removed = prune_wanted(&p, "r1", &["w1".into(), "w2".into()]).unwrap();
+        assert_eq!(removed, 1, "only the row that fell out of scope");
+
+        let conn = p.get().unwrap();
+        let rows = wanted_for_request(&conn, "r1").unwrap();
+        assert_eq!(rows.len(), 2);
+        // The point of pruning over replacing: what was downloaded stays known.
+        assert_eq!(
+            rows.iter().find(|w| w.id == "w1").unwrap().status,
+            "available"
+        );
+        assert_eq!(
+            rows.iter().find(|w| w.id == "w2").unwrap().status,
+            "grabbed"
+        );
+    }
+
+    #[test]
+    fn pruning_to_nothing_empties_the_ledger() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        replace_wanted(&p, "r1", &[ep_row("w1", 1, 1, "wanted")], 1000).unwrap();
+        assert_eq!(prune_wanted(&p, "r1", &[]).unwrap(), 1);
+        let conn = p.get().unwrap();
+        assert!(wanted_for_request(&conn, "r1").unwrap().is_empty());
+    }
+
+    #[test]
+    fn a_keep_list_longer_than_one_chunk_keeps_every_row_it_names() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        let rows: Vec<WantedRow> = (0..IN_CHUNK + 50)
+            .map(|n| ep_row(&format!("w{n}"), 1, n as u32, "wanted"))
+            .collect();
+        replace_wanted(&p, "r1", &rows, 1000).unwrap();
+
+        let keep: Vec<String> = rows.iter().skip(1).map(|w| w.id.clone()).collect();
+        let removed = prune_wanted(&p, "r1", &keep).unwrap();
+
+        assert_eq!(removed, 1);
+        let conn = p.get().unwrap();
+        assert_eq!(wanted_for_request(&conn, "r1").unwrap().len(), keep.len());
+    }
+
+    #[test]
+    fn pruning_one_request_never_reaches_another() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        insert_request(&p, &new_req("r2", RequestKind::Show, 1400, None), 1000).unwrap();
+        replace_wanted(&p, "r1", &[ep_row("w1", 1, 1, "wanted")], 1000).unwrap();
+        let mut other = ep_row("w9", 1, 1, "wanted");
+        other.request_id = "r2".into();
+        replace_wanted(&p, "r2", &[other], 1000).unwrap();
+
+        prune_wanted(&p, "r1", &[]).unwrap();
+        let conn = p.get().unwrap();
+        assert_eq!(
+            wanted_for_request(&conn, "r2").unwrap().len(),
+            1,
+            "r2 untouched"
+        );
+    }
+
+    #[test]
+    fn insert_wanted_is_additive_and_never_disturbs_grabbed() {
+        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| 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: None,
+        };
+        replace_wanted(
+            &p,
+            "r1",
+            &[
+                mk("w-e1", 1, Some("2020-01-01"), "grabbed"),
+                mk("w-e2", 2, None, "wanted"),
+            ],
+            1000,
+        )
+        .unwrap();
+        insert_wanted(
+            &p,
+            &[
+                mk("w-e3", 3, Some("2020-01-03"), "wanted"),
+                mk("w-e1", 1, Some("2020-01-01"), "wanted"),
+            ],
+            2000,
+        )
+        .unwrap();
+        set_wanted_air_date(&p, "w-e2", "2020-01-02", 2000).unwrap();
+        set_wanted_air_date(&p, "w-e1", "2999-01-01", 2000).unwrap();
+
+        let conn = p.get().unwrap();
+        let rows = wanted_for_request(&conn, "r1").unwrap();
+        assert_eq!(rows.len(), 3, "e3 added; the e1 duplicate was ignored");
+        let by_ep = |ep: u32| rows.iter().find(|w| w.episode == Some(ep)).unwrap();
+        assert_eq!(by_ep(1).status, "grabbed");
+        assert_eq!(by_ep(1).air_date.as_deref(), Some("2020-01-01"));
+        assert_eq!(by_ep(2).air_date.as_deref(), Some("2020-01-02"));
+        assert_eq!(by_ep(3).status, "wanted");
+    }
+
+    #[test]
+    fn a_refused_row_rolls_the_whole_ledger_write_back() {
+        let pool = pool();
+        let conn = pool.get().unwrap();
+        seed_library(&conn);
+        insert_request(&pool, &new_req("r-1", RequestKind::Show, 1396, None), 1_000).unwrap();
+        conn.execute_batch(
+            "CREATE TRIGGER no_wanted BEFORE INSERT ON wanted \
+             BEGIN SELECT RAISE(ABORT, 'refused'); END;
+             CREATE TRIGGER no_gaps BEFORE INSERT ON library_gaps \
+             BEGIN SELECT RAISE(ABORT, 'refused'); END",
+        )
+        .unwrap();
+        drop(conn);
+
+        let rows = vec![wanted_row("w-1", "r-1", Some("2030-01-01"), "wanted")];
+        assert!(insert_wanted(&pool, &rows, 1_000).is_err());
+        assert!(replace_wanted(&pool, "r-1", &rows, 1_000).is_err());
+        assert!(replace_show_gaps(
+            &pool,
+            "s1",
+            1396,
+            "Breaking Bad",
+            None,
+            &[(1, 1, Some("2030-01-01".into()))],
+            1_000
+        )
+        .is_err());
+    }
+}

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

@@ -0,0 +1,245 @@
+//! The `requests` table: a title someone asked for, and its lifecycle.
+//!
+//! The ledger a request expands into lives in [`wanted`], read back as a
+//! calendar in [`calendar`], beside the [`gaps`] a library scan finds; [`search_queue`]
+//! decides which of those rows a search pass takes next, and [`availability`]
+//! answers what the library already holds. All re-exported flat here so the
+//! public `db::<item>` paths resolve unchanged.
+
+use rusqlite::OptionalExtension;
+
+use super::*;
+use kroma_domain::{EpisodeRef, MediaRequest, RequestKind, RequestStatus};
+
+mod availability;
+mod calendar;
+mod gaps;
+mod search_queue;
+mod wanted;
+
+#[cfg(test)]
+mod tests;
+
+pub use availability::*;
+pub use calendar::*;
+pub use gaps::*;
+pub use search_queue::*;
+pub use wanted::*;
+
+// New columns must be appended, never inserted: callers read rows by position.
+const REQUEST_COLS: &str = "r.id, r.kind, r.tmdb_id, r.title, r.year, r.poster_url, r.seasons, \
+    r.status, r.requested_by, u.username, r.reviewed_by, r.note, r.created_at, r.updated_at, \
+    r.episodes, r.air_status, r.next_air_date, r.last_refresh_at";
+
+fn row_to_request(r: &Row) -> rusqlite::Result<MediaRequest> {
+    let kind: String = r.get(1)?;
+    let seasons_json: Option<String> = r.get(6)?;
+    let status: String = r.get(7)?;
+    let episodes_json: Option<String> = r.get(14)?;
+    Ok(MediaRequest {
+        id: r.get(0)?,
+        kind: RequestKind::parse(&kind).unwrap_or(RequestKind::Movie),
+        tmdb_id: r.get::<_, i64>(2)? as u64,
+        title: r.get(3)?,
+        year: r.get(4)?,
+        poster_url: r.get(5)?,
+        seasons: seasons_json.and_then(|j| serde_json::from_str(&j).ok()),
+        episodes: episodes_json.and_then(|j| serde_json::from_str(&j).ok()),
+        status: RequestStatus::parse(&status).unwrap_or(RequestStatus::Pending),
+        requested_by: r.get(8)?,
+        requested_by_name: r.get(9)?,
+        reviewed_by: r.get(10)?,
+        note: r.get(11)?,
+        created_at: r.get(12)?,
+        updated_at: r.get(13)?,
+        progress: None,
+        air_status: r.get(15)?,
+        next_air_date: r.get(16)?,
+        last_refresh_at: r.get(17)?,
+    })
+}
+
+pub struct NewRequest {
+    pub id: String,
+    pub kind: RequestKind,
+    pub tmdb_id: u64,
+    pub title: String,
+    pub year: Option<u32>,
+    pub poster_url: Option<String>,
+    pub seasons: Option<Vec<u32>>,
+    pub episodes: Option<Vec<EpisodeRef>>,
+    pub status: RequestStatus,
+    pub requested_by: Option<String>,
+}
+
+pub fn insert_request(pool: &Pool, req: &NewRequest, now_ms: i64) -> Result<()> {
+    let conn = pool.get()?;
+    let seasons = req
+        .seasons
+        .as_ref()
+        .map(|s| serde_json::to_string(s).unwrap_or_default());
+    let episodes = req
+        .episodes
+        .as_ref()
+        .map(|e| serde_json::to_string(e).unwrap_or_default());
+    conn.execute(
+        "INSERT INTO requests (id, kind, tmdb_id, title, year, poster_url, seasons, status, requested_by, episodes, created_at, updated_at) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?11)",
+        params![
+            req.id,
+            req.kind.as_str(),
+            req.tmdb_id as i64,
+            req.title,
+            req.year,
+            req.poster_url,
+            seasons,
+            req.status.as_str(),
+            req.requested_by,
+            episodes,
+            now_ms
+        ],
+    )?;
+    Ok(())
+}
+
+/// All requests newest-first, optionally scoped to one requester.
+pub fn list_requests(
+    conn: &Connection,
+    only_user: Option<&str>,
+) -> rusqlite::Result<Vec<MediaRequest>> {
+    let base =
+        format!("SELECT {REQUEST_COLS} FROM requests r LEFT JOIN users u ON u.id = r.requested_by");
+    match only_user {
+        Some(uid) => {
+            let mut stmt = conn.prepare(&format!(
+                "{base} WHERE r.requested_by = ?1 ORDER BY r.created_at DESC"
+            ))?;
+            let rows = stmt.query_map(params![uid], row_to_request)?;
+            rows.collect()
+        }
+        None => {
+            let mut stmt = conn.prepare(&format!("{base} ORDER BY r.created_at DESC"))?;
+            let rows = stmt.query_map([], row_to_request)?;
+            rows.collect()
+        }
+    }
+}
+
+pub fn get_request(conn: &Connection, id: &str) -> rusqlite::Result<Option<MediaRequest>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {REQUEST_COLS} FROM requests r LEFT JOIN users u ON u.id = r.requested_by WHERE r.id = ?1"
+    ))?;
+    let mut rows = stmt.query_map(params![id], row_to_request)?;
+    rows.next().transpose()
+}
+
+/// The open (mergeable) request for a title, if any. Denied/failed and
+/// fully-available requests are not merge targets.
+pub fn find_open_request(
+    conn: &Connection,
+    kind: RequestKind,
+    tmdb_id: u64,
+) -> rusqlite::Result<Option<MediaRequest>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {REQUEST_COLS} FROM requests r LEFT JOIN users u ON u.id = r.requested_by \
+         WHERE r.kind = ?1 AND r.tmdb_id = ?2 \
+           AND r.status IN ('pending', 'approved', 'partially_available') \
+         ORDER BY r.created_at DESC LIMIT 1"
+    ))?;
+    let mut rows = stmt.query_map(params![kind.as_str(), tmdb_id as i64], row_to_request)?;
+    rows.next().transpose()
+}
+
+pub fn latest_request_for(
+    conn: &Connection,
+    kind: RequestKind,
+    tmdb_id: u64,
+) -> rusqlite::Result<Option<(String, RequestStatus)>> {
+    conn.query_row(
+        "SELECT id, status FROM requests WHERE kind = ?1 AND tmdb_id = ?2 \
+         ORDER BY created_at DESC LIMIT 1",
+        params![kind.as_str(), tmdb_id as i64],
+        |r| {
+            let status: String = r.get(1)?;
+            Ok((
+                r.get(0)?,
+                RequestStatus::parse(&status).unwrap_or(RequestStatus::Pending),
+            ))
+        },
+    )
+    .optional()
+}
+
+pub fn set_request_status(
+    pool: &Pool,
+    id: &str,
+    status: RequestStatus,
+    reviewed_by: Option<&str>,
+    note: Option<&str>,
+    now_ms: i64,
+) -> Result<bool> {
+    let conn = pool.get()?;
+    let n = conn.execute(
+        "UPDATE requests SET status = ?2, \
+         reviewed_by = COALESCE(?3, reviewed_by), note = COALESCE(?4, note), updated_at = ?5 \
+         WHERE id = ?1",
+        params![id, status.as_str(), reviewed_by, note, now_ms],
+    )?;
+    Ok(n > 0)
+}
+
+/// `None` = the whole show.
+pub fn set_request_seasons(
+    pool: &Pool,
+    id: &str,
+    seasons: Option<&[u32]>,
+    now_ms: i64,
+) -> Result<()> {
+    let conn = pool.get()?;
+    let json = seasons.map(|s| serde_json::to_string(s).unwrap_or_default());
+    conn.execute(
+        "UPDATE requests SET seasons = ?2, updated_at = ?3 WHERE id = ?1",
+        params![id, json, now_ms],
+    )?;
+    Ok(())
+}
+
+/// `None` = no per-episode ask.
+pub fn set_request_episodes(
+    pool: &Pool,
+    id: &str,
+    episodes: Option<&[EpisodeRef]>,
+    now_ms: i64,
+) -> Result<()> {
+    let conn = pool.get()?;
+    let json = episodes.map(|e| serde_json::to_string(e).unwrap_or_default());
+    conn.execute(
+        "UPDATE requests SET episodes = ?2, updated_at = ?3 WHERE id = ?1",
+        params![id, json, now_ms],
+    )?;
+    Ok(())
+}
+
+/// Set outright, not COALESCE'd: an ended show clearing `next_air_date` back to
+/// NULL is a meaningful update. Leaves `updated_at` alone — a background sync is
+/// not a lifecycle change.
+pub fn set_request_air(
+    pool: &Pool,
+    id: &str,
+    air_status: Option<&str>,
+    next_air_date: Option<&str>,
+    refreshed_at: i64,
+) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "UPDATE requests SET air_status = ?2, next_air_date = ?3, last_refresh_at = ?4 WHERE id = ?1",
+        params![id, air_status, next_air_date, refreshed_at],
+    )?;
+    Ok(())
+}
+
+/// Cascades its wanted rows. False when absent.
+pub fn delete_request(pool: &Pool, id: &str) -> Result<bool> {
+    let conn = pool.get()?;
+    Ok(conn.execute("DELETE FROM requests WHERE id = ?1", params![id])? > 0)
+}