@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-db/src/playback/continue_watching.rs

@@ -0,0 +1,289 @@
+//! What a user can pick up again, newest first.
+
+use anyhow::Result;
+use rusqlite::params;
+
+use super::on_deck::on_deck;
+use crate::hydrate::items_by_ids_ordered;
+use crate::pool::Pool;
+use crate::rows::parse_metadata;
+use kroma_domain::{ContinueItem, Kind, MediaItem};
+
+const LIMIT: usize = 30;
+
+/// "Continue watching": resumable items (started, not yet ~finished), plus the
+/// episode a show is left on when none of it is mid-play (at position 0). Newest
+/// first, each carried as a full [`MediaItem`] so clients render normal cards.
+pub fn continue_watching(pool: &Pool, user_id: &str) -> Result<Vec<ContinueItem>> {
+    let conn = pool.get()?;
+    // The JOIN drops any orphan progress row whose item no longer exists.
+    let mut stmt = conn.prepare(&format!(
+        "SELECT p.item_id,p.position_ms,p.duration_ms,p.updated_at \
+         FROM progress p JOIN items i ON i.id = p.item_id \
+         WHERE p.user_id = ?1 AND {} \
+         ORDER BY p.updated_at DESC LIMIT ?2",
+        super::resumable_sql()
+    ))?;
+    let mut rows: Vec<(String, i64, Option<i64>, String)> = stmt
+        .query_map(params![user_id, LIMIT as i64], |r| {
+            Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?))
+        })?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    drop(stmt);
+
+    // A show whose last episode was finished holds no resume row, so it would fall
+    // off the list entirely: the episode it is left on joins at position 0, ordered
+    // among the rest by when that show was last watched.
+    rows.extend(
+        on_deck(&conn, user_id, LIMIT)?
+            .into_iter()
+            .map(|(id, at)| (id, 0, None, at)),
+    );
+    rows.sort_by(|a, b| b.3.cmp(&a.3));
+    rows.truncate(LIMIT);
+
+    let ids: Vec<&str> = rows.iter().map(|(id, _, _, _)| id.as_str()).collect();
+    let items = items_by_ids_ordered(&conn, &ids)?;
+    let mut by_id: std::collections::HashMap<String, MediaItem> =
+        items.into_iter().map(|i| (i.id.clone(), i)).collect();
+
+    // Episodes carry no poster of their own, so a Continue tile would fall back
+    // to a placeholder. Borrow the parent show's artwork (keeping any
+    // episode-specific still as the backdrop) one query for all shows.
+    let show_ids: Vec<String> = by_id
+        .values()
+        .filter(|i| i.kind == Kind::Episode)
+        .filter_map(|i| i.show_id.clone())
+        .collect::<std::collections::HashSet<_>>()
+        .into_iter()
+        .collect();
+    let mut show_meta_by_id: std::collections::HashMap<String, Option<String>> =
+        std::collections::HashMap::new();
+    for chunk in show_ids.chunks(super::IN_CHUNK) {
+        let ph = vec!["?"; chunk.len()].join(",");
+        let mut stmt = conn.prepare(&format!(
+            "SELECT id, metadata FROM shows WHERE id IN ({ph})"
+        ))?;
+        let metas = stmt.query_map(rusqlite::params_from_iter(chunk.iter()), |r| {
+            Ok((r.get::<_, String>(0)?, r.get::<_, Option<String>>(1)?))
+        })?;
+        for row in metas {
+            let (id, json) = row?;
+            show_meta_by_id.insert(id, json);
+        }
+    }
+
+    let mut out = Vec::with_capacity(rows.len());
+    for (item_id, position_ms, duration_ms, updated_at) in rows {
+        let Some(mut item) = by_id.remove(&item_id) else {
+            continue;
+        };
+        if item.kind == Kind::Episode {
+            let json = item
+                .show_id
+                .as_ref()
+                .and_then(|sid| show_meta_by_id.get(sid).cloned())
+                .flatten();
+            if let Some(mut show_meta) = parse_metadata(json) {
+                if let Some(still) = item.metadata.as_ref().and_then(|m| m.backdrop_url.clone()) {
+                    show_meta.backdrop_url = Some(still);
+                }
+                item.metadata = Some(show_meta);
+            }
+        }
+        out.push(ContinueItem {
+            item,
+            position_ms,
+            duration_ms,
+            updated_at,
+        });
+    }
+    Ok(out)
+}
+
+/// The ids "Continue watching" occupies, plus the parent show of any episode
+/// among them: what the home generator must not offer again in a row below it.
+pub fn continue_watching_ids(pool: &Pool, user_id: &str) -> Result<Vec<String>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(&format!(
+        "SELECT p.item_id FROM progress p JOIN items i ON i.id = p.item_id \
+         WHERE p.user_id = ?1 AND {} \
+         ORDER BY p.updated_at DESC LIMIT ?2",
+        super::resumable_sql()
+    ))?;
+    let mut ids: Vec<String> = stmt
+        .query_map(params![user_id, LIMIT as i64], |r| r.get::<_, String>(0))?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    drop(stmt);
+    ids.extend(
+        on_deck(&conn, user_id, LIMIT)?
+            .into_iter()
+            .map(|(id, _)| id),
+    );
+    let refs: Vec<&str> = ids.iter().map(String::as_str).collect();
+    let shows = crate::show_ids_for(pool, &refs)?;
+    ids.extend(shows);
+    Ok(ids)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::playback::test_support::*;
+
+    #[test]
+    fn continue_watching_filters_and_orders() {
+        let (pool, uid) = pool_with_user(); // m1 already an item
+        for id in ["low", "done", "nodur"] {
+            seed_movie(&pool, id);
+        }
+        {
+            let conn = pool.get().unwrap();
+            // (item, position, duration, updated_at)
+            let rows: [(&str, i64, Option<i64>, &str); 4] = [
+                // Resumable, older.
+                ("nodur", 30_000, None, "2021-01-01T00:00:00Z"),
+                // Resumable, newer -> should come first.
+                ("m1", 20_000, Some(100_000), "2021-01-02T00:00:00Z"),
+                // Below the 15s floor -> excluded.
+                ("low", 5_000, Some(100_000), "2021-01-03T00:00:00Z"),
+                // Past 95% -> counts as finished -> excluded.
+                ("done", 96_000, Some(100_000), "2021-01-04T00:00:00Z"),
+            ];
+            for (id, pos, dur, at) in rows {
+                conn.execute(
+                    "INSERT INTO progress (user_id,item_id,position_ms,duration_ms,updated_at) \
+                     VALUES (?1,?2,?3,?4,?5)",
+                    params![uid, id, pos, dur, at],
+                )
+                .unwrap();
+            }
+        }
+
+        let cw = continue_watching(&pool, &uid).unwrap();
+        let ids: Vec<&str> = cw.iter().map(|c| c.item.id.as_str()).collect();
+        // Only the two resumable rows, newest-first (m1 then nodur).
+        assert_eq!(ids, vec!["m1", "nodur"]);
+        assert_eq!(cw[0].position_ms, 20_000);
+        assert_eq!(cw[0].duration_ms, Some(100_000));
+        assert_eq!(cw[1].position_ms, 30_000);
+        assert_eq!(cw[1].duration_ms, None);
+    }
+
+    #[test]
+    fn the_ids_already_on_the_continue_rail_include_the_parent_show() {
+        let (pool, uid) = pool_with_user();
+        seed_show(&pool, "s1", "e", 3);
+        {
+            let conn = pool.get().unwrap();
+            conn.execute(
+                "INSERT INTO progress (user_id,item_id,position_ms,duration_ms,updated_at) \
+                 VALUES (?1,'e1',20000,100000,'2021-01-01T00:00:00Z')",
+                params![uid],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO progress (user_id,item_id,position_ms,duration_ms,updated_at) \
+                 VALUES (?1,'m1',5000,100000,'2021-01-02T00:00:00Z')",
+                params![uid],
+            )
+            .unwrap();
+        }
+
+        let mut ids = continue_watching_ids(&pool, &uid).unwrap();
+        ids.sort();
+
+        assert_eq!(ids, vec!["e1".to_string(), "s1".to_string()]);
+    }
+
+    #[test]
+    fn continue_watching_episode_borrows_show_artwork() {
+        let (pool, uid) = pool_with_user();
+        {
+            let conn = pool.get().unwrap();
+            conn.execute(
+                "INSERT INTO shows (id,library,title,metadata,added_at) VALUES ('s1','lib','Show',?1,'t')",
+                params![r#"{"tmdbId":10,"genres":[],"tmdbUrl":"http://tmdb/show","posterUrl":"show-poster.jpg","backdropUrl":"show-backdrop.jpg"}"#],
+            )
+            .unwrap();
+            // Episode carries only its own still as backdrop, no poster of its own.
+            conn.execute(
+                "INSERT INTO items (id,kind,title,container,library,show_id,season,episode,metadata,added_at) \
+                 VALUES ('e1','episode','Ep','mkv','lib','s1',1,1,?1,'t')",
+                params![r#"{"tmdbId":11,"genres":[],"tmdbUrl":"http://tmdb/ep","backdropUrl":"episode-still.jpg"}"#],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO progress (user_id,item_id,position_ms,duration_ms,updated_at) \
+                 VALUES (?1,'e1',20000,100000,'2021-01-01T00:00:00Z')",
+                params![uid],
+            )
+            .unwrap();
+        }
+
+        let cw = continue_watching(&pool, &uid).unwrap();
+        assert_eq!(cw.len(), 1);
+        let meta = cw[0]
+            .item
+            .metadata
+            .as_ref()
+            .expect("episode inherits show metadata");
+        // Poster comes from the show; backdrop keeps the episode-specific still.
+        assert_eq!(meta.poster_url.as_deref(), Some("show-poster.jpg"));
+        assert_eq!(meta.backdrop_url.as_deref(), Some("episode-still.jpg"));
+    }
+
+    #[test]
+    fn continue_watching_offers_the_next_episode_once_one_is_finished() {
+        let (pool, uid) = pool_with_user();
+        seed_show(&pool, "s1", "e", 3);
+
+        {
+            let conn = pool.get().unwrap();
+            conn.execute(
+                "INSERT INTO watched (user_id,item_id,watched_at) \
+                 VALUES (?1,'e1','2021-01-05T00:00:00Z')",
+                params![uid],
+            )
+            .unwrap();
+        }
+
+        let cw = continue_watching(&pool, &uid).unwrap();
+
+        let ids: Vec<&str> = cw.iter().map(|c| c.item.id.as_str()).collect();
+        assert_eq!(ids, vec!["e2"]);
+        assert_eq!(cw[0].position_ms, 0);
+        assert_eq!(cw[0].updated_at, "2021-01-05T00:00:00Z");
+    }
+
+    #[test]
+    fn continue_watching_skips_a_show_caught_up_or_already_mid_episode() {
+        let (pool, uid) = pool_with_user();
+        seed_show(&pool, "s1", "a", 2);
+        seed_show(&pool, "s2", "b", 2);
+
+        {
+            let conn = pool.get().unwrap();
+            for id in ["a1", "a2", "b1"] {
+                conn.execute(
+                    "INSERT INTO watched (user_id,item_id,watched_at) \
+                     VALUES (?1,?2,'2021-01-01T00:00:00Z')",
+                    params![uid, id],
+                )
+                .unwrap();
+            }
+            conn.execute(
+                "INSERT INTO progress (user_id,item_id,position_ms,duration_ms,updated_at) \
+                 VALUES (?1,'b2',20000,100000,'2021-01-02T00:00:00Z')",
+                params![uid],
+            )
+            .unwrap();
+        }
+
+        let cw = continue_watching(&pool, &uid).unwrap();
+
+        let ids: Vec<&str> = cw.iter().map(|c| c.item.id.as_str()).collect();
+        assert_eq!(ids, vec!["b2"]);
+        assert_eq!(cw[0].position_ms, 20_000);
+    }
+}

package/rust/kroma-db/src/playback/on_deck.rs

@@ -0,0 +1,53 @@
+//! The episode a show is left on, for shows with nothing mid-play.
+
+use anyhow::Result;
+use rusqlite::{params, Connection};
+
+// The episode after the last watched one, for every show the user has watched and
+// left with no episode in progress, newest show first: `(item_id, watched_at)`.
+// A show that is caught up yields no row (the JOIN finds nothing to play).
+fn sql() -> String {
+    let resumable = crate::playback::resumable_sql();
+    format!(
+        "\
+WITH busy AS ( \
+    SELECT DISTINCT pi.show_id AS show_id \
+      FROM progress p JOIN items pi ON pi.id = p.item_id \
+     WHERE p.user_id = ?1 AND pi.show_id IS NOT NULL AND {resumable} \
+), seen AS ( \
+    SELECT i.show_id AS show_id, \
+           MAX(w.watched_at) AS watched_at, \
+           MAX(COALESCE(i.season,0) * 1000000 + COALESCE(i.episode,0)) AS rank \
+      FROM watched w JOIN items i ON i.id = w.item_id \
+     WHERE w.user_id = ?1 AND i.kind = 'episode' AND i.show_id IS NOT NULL \
+       AND i.show_id NOT IN (SELECT show_id FROM busy) \
+     GROUP BY i.show_id \
+) \
+SELECT next.id, seen.watched_at \
+  FROM seen \
+  JOIN items next ON next.id = ( \
+       SELECT e.id FROM items e \
+        WHERE e.show_id = seen.show_id AND e.kind = 'episode' \
+          AND COALESCE(e.season,0) * 1000000 + COALESCE(e.episode,0) > seen.rank \
+          AND NOT EXISTS (SELECT 1 FROM watched w2 \
+                           WHERE w2.user_id = ?1 AND w2.item_id = e.id) \
+          AND NOT EXISTS (SELECT 1 FROM progress p2 \
+                           WHERE p2.user_id = ?1 AND p2.item_id = e.id) \
+        ORDER BY e.season, e.episode LIMIT 1) \
+ ORDER BY seen.watched_at DESC LIMIT ?2"
+    )
+}
+
+pub(super) fn on_deck(
+    conn: &Connection,
+    user_id: &str,
+    limit: usize,
+) -> Result<Vec<(String, String)>> {
+    let mut stmt = conn.prepare(&sql())?;
+    let rows = stmt
+        .query_map(params![user_id, limit as i64], |r| {
+            Ok((r.get(0)?, r.get(1)?))
+        })?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    Ok(rows)
+}

package/rust/kroma-db/src/playback/show_progress.rs

@@ -0,0 +1,230 @@
+//! How far through a show a user is, as a percent.
+
+use anyhow::Result;
+use rusqlite::params;
+
+use crate::pool::Pool;
+
+/// Per-user progress through each show, as a percent 0–100 (only shows with >0).
+/// `(watched episodes + the in-progress episode's fraction) / total episodes`
+/// a Plex-style series completion bar for show cards.
+pub fn show_progress(pool: &Pool, user_id: &str) -> Result<std::collections::HashMap<String, u8>> {
+    use std::collections::HashMap;
+    let conn = pool.get()?;
+
+    // Total episodes per show.
+    let mut totals: HashMap<String, i64> = HashMap::new();
+    {
+        let mut s = conn.prepare(
+            "SELECT show_id, COUNT(*) FROM items \
+             WHERE kind = 'episode' AND show_id IS NOT NULL GROUP BY show_id",
+        )?;
+        for row in s.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)))? {
+            let (show, n) = row?;
+            totals.insert(show, n);
+        }
+    }
+
+    // Watched episodes per show.
+    let mut watched: HashMap<String, i64> = HashMap::new();
+    {
+        let mut s = conn.prepare(
+            "SELECT i.show_id, COUNT(*) FROM watched w JOIN items i ON i.id = w.item_id \
+             WHERE w.user_id = ?1 AND i.kind = 'episode' AND i.show_id IS NOT NULL GROUP BY i.show_id",
+        )?;
+        for row in s.query_map(params![user_id], |r| {
+            Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?))
+        })? {
+            let (show, n) = row?;
+            watched.insert(show, n);
+        }
+    }
+
+    // Most-recent in-progress episode's fraction per show (watched + in-progress are
+    // disjoint: mark_watched deletes the progress row).
+    let mut frac: HashMap<String, f64> = HashMap::new();
+    {
+        let mut s = conn.prepare(
+            "SELECT i.show_id, p.position_ms, p.duration_ms FROM progress p JOIN items i ON i.id = p.item_id \
+             WHERE p.user_id = ?1 AND i.kind = 'episode' AND i.show_id IS NOT NULL AND p.position_ms > 15000 \
+               AND (p.duration_ms IS NULL OR p.position_ms < p.duration_ms * 95 / 100) \
+             ORDER BY p.updated_at DESC",
+        )?;
+        for row in s.query_map(params![user_id], |r| {
+            Ok((
+                r.get::<_, String>(0)?,
+                r.get::<_, i64>(1)?,
+                r.get::<_, Option<i64>>(2)?,
+            ))
+        })? {
+            let (show, pos, dur) = row?;
+            // ORDER BY updated_at DESC → keep the first (most recent) per show.
+            frac.entry(show).or_insert_with(|| match dur {
+                Some(d) if d > 0 => (pos as f64 / d as f64).clamp(0.0, 1.0),
+                _ => 0.0,
+            });
+        }
+    }
+
+    let mut out = HashMap::new();
+    for (show, total) in totals {
+        if total <= 0 {
+            continue;
+        }
+        let w = *watched.get(&show).unwrap_or(&0) as f64;
+        let f = *frac.get(&show).unwrap_or(&0.0);
+        let pct = ((w + f) / total as f64 * 100.0).round().clamp(0.0, 100.0) as u8;
+        if pct > 0 {
+            out.insert(show, pct);
+        }
+    }
+    Ok(out)
+}
+
+/// Series-completion percent (0–100) for a single show, or `None` if no progress
+/// (lighter than [`show_progress`] for a one-show detail page).
+pub fn show_progress_one(pool: &Pool, user_id: &str, show_id: &str) -> Result<Option<u8>> {
+    let conn = pool.get()?;
+    let total: i64 = conn.query_row(
+        "SELECT COUNT(*) FROM items WHERE kind = 'episode' AND show_id = ?1",
+        params![show_id],
+        |r| r.get(0),
+    )?;
+    if total <= 0 {
+        return Ok(None);
+    }
+    let watched: i64 = conn.query_row(
+        "SELECT COUNT(*) FROM watched w JOIN items i ON i.id = w.item_id \
+         WHERE w.user_id = ?1 AND i.kind = 'episode' AND i.show_id = ?2",
+        params![user_id, show_id],
+        |r| r.get(0),
+    )?;
+    let frac = {
+        let mut s = conn.prepare(
+            "SELECT p.position_ms, p.duration_ms FROM progress p JOIN items i ON i.id = p.item_id \
+             WHERE p.user_id = ?1 AND i.show_id = ?2 AND i.kind = 'episode' AND p.position_ms > 15000 \
+               AND (p.duration_ms IS NULL OR p.position_ms < p.duration_ms * 95 / 100) \
+             ORDER BY p.updated_at DESC LIMIT 1",
+        )?;
+        let row = s
+            .query_map(params![user_id, show_id], |r| {
+                Ok((r.get::<_, i64>(0)?, r.get::<_, Option<i64>>(1)?))
+            })?
+            .next()
+            .transpose()?;
+        match row {
+            Some((pos, Some(d))) if d > 0 => (pos as f64 / d as f64).clamp(0.0, 1.0),
+            _ => 0.0,
+        }
+    };
+    let pct = ((watched as f64 + frac) / total as f64 * 100.0)
+        .round()
+        .clamp(0.0, 100.0) as u8;
+    Ok(if pct > 0 { Some(pct) } else { None })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::playback::test_support::*;
+    use crate::playback::{continue_watching, mark_watched, upsert_progress};
+
+    #[test]
+    fn show_progress_and_one_compute_percent() {
+        let (pool, uid) = pool_with_user();
+        seed_show(&pool, "s1", "e", 4); // e1..e4
+        seed_show(&pool, "s2", "f", 2); // f1..f2 (untouched)
+        seed_show(&pool, "s3", "g", 2); // g1..g2 (fully watched)
+
+        // s1: two watched + one in-progress at 0.4 -> (2 + 0.4)/4 = 60%.
+        mark_watched(&pool, &uid, "e1").unwrap();
+        mark_watched(&pool, &uid, "e2").unwrap();
+        upsert_progress(&pool, &uid, "e3", 24_000, Some(60_000)).unwrap();
+
+        // s3: both episodes watched -> 100%.
+        mark_watched(&pool, &uid, "g1").unwrap();
+        mark_watched(&pool, &uid, "g2").unwrap();
+
+        let map = show_progress(&pool, &uid).unwrap();
+        assert_eq!(map.get("s1"), Some(&60));
+        assert_eq!(map.get("s3"), Some(&100));
+        // s2 has no progress -> excluded (0% rows are dropped).
+        assert_eq!(map.get("s2"), None);
+        // Movies are never series-progress rows.
+        assert_eq!(map.get("m1"), None);
+
+        // Single-show variant agrees, and is None for no-progress / unknown shows.
+        assert_eq!(show_progress_one(&pool, &uid, "s1").unwrap(), Some(60));
+        assert_eq!(show_progress_one(&pool, &uid, "s3").unwrap(), Some(100));
+        assert_eq!(show_progress_one(&pool, &uid, "s2").unwrap(), None);
+        assert_eq!(
+            show_progress_one(&pool, &uid, "no-such-show").unwrap(),
+            None
+        );
+    }
+
+    #[test]
+    fn an_episode_of_an_unenriched_show_keeps_its_own_metadata() {
+        let (pool, uid) = pool_with_user();
+        {
+            let conn = pool.get().unwrap();
+            conn.execute(
+                "INSERT INTO shows (id,library,title,added_at) VALUES ('s1','lib','Show','t')",
+                [],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO items (id,kind,title,container,library,show_id,season,episode,metadata,added_at) \
+                 VALUES ('e1','episode','Ep','mkv','lib','s1',1,1,?1,'t')",
+                params![r#"{"tmdbId":11,"genres":[],"tmdbUrl":"http://tmdb/ep","backdropUrl":"episode-still.jpg"}"#],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO progress (user_id,item_id,position_ms,duration_ms,updated_at) \
+                 VALUES (?1,'e1',20000,100000,'2021-01-01T00:00:00Z')",
+                params![uid],
+            )
+            .unwrap();
+        }
+
+        let cw = continue_watching(&pool, &uid).unwrap();
+        let meta = cw[0]
+            .item
+            .metadata
+            .as_ref()
+            .expect("the episode's own metadata is kept");
+        assert_eq!(meta.backdrop_url.as_deref(), Some("episode-still.jpg"));
+        assert!(
+            meta.poster_url.is_none(),
+            "there is no show artwork to borrow"
+        );
+    }
+
+    #[test]
+    fn an_in_progress_episode_of_unknown_length_counts_as_no_fraction() {
+        let (pool, uid) = pool_with_user();
+        seed_show(&pool, "s1", "e", 4);
+        mark_watched(&pool, &uid, "e1").unwrap();
+        upsert_progress(&pool, &uid, "e2", 30_000, None).unwrap();
+
+        assert_eq!(show_progress(&pool, &uid).unwrap().get("s1"), Some(&25));
+        assert_eq!(show_progress_one(&pool, &uid, "s1").unwrap(), Some(25));
+    }
+
+    #[test]
+    fn a_single_shows_progress_errors_rather_than_reading_as_untouched() {
+        let (pool, uid) = pool_with_user();
+        seed_show(&pool, "s1", "e", 3);
+        pool.get()
+            .unwrap()
+            .execute_batch("DROP TABLE watched")
+            .unwrap();
+        assert!(show_progress_one(&pool, &uid, "s1").is_err());
+
+        pool.get()
+            .unwrap()
+            .execute_batch("DROP TABLE items")
+            .unwrap();
+        assert!(show_progress_one(&pool, &uid, "s1").is_err());
+    }
+}

package/rust/kroma-db/src/playback/test_support.rs

@@ -0,0 +1,55 @@
+use rusqlite::params;
+
+use crate::pool::Pool;
+use crate::testing::TempPool;
+use kroma_domain::Permission;
+
+// Fresh DB with one user and one movie item `m1` (so `progress` which has an
+// items FK can be seeded).
+pub(super) fn pool_with_user() -> (TempPool, String) {
+    let pool = crate::testing::temp_pool("watched");
+    let user = crate::create_user(&pool, "w@e.com", "w", "hash", &[Permission::Playback]).unwrap();
+    let conn = pool.get().unwrap();
+    conn.execute(
+        "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movie','/x','t')",
+        [],
+    )
+    .unwrap();
+    conn.execute(
+        "INSERT INTO items (id,kind,title,container,library,added_at) \
+         VALUES ('m1','movie','Dune','mkv','lib','t')",
+        [],
+    )
+    .unwrap();
+    (pool, user.id)
+}
+
+// Insert a movie item so `progress`'s items FK is satisfied.
+pub(super) fn seed_movie(pool: &Pool, id: &str) {
+    pool.get()
+        .unwrap()
+        .execute(
+            "INSERT INTO items (id,kind,title,container,library,added_at) \
+             VALUES (?1,'movie','T','mkv','lib','t')",
+            params![id],
+        )
+        .unwrap();
+}
+
+// Show `sid` with `n` episodes `{prefix}1..{prefix}n`.
+pub(super) fn seed_show(pool: &Pool, sid: &str, prefix: &str, n: i64) {
+    let conn = pool.get().unwrap();
+    conn.execute(
+        "INSERT INTO shows (id,library,title,added_at) VALUES (?1,'lib','Show','t')",
+        params![sid],
+    )
+    .unwrap();
+    for e in 1..=n {
+        conn.execute(
+            "INSERT INTO items (id,kind,title,container,library,show_id,season,episode,added_at) \
+             VALUES (?1,'episode','Ep','mkv','lib',?2,1,?3,'t')",
+            params![format!("{prefix}{e}"), sid, e],
+        )
+        .unwrap();
+    }
+}