@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,253 @@
+//! EBU R128 loudness analysis per (file, audio track): the data behind the
+//! "high dynamics / quiet dialogue" badge and the player's volume-boost
+//! suggestion. One row per analyzed track; written by the `pipeline.loudness`
+//! stage. Raw measured values are kept so remediation can reuse them.
+
+use super::*;
+use kroma_domain::{AudioAnalysis, AudioVerdict};
+
+fn verdict_str(v: AudioVerdict) -> &'static str {
+    match v {
+        AudioVerdict::Ok => "ok",
+        AudioVerdict::HighDynamics => "highDynamics",
+        AudioVerdict::QuietDialog => "quietDialog",
+    }
+}
+
+fn verdict_from_str(s: &str) -> Option<AudioVerdict> {
+    match s {
+        "ok" => Some(AudioVerdict::Ok),
+        "highDynamics" => Some(AudioVerdict::HighDynamics),
+        "quietDialog" => Some(AudioVerdict::QuietDialog),
+        _ => None,
+    }
+}
+
+fn row_to_analysis(r: &Row) -> rusqlite::Result<(String, Option<AudioAnalysis>)> {
+    let file_id: String = r.get(0)?;
+    let verdict: String = r.get(5)?;
+    // An unknown verdict (from a future version) drops the row instead of
+    // breaking older servers reading a newer DB.
+    let analysis = verdict_from_str(&verdict).map(|v| AudioAnalysis {
+        lufs_i: r.get(1).unwrap_or(0.0),
+        lra: r.get(2).unwrap_or(0.0),
+        true_peak: r.get(3).unwrap_or(0.0),
+        dialog_lufs: r.get(4).ok().flatten(),
+        verdict: v,
+    });
+    Ok((file_id, analysis))
+}
+
+/// Upsert the analysis of one audio track of one file.
+pub fn set_audio_analysis(
+    pool: &Pool,
+    file_id: &str,
+    track_index: u32,
+    analysis: &AudioAnalysis,
+) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "INSERT INTO audio_analysis \
+            (file_id, track_index, lufs_i, lra, true_peak, dialog_lufs, verdict, updated_at) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, datetime('now')) \
+         ON CONFLICT(file_id, track_index) DO UPDATE SET \
+           lufs_i = excluded.lufs_i, lra = excluded.lra, true_peak = excluded.true_peak, \
+           dialog_lufs = excluded.dialog_lufs, verdict = excluded.verdict, \
+           updated_at = excluded.updated_at",
+        params![
+            file_id,
+            track_index,
+            analysis.lufs_i,
+            analysis.lra,
+            analysis.true_peak,
+            analysis.dialog_lufs,
+            verdict_str(analysis.verdict),
+        ],
+    )?;
+    Ok(())
+}
+
+/// The analysis of one file's analyzed track (only the default track is
+/// analyzed today; lowest track index wins should several exist).
+pub fn audio_analysis_for_file(
+    conn: &Connection,
+    file_id: &str,
+) -> rusqlite::Result<Option<AudioAnalysis>> {
+    let mut stmt = conn.prepare(
+        "SELECT file_id, lufs_i, lra, true_peak, dialog_lufs, verdict \
+         FROM audio_analysis WHERE file_id = ?1 ORDER BY track_index LIMIT 1",
+    )?;
+    let mut rows = stmt.query_map(params![file_id], row_to_analysis)?;
+    match rows.next() {
+        Some(r) => Ok(r?.1),
+        None => Ok(None),
+    }
+}
+
+/// [`audio_analysis_for_file`] over many files in one query per id-chunk,
+/// keyed by file id (absent ids simply have no analysis yet).
+pub(crate) fn audio_analysis_for_files(
+    conn: &Connection,
+    file_ids: &[&str],
+) -> rusqlite::Result<std::collections::HashMap<String, AudioAnalysis>> {
+    let mut out = std::collections::HashMap::new();
+    for chunk in file_ids.chunks(super::IN_CHUNK) {
+        let ph = vec!["?"; chunk.len()].join(",");
+        let mut stmt = conn.prepare(&format!(
+            "SELECT file_id, lufs_i, lra, true_peak, dialog_lufs, verdict \
+             FROM audio_analysis WHERE file_id IN ({ph}) ORDER BY track_index",
+        ))?;
+        let rows = stmt.query_map(rusqlite::params_from_iter(chunk.iter()), row_to_analysis)?;
+        for row in rows {
+            let (file_id, analysis) = row?;
+            if let Some(a) = analysis {
+                // Rows arrive track-index-ascending; keep the first per file.
+                out.entry(file_id).or_insert(a);
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// `(id, "mtime:size")` of every **probed** file, for the `pipeline.loudness`
+/// stage's enumeration: unprobed files stay out of scope (their track layout is
+/// unknown) and flow in once the probe stage lands.
+pub fn analyzable_file_sigs(pool: &Pool) -> Result<Vec<(String, String)>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(
+        "SELECT id, COALESCE(mtime,0) || ':' || COALESCE(size,0) FROM files WHERE probed = 1",
+    )?;
+    let rows = stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))?;
+    Ok(rows.collect::<rusqlite::Result<_>>()?)
+}
+
+/// `(abs_path, audio_tracks_json)` for one file the loudness stage's
+/// per-subject lookup. `None` if the file row is gone.
+pub fn loudness_target(pool: &Pool, file_id: &str) -> Result<Option<(String, String)>> {
+    let conn = pool.get()?;
+    let mut stmt =
+        conn.prepare("SELECT abs_path, audio_tracks FROM files WHERE id = ?1 AND probed = 1")?;
+    let mut rows = stmt.query_map(params![file_id], |r| {
+        Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
+    })?;
+    match rows.next() {
+        Some(r) => Ok(Some(r?)),
+        None => Ok(None),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::TempPool;
+
+    fn pool_with_file() -> TempPool {
+        let pool = crate::testing::temp_pool("loud");
+        let conn = pool.get().unwrap();
+        conn.execute("INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movies','/x','t')", []).unwrap();
+        conn.execute(
+            "INSERT INTO items (id,kind,title,container,library,added_at) VALUES ('m1','movie','T','mkv','lib','t')",
+            [],
+        )
+        .unwrap();
+        conn.execute(
+            "INSERT INTO files (id,item_id,abs_path,container,probed,mtime,size,audio_tracks) \
+             VALUES ('f1','m1','/media/m1.mkv','mkv',1,100,2000,'[{\"index\":0,\"codec\":\"eac3\"}]')",
+            [],
+        )
+        .unwrap();
+        drop(conn);
+        pool
+    }
+
+    fn analysis(verdict: AudioVerdict) -> AudioAnalysis {
+        AudioAnalysis {
+            lufs_i: -18.0,
+            lra: 12.5,
+            true_peak: -1.2,
+            dialog_lufs: Some(-24.0),
+            verdict,
+        }
+    }
+
+    #[test]
+    fn set_get_and_upsert_analysis() {
+        let p = pool_with_file();
+        set_audio_analysis(&p, "f1", 0, &analysis(AudioVerdict::HighDynamics)).unwrap();
+        let conn = p.get().unwrap();
+        let got = audio_analysis_for_file(&conn, "f1").unwrap().unwrap();
+        assert_eq!(got.lufs_i, -18.0);
+        assert_eq!(got.lra, 12.5);
+        assert_eq!(got.dialog_lufs, Some(-24.0));
+        assert_eq!(got.verdict, AudioVerdict::HighDynamics);
+        assert!(audio_analysis_for_file(&conn, "ghost").unwrap().is_none());
+        drop(conn);
+
+        // Upsert the same (file, track) replaces the verdict.
+        set_audio_analysis(&p, "f1", 0, &analysis(AudioVerdict::Ok)).unwrap();
+        let conn = p.get().unwrap();
+        assert_eq!(
+            audio_analysis_for_file(&conn, "f1")
+                .unwrap()
+                .unwrap()
+                .verdict,
+            AudioVerdict::Ok
+        );
+    }
+
+    #[test]
+    fn lowest_track_wins_and_batch_lookup() {
+        let p = pool_with_file();
+        set_audio_analysis(&p, "f1", 1, &analysis(AudioVerdict::QuietDialog)).unwrap();
+        set_audio_analysis(&p, "f1", 0, &analysis(AudioVerdict::Ok)).unwrap();
+        let conn = p.get().unwrap();
+        // The default (lowest index) track's analysis is the representative one.
+        assert_eq!(
+            audio_analysis_for_file(&conn, "f1")
+                .unwrap()
+                .unwrap()
+                .verdict,
+            AudioVerdict::Ok
+        );
+        let batch = audio_analysis_for_files(&conn, &["f1", "ghost"]).unwrap();
+        assert_eq!(batch.len(), 1);
+        assert_eq!(batch["f1"].verdict, AudioVerdict::Ok);
+    }
+
+    #[test]
+    fn enumeration_and_target_lookups() {
+        let p = pool_with_file();
+        let sigs: std::collections::HashMap<String, String> =
+            analyzable_file_sigs(&p).unwrap().into_iter().collect();
+        assert_eq!(sigs.get("f1").map(String::as_str), Some("100:2000"));
+
+        let (abs, tracks) = loudness_target(&p, "f1").unwrap().unwrap();
+        assert_eq!(abs, "/media/m1.mkv");
+        assert!(tracks.contains("eac3"));
+        assert!(loudness_target(&p, "ghost").unwrap().is_none());
+    }
+
+    #[test]
+    fn a_verdict_written_by_a_newer_server_reads_as_no_analysis() {
+        let p = pool_with_file();
+        set_audio_analysis(&p, "f1", 0, &analysis(AudioVerdict::QuietDialog)).unwrap();
+        let conn = p.get().unwrap();
+        conn.execute(
+            "UPDATE audio_analysis SET verdict='clipping' WHERE file_id='f1'",
+            [],
+        )
+        .unwrap();
+
+        assert!(audio_analysis_for_file(&conn, "f1").unwrap().is_none());
+        assert!(audio_analysis_for_files(&conn, &["f1"]).unwrap().is_empty());
+    }
+
+    #[test]
+    fn a_missing_analysis_table_errors_rather_than_reading_as_never_measured() {
+        let p = pool_with_file();
+        let conn = p.get().unwrap();
+        conn.execute_batch("DROP TABLE audio_analysis").unwrap();
+
+        assert!(audio_analysis_for_file(&conn, "f1").is_err());
+    }
+}

package/rust/kroma-db/src/backup/module_stores.rs

@@ -0,0 +1,204 @@
+//! A module's own database, dumped whole and put back where it came from.
+
+use std::collections::BTreeMap;
+
+use anyhow::{Context, Result};
+use rusqlite::Connection;
+use serde_json::{Map, Value};
+
+use super::rows::{dump_query, is_ident, restore_rows};
+use super::{table_exists, BackupDoc};
+
+/// Every installed module's own database, as `(module id, path)`. Empty when
+/// nothing is installed, which is the zero-module base build.
+pub(super) fn module_stores(data_dir: &std::path::Path) -> Vec<(String, std::path::PathBuf)> {
+    let Ok(entries) = std::fs::read_dir(data_dir.join("modules")) else {
+        return Vec::new();
+    };
+    let mut out: Vec<(String, std::path::PathBuf)> = entries
+        .filter_map(Result::ok)
+        .filter_map(|e| {
+            let store = e.path().join("module.sqlite");
+            let id = e.file_name().to_string_lossy().into_owned();
+            store.is_file().then_some((id, store))
+        })
+        .collect();
+    out.sort();
+    out
+}
+
+// Every user table in one module's database, whatever they are: the core does
+// not know a module's schema and has no business learning it.
+pub(super) fn dump_store(
+    path: &std::path::Path,
+) -> Result<BTreeMap<String, Vec<Map<String, Value>>>> {
+    let conn = Connection::open(path)?;
+    let names: Vec<String> = conn
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")?
+        .query_map([], |r| r.get(0))?
+        .collect::<std::result::Result<_, _>>()?;
+    let mut out = BTreeMap::new();
+    for name in names {
+        out.insert(
+            name.clone(),
+            dump_query(&conn, &format!("SELECT * FROM \"{name}\""))?,
+        );
+    }
+    Ok(out)
+}
+
+// A module's rows go back into that module's own database, and only into tables
+// it has already created. A module absent from this server (or one that has
+// never started, so its schema does not exist yet) is skipped: its rows stay in
+// the document and land the next time the same backup is restored somewhere the
+// module IS installed.
+pub(super) fn restore_modules(
+    data_dir: &std::path::Path,
+    doc: &BackupDoc,
+    reset: bool,
+) -> Vec<(String, usize)> {
+    let mut summary = Vec::new();
+    for (id, tables) in &doc.modules {
+        // The document is an uploaded file, so its module ids are untrusted and
+        // land in a path: anything but a reverse-DNS id could walk out of the
+        // data directory.
+        if !is_module_id(id) {
+            tracing::warn!(module = %id, "not a module id; its rows are not restored");
+            continue;
+        }
+        let path = data_dir.join("modules").join(id).join("module.sqlite");
+        if !path.is_file() {
+            tracing::info!(module = %id, "not installed here; its rows are not restored");
+            continue;
+        }
+        match restore_store(&path, tables, reset) {
+            Ok(counts) => summary.extend(counts.into_iter().map(|(t, n)| (format!("{id}/{t}"), n))),
+            Err(error) => tracing::warn!(module = %id, %error, "module rows not restored"),
+        }
+    }
+    summary
+}
+
+fn restore_store(
+    path: &std::path::Path,
+    tables: &BTreeMap<String, Vec<Map<String, Value>>>,
+    reset: bool,
+) -> Result<Vec<(String, usize)>> {
+    let mut conn = Connection::open(path)?;
+    let tx = conn.transaction()?;
+    let mut summary = Vec::new();
+    for (name, rows) in tables {
+        if !is_ident(name) || !table_exists(&tx, name)? {
+            continue;
+        }
+        if reset {
+            tx.execute(&format!("DELETE FROM \"{name}\""), [])?;
+        }
+        let n = restore_rows(&tx, name, rows).with_context(|| format!("restoring {name}"))?;
+        summary.push((name.clone(), n));
+    }
+    tx.commit()?;
+    Ok(summary)
+}
+
+// A reverse-DNS module id (`tv.kroma.torrents`), which is also the name of its
+// directory: no separator, no `..`, nothing a path could follow out of the data
+// directory.
+fn is_module_id(s: &str) -> bool {
+    !s.is_empty()
+        && s.len() <= 128
+        && !s.starts_with('.')
+        && s.split('.').all(|label| {
+            !label.is_empty()
+                && label
+                    .bytes()
+                    .all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'-')
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::backup::test_support::*;
+    use crate::backup::{export_portable, import_portable};
+
+    #[test]
+    fn a_modules_own_database_travels_with_the_backup() {
+        // The indexer API keys and download-client passwords moved out of the
+        // core database, and losing them in a restore would be the whole point
+        // of a backup gone.
+        let src = fresh_pool("mod-src");
+        let src_dir = data_dir(&src);
+        seed_indexer_store(
+            &src_dir,
+            "INSERT INTO indexers VALUES ('ix1','Jackett','secret',1);",
+        );
+
+        let doc = export_portable(&src, &src_dir).unwrap();
+        let dumped = &doc.modules["tv.kroma.indexer"]["indexers"];
+        assert_eq!(dumped.len(), 1);
+        assert_eq!(dumped[0]["api_key"], Value::from("secret"));
+
+        // The target has the module installed and started, so its schema exists.
+        let dst = fresh_pool("mod-dst");
+        let dst_dir = data_dir(&dst);
+        let dst_store = seed_indexer_store(&dst_dir, "");
+
+        let summary = import_portable(&dst, &dst_dir, &doc, false).unwrap();
+        assert!(
+            summary.contains(&("tv.kroma.indexer/indexers".to_string(), 1)),
+            "{summary:?}"
+        );
+        assert_eq!(store_count(&dst_store, "indexers"), 1);
+        let key: String = Connection::open(&dst_store)
+            .unwrap()
+            .query_row("SELECT api_key FROM indexers WHERE id='ix1'", [], |r| {
+                r.get(0)
+            })
+            .unwrap();
+        assert_eq!(key, "secret");
+    }
+
+    #[test]
+    fn rows_for_a_module_this_server_does_not_have_are_left_in_the_document() {
+        // Restoring onto a server where the module is not installed must not
+        // fail the restore, and must not invent a database for it either.
+        let dst = fresh_pool("mod-absent");
+        let dir = data_dir(&dst);
+        let mut doc = empty_doc();
+        doc.modules.insert(
+            "tv.kroma.indexer".into(),
+            BTreeMap::from([(
+                "indexers".to_string(),
+                vec![Map::from_iter([("id".to_string(), Value::from("ix1"))])],
+            )]),
+        );
+
+        assert!(import_portable(&dst, &dir, &doc, false).unwrap().is_empty());
+        assert!(!dir.join("modules/tv.kroma.indexer/module.sqlite").exists());
+    }
+
+    #[test]
+    fn a_module_id_that_is_a_path_never_becomes_one() {
+        let dst = fresh_pool("mod-traversal");
+        let dir = data_dir(&dst);
+        let outside = dir.join("outside");
+        let store = seed_indexer_store(&outside, "");
+        let mut doc = empty_doc();
+        doc.modules.insert(
+            "../outside/modules/tv.kroma.indexer".into(),
+            BTreeMap::from([(
+                "indexers".to_string(),
+                vec![Map::from_iter([
+                    ("id".to_string(), Value::from("ix1")),
+                    ("name".to_string(), Value::from("J")),
+                    ("api_key".to_string(), Value::from("k")),
+                    ("created_at".to_string(), Value::from(1)),
+                ])],
+            )]),
+        );
+
+        assert!(import_portable(&dst, &dir, &doc, false).unwrap().is_empty());
+        assert_eq!(store_count(&store, "indexers"), 0);
+    }
+}

package/rust/kroma-db/src/backup/rows.rs

@@ -0,0 +1,155 @@
+//! One table row, as JSON and back.
+
+use anyhow::Result;
+use rusqlite::Connection;
+use serde_json::{Map, Value};
+
+use super::{SqlValue, ValueRef};
+
+// Run `sql` and map every row to a `{column: value}` JSON object.
+pub(super) fn dump_query(conn: &Connection, sql: &str) -> Result<Vec<Map<String, Value>>> {
+    let mut stmt = conn.prepare(sql)?;
+    let cols: Vec<String> = stmt.column_names().into_iter().map(String::from).collect();
+    let mut rows = stmt.query([])?;
+    let mut out = Vec::new();
+    while let Some(row) = rows.next()? {
+        let mut obj = Map::new();
+        for (i, col) in cols.iter().enumerate() {
+            obj.insert(col.clone(), sql_to_json(row.get_ref(i)?));
+        }
+        out.push(obj);
+    }
+    Ok(out)
+}
+
+// `INSERT OR REPLACE` each row into `table` (replace-by-primary-key). Column
+// names are validated as plain identifiers before interpolation.
+pub(super) fn restore_rows(
+    conn: &Connection,
+    table: &str,
+    rows: &[Map<String, Value>],
+) -> Result<usize> {
+    let mut written = 0;
+    for row in rows {
+        let cols: Vec<&String> = row.keys().filter(|c| is_ident(c)).collect();
+        if cols.is_empty() {
+            continue;
+        }
+        let col_list = cols
+            .iter()
+            .map(|c| format!("\"{c}\""))
+            .collect::<Vec<_>>()
+            .join(",");
+        let placeholders = (1..=cols.len())
+            .map(|i| format!("?{i}"))
+            .collect::<Vec<_>>()
+            .join(",");
+        let sql =
+            format!("INSERT OR REPLACE INTO \"{table}\" ({col_list}) VALUES ({placeholders})");
+        let values: Vec<SqlValue> = cols.iter().map(|c| json_to_sql(&row[*c])).collect();
+        conn.execute(&sql, rusqlite::params_from_iter(values.iter()))?;
+        written += 1;
+    }
+    Ok(written)
+}
+
+// SQLite value → JSON. Blobs become a byte array (none of the exported tables
+// have blob columns today, but keep it lossless).
+pub(super) fn sql_to_json(v: ValueRef<'_>) -> Value {
+    match v {
+        ValueRef::Null => Value::Null,
+        ValueRef::Integer(i) => Value::from(i),
+        ValueRef::Real(f) => Value::from(f),
+        ValueRef::Text(t) => Value::from(String::from_utf8_lossy(t).into_owned()),
+        ValueRef::Blob(b) => Value::from(b.to_vec()),
+    }
+}
+
+// JSON → SQLite value, inverse of [`sql_to_json`]. Stored-JSON text columns
+// (`settings.value`, `permissions`, …) round-trip as `Text`.
+pub(super) fn json_to_sql(v: &Value) -> SqlValue {
+    match v {
+        Value::Null => SqlValue::Null,
+        Value::Bool(b) => SqlValue::Integer(*b as i64),
+        Value::Number(n) => n
+            .as_i64()
+            .map(SqlValue::Integer)
+            .unwrap_or_else(|| SqlValue::Real(n.as_f64().unwrap_or(0.0))),
+        Value::String(s) => SqlValue::Text(s.clone()),
+        Value::Array(a) => SqlValue::Blob(
+            a.iter()
+                .filter_map(|x| x.as_u64().map(|n| n as u8))
+                .collect(),
+        ),
+        Value::Object(_) => SqlValue::Text(v.to_string()),
+    }
+}
+
+// A safe SQL identifier (`[A-Za-z0-9_]+`) guards interpolated column names.
+pub(super) fn is_ident(s: &str) -> bool {
+    !s.is_empty() && s.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::backup::import_portable;
+    use crate::backup::test_support::*;
+
+    #[test]
+    fn a_row_whose_columns_are_all_unsafe_identifiers_is_skipped() {
+        let dst = fresh_pool("idents");
+        let mut doc = empty_doc();
+        doc.tables.insert(
+            "users".into(),
+            vec![Map::from_iter([(
+                "id); DROP TABLE users --".to_string(),
+                Value::from("u1"),
+            )])],
+        );
+        assert_eq!(
+            import_portable(&dst, &data_dir(&dst), &doc, false).unwrap(),
+            vec![("users".to_string(), 0)]
+        );
+        assert_eq!(count(&dst, "users"), 0);
+    }
+
+    #[test]
+    fn every_json_value_kind_maps_onto_a_sqlite_value() {
+        assert_eq!(json_to_sql(&Value::Null), SqlValue::Null);
+        assert_eq!(json_to_sql(&Value::Bool(true)), SqlValue::Integer(1));
+        assert_eq!(json_to_sql(&Value::Bool(false)), SqlValue::Integer(0));
+        assert_eq!(json_to_sql(&serde_json::json!(42)), SqlValue::Integer(42));
+        assert_eq!(json_to_sql(&serde_json::json!(1.5)), SqlValue::Real(1.5));
+        assert_eq!(
+            json_to_sql(&serde_json::json!("hi")),
+            SqlValue::Text("hi".into())
+        );
+        assert_eq!(
+            json_to_sql(&serde_json::json!([1, 2, 255])),
+            SqlValue::Blob(vec![1, 2, 255])
+        );
+        assert_eq!(
+            json_to_sql(&serde_json::json!({ "a": 1 })),
+            SqlValue::Text(r#"{"a":1}"#.into())
+        );
+    }
+
+    #[test]
+    fn every_sqlite_value_kind_survives_the_dump_as_json() {
+        let pool = crate::testing::temp_pool("bkp-values");
+        let conn = pool.get().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE v (i INTEGER, r REAL, t TEXT, b BLOB, n TEXT);\
+             INSERT INTO v VALUES (7, 1.5, 'text', x'00ff', NULL);",
+        )
+        .unwrap();
+
+        let rows = dump_query(&conn, "SELECT * FROM v").unwrap();
+        assert_eq!(rows[0]["i"], Value::from(7));
+        assert_eq!(rows[0]["r"], Value::from(1.5));
+        assert_eq!(rows[0]["t"], Value::from("text"));
+        assert_eq!(rows[0]["b"], serde_json::json!([0, 255]));
+        assert_eq!(rows[0]["n"], Value::Null);
+    }
+}

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

@@ -0,0 +1,61 @@
+use std::collections::BTreeMap;
+
+use rusqlite::Connection;
+
+use super::{BackupDoc, VERSION};
+use crate::testing::TempPool;
+use crate::Pool;
+
+pub(super) fn fresh_pool(tag: &str) -> TempPool {
+    crate::testing::temp_pool(&format!("bkp-{tag}"))
+}
+
+// The data directory the pool's database sits in, which is also where a
+// module's own store lives.
+pub(super) fn data_dir(pool: &Pool) -> std::path::PathBuf {
+    pool.path()
+        .parent()
+        .expect("the database has a directory")
+        .to_path_buf()
+}
+
+// Stand up one module's own database the way a running module would: the
+// indexer's table, holding an API key nobody wants to lose in a restore.
+pub(super) fn seed_indexer_store(dir: &std::path::Path, rows: &str) -> std::path::PathBuf {
+    let store = dir
+        .join("modules")
+        .join("tv.kroma.indexer")
+        .join("module.sqlite");
+    std::fs::create_dir_all(store.parent().unwrap()).unwrap();
+    let conn = Connection::open(&store).unwrap();
+    conn.execute_batch(&format!(
+        "CREATE TABLE IF NOT EXISTS indexers (id TEXT PRIMARY KEY, name TEXT NOT NULL, \
+         api_key TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL);{rows}"
+    ))
+    .unwrap();
+    store
+}
+
+pub(super) fn store_count(store: &std::path::Path, table: &str) -> i64 {
+    Connection::open(store)
+        .unwrap()
+        .query_row(&format!("SELECT count(*) FROM {table}"), [], |r| r.get(0))
+        .unwrap()
+}
+
+pub(super) fn count(pool: &Pool, table: &str) -> i64 {
+    pool.get()
+        .unwrap()
+        .query_row(&format!("SELECT COUNT(*) FROM {table}"), [], |r| r.get(0))
+        .unwrap()
+}
+
+pub(super) fn empty_doc() -> BackupDoc {
+    BackupDoc {
+        version: VERSION,
+        exported_at: "t".into(),
+        tables: BTreeMap::new(),
+        assets: BTreeMap::new(),
+        modules: BTreeMap::new(),
+    }
+}