@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,97 @@
+//! SQLite persistence (rusqlite + r2d2 pool).
+//!
+//! The whole library lives in SQLite. A scan computes the full set of
+//! libraries/shows/items and atomically swaps it in via [`replace_all`]. Read
+//! queries run on `spawn_blocking` threads against a small connection pool.
+//!
+//! Performance: WAL journaling, `synchronous=NORMAL`, a 256 MiB mmap and a 16
+//! MiB page cache are set on every pooled connection; reads never block the
+//! single writer, and the indices below keep movie/show/episode lookups O(log n).
+//!
+//! This module is the directory root: the connection pool lives in [`pool`],
+//! the shared row-mappers in [`rows`], the item hydration in [`hydrate`] and
+//! the schema DDL plus `init`/`migrate` in [`schema`]. It re-exports those and
+//! the per-domain query submodules below as a flat namespace so
+//! `db::list_movies(...)` etc. resolve unchanged.
+
+use anyhow::Result;
+use rusqlite::{params, Connection, Row};
+
+use kroma_domain::{MediaItem, Metadata, Permission, User};
+
+mod accounts;
+mod admin;
+mod catalog_query;
+mod chunked;
+mod downloaded_subs;
+mod downloads;
+mod hydrate;
+mod ingest;
+mod jobs;
+mod library;
+mod markers;
+mod media;
+mod passkeys;
+mod playback;
+mod pool;
+mod rows;
+// Kept namespaced (`db::pipeline::…`) rather than glob-exported: its `counts`
+// would clash with `media::counts`, and the call sites read clearer scoped.
+pub mod audio_analysis;
+mod curated;
+pub mod notifications;
+pub mod pipeline;
+pub mod push_subs;
+mod reports;
+mod requests;
+mod suggest;
+mod taste;
+// Namespaced (`db::translations::…` / `db::metadata_core::…`) rather than
+// glob-exported: the generic language cache the whole app writes into, kept
+// scoped so `put`/`resolve_*`/`get_core` read clearly at the call sites.
+mod backup;
+mod core_tables;
+mod grant;
+mod home;
+pub mod localize;
+pub mod metadata_core;
+mod schema;
+#[cfg(any(test, feature = "testing"))]
+pub mod testing;
+pub mod tmdb_pin;
+pub mod translations;
+mod vectors;
+
+pub use accounts::*;
+pub use admin::*;
+pub use audio_analysis::*;
+pub use backup::*;
+pub use catalog_query::*;
+pub(crate) use chunked::*;
+pub use core_tables::is_core_table;
+pub use curated::*;
+pub use downloaded_subs::*;
+pub use downloads::*;
+pub use grant::{init_scoped, Grant};
+pub use home::*;
+pub(crate) use hydrate::*;
+pub use ingest::*;
+pub use jobs::*;
+pub use library::*;
+pub use markers::*;
+pub use media::*;
+pub use passkeys::*;
+pub use playback::*;
+pub use pool::{Pool, PoolInner, PooledConn};
+pub use reports::*;
+pub use requests::*;
+pub(crate) use rows::*;
+pub use schema::{apply_migrations, init, open};
+pub(crate) use schema::{FILE_COLS, ITEM_COLS, PRAGMAS};
+pub use suggest::*;
+pub use taste::*;
+pub use vectors::*;
+
+pub(crate) fn now_or_blank() -> String {
+    kroma_primitives::now_iso8601()
+}

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

@@ -0,0 +1,66 @@
+//! Library reads: the scanned library roots and their item counts.
+
+use super::*;
+
+use kroma_domain::{Library, LibraryKind};
+
+pub fn list_libraries(pool: &Pool) -> Result<Vec<Library>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(
+        "SELECT id,name,kind,path,(SELECT COUNT(*) FROM items i WHERE i.library=l.id) \
+         FROM libraries l ORDER BY name",
+    )?;
+    let rows = stmt.query_map([], |r| {
+        Ok(Library {
+            id: r.get(0)?,
+            name: r.get(1)?,
+            kind: parse_library_kind(&r.get::<_, String>(2)?),
+            path: r.get(3)?,
+            item_count: r.get::<_, i64>(4)? as usize,
+        })
+    })?;
+    Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
+}
+
+fn parse_library_kind(s: &str) -> LibraryKind {
+    match s {
+        "shows" => LibraryKind::Shows,
+        "mixed" => LibraryKind::Mixed,
+        _ => LibraryKind::Movies,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::TempPool;
+
+    fn pool() -> TempPool {
+        crate::testing::temp_pool("lib")
+    }
+
+    #[test]
+    fn list_libraries_counts_items_and_parses_kind() {
+        let p = pool();
+        {
+            let conn = p.get().unwrap();
+            conn.execute("INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('l2','Series','shows','/tv','t')", []).unwrap();
+            conn.execute("INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('l1','Films','movies','/mov','t')", []).unwrap();
+            for id in ["m1", "m2"] {
+                conn.execute(
+                    "INSERT INTO items (id,kind,title,container,library,added_at) VALUES (?1,'movie','T','mkv','l1','t')",
+                    params![id],
+                )
+                .unwrap();
+            }
+        }
+        let libs = list_libraries(&p).unwrap();
+        assert_eq!(libs.len(), 2);
+        assert_eq!(libs[0].id, "l1");
+        assert_eq!(libs[0].kind, LibraryKind::Movies);
+        assert_eq!(libs[0].item_count, 2);
+        assert_eq!(libs[1].id, "l2");
+        assert_eq!(libs[1].kind, LibraryKind::Shows);
+        assert_eq!(libs[1].item_count, 0);
+    }
+}

package/rust/kroma-db/src/localize/items.rs

@@ -0,0 +1,303 @@
+//! Overlaying a locale onto items and home-section rows.
+
+use super::{apply, apply_show};
+use crate::translations::TransData;
+use crate::{metadata_core, translations, Pool};
+use anyhow::Result;
+
+use kroma_domain::{Kind, MediaItem, SectionItem};
+
+fn apply_item(item: &mut MediaItem, tr: &TransData) {
+    apply(item.metadata.as_mut(), tr);
+    if let Some(t) = &tr.title {
+        item.title = t.clone();
+        // An episode row prints `episodeTitle ?? title`, so leaving the scan's
+        // name here keeps the filename's language on a card whose title has
+        // just been translated.
+        if item.episode_title.is_some() {
+            item.episode_title = Some(t.clone());
+        }
+    }
+}
+
+/// Overlay `locale` onto a batch of items (movies/videos + episodes). Episodes
+/// resolve under the `'episode'` subject kind, everything else under `'item'`.
+pub fn overlay_items(pool: &Pool, items: &mut [MediaItem], locale: &str) -> Result<()> {
+    overlay_each(pool, items.iter_mut(), locale)
+}
+
+/// Overlay `locale` onto items reached through something other than a slice: a
+/// resume row's inner item, the next episode, one `Option`.
+pub fn overlay_each<'a>(
+    pool: &Pool,
+    items: impl IntoIterator<Item = &'a mut MediaItem>,
+    locale: &str,
+) -> Result<()> {
+    let mut items: Vec<&mut MediaItem> = items.into_iter().collect();
+    if items.is_empty() {
+        return Ok(());
+    }
+    let conn = pool.get()?;
+    let movie_ids: Vec<&str> = items
+        .iter()
+        .filter(|i| i.kind != Kind::Episode)
+        .map(|i| i.id.as_str())
+        .collect();
+    let ep_ids: Vec<&str> = items
+        .iter()
+        .filter(|i| i.kind == Kind::Episode)
+        .map(|i| i.id.as_str())
+        .collect();
+    // The show's name is printed beside the episode's on every continue row and
+    // every up-next rail, so translating one without the other puts two
+    // languages on one card.
+    let show_ids: Vec<&str> = items.iter().filter_map(|i| i.show_id.as_deref()).collect();
+    let movie_tr = translations::resolve_many(&conn, metadata_core::ITEM, &movie_ids, locale)?;
+    let ep_tr = translations::resolve_many(&conn, "episode", &ep_ids, locale)?;
+    let show_tr = translations::resolve_many(&conn, metadata_core::SHOW, &show_ids, locale)?;
+    for item in items.iter_mut() {
+        let table = if item.kind == Kind::Episode {
+            &ep_tr
+        } else {
+            &movie_tr
+        };
+        if let Some(tr) = table.get(&item.id) {
+            apply_item(item, tr);
+        }
+        if let Some(name) = item
+            .show_id
+            .as_deref()
+            .and_then(|id| show_tr.get(id))
+            .and_then(|tr| tr.title.as_deref())
+        {
+            item.show_title = Some(name.to_string());
+        }
+    }
+    Ok(())
+}
+
+/// Overlay `locale` onto home-section items (a mix of movies and shows).
+pub fn overlay_section_items(pool: &Pool, items: &mut [SectionItem], locale: &str) -> Result<()> {
+    if items.is_empty() {
+        return Ok(());
+    }
+    let conn = pool.get()?;
+    let movie_ids: Vec<&str> = items
+        .iter()
+        .filter_map(|s| match s {
+            SectionItem::Movie { item } => Some(item.id.as_str()),
+            SectionItem::Show { .. } => None,
+        })
+        .collect();
+    let show_ids: Vec<&str> = items
+        .iter()
+        .filter_map(|s| match s {
+            SectionItem::Show { show } => Some(show.id.as_str()),
+            SectionItem::Movie { .. } => None,
+        })
+        .collect();
+    let m_tr = translations::resolve_many(&conn, metadata_core::ITEM, &movie_ids, locale)?;
+    let s_tr = translations::resolve_many(&conn, metadata_core::SHOW, &show_ids, locale)?;
+    for it in items.iter_mut() {
+        match it {
+            SectionItem::Movie { item } => {
+                if let Some(t) = m_tr.get(&item.id) {
+                    apply_item(item, t);
+                }
+            }
+            SectionItem::Show { show } => {
+                if let Some(t) = s_tr.get(&show.id) {
+                    apply_show(show, t);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::localize::test_support::*;
+    use crate::translations::TransData;
+
+    #[test]
+    fn the_items_own_title_is_localized_not_only_its_metadata() {
+        let p = pool();
+        translations::put(
+            &p,
+            metadata_core::ITEM,
+            "m1",
+            "en",
+            translations::TMDB,
+            &td("Minions: The Rise of Gru", vec![]),
+        )
+        .unwrap();
+
+        let mut items = vec![item("m1", Kind::Movie)];
+        overlay_items(&p, &mut items, "en").unwrap();
+
+        assert_eq!(items[0].title, "Minions: The Rise of Gru");
+    }
+
+    #[test]
+    fn an_episode_card_does_not_print_two_languages() {
+        let p = pool();
+        translations::put(
+            &p,
+            "episode",
+            "e1",
+            "en",
+            translations::TMDB,
+            &td("Ozymandias", vec![]),
+        )
+        .unwrap();
+        translations::put(
+            &p,
+            metadata_core::SHOW,
+            "sh1",
+            "en",
+            translations::TMDB,
+            &td("Breaking Bad", vec![]),
+        )
+        .unwrap();
+
+        let mut ep = item("e1", Kind::Episode);
+        ep.show_id = Some("sh1".into());
+        ep.show_title = Some("Breaking Bad VF".into());
+        ep.episode_title = Some("Ozymandias VF".into());
+        let mut items = vec![ep];
+        overlay_items(&p, &mut items, "en").unwrap();
+
+        // A row prints the show's name beside the episode's, and falls back to
+        // `episodeTitle` over `title`, so all three have to move together.
+        assert_eq!(items[0].title, "Ozymandias");
+        assert_eq!(items[0].episode_title.as_deref(), Some("Ozymandias"));
+        assert_eq!(items[0].show_title.as_deref(), Some("Breaking Bad"));
+    }
+
+    #[test]
+    fn the_home_rows_localize_the_title_the_card_renders() {
+        let p = pool();
+        translations::put(
+            &p,
+            metadata_core::ITEM,
+            "m1",
+            "en",
+            translations::TMDB,
+            &td("Arrival", vec![]),
+        )
+        .unwrap();
+
+        let mut rows = vec![SectionItem::Movie {
+            item: Box::new(item("m1", Kind::Movie)),
+        }];
+        overlay_section_items(&p, &mut rows, "en").unwrap();
+
+        let SectionItem::Movie { item } = &rows[0] else {
+            panic!("expected a movie row");
+        };
+        assert_eq!(item.title, "Arrival");
+    }
+
+    #[test]
+    fn an_item_reached_through_a_wrapper_is_localized_like_any_other() {
+        let p = pool();
+        translations::put(
+            &p,
+            metadata_core::ITEM,
+            "m1",
+            "en",
+            translations::TMDB,
+            &td("Arrival", vec![]),
+        )
+        .unwrap();
+
+        let mut resume = (item("m1", Kind::Movie), 1234);
+        overlay_each(&p, std::iter::once(&mut resume.0), "en").unwrap();
+
+        assert_eq!(resume.0.title, "Arrival");
+    }
+
+    #[test]
+    fn overlay_items_applies_title_and_characters() {
+        let p = pool();
+        translations::put(
+            &p,
+            metadata_core::ITEM,
+            "m1",
+            "fr",
+            translations::TMDB,
+            &td("Titre FR", vec![Some("Perso FR".into())]),
+        )
+        .unwrap();
+        translations::put(
+            &p,
+            "episode",
+            "e1",
+            "fr",
+            translations::TMDB,
+            &td("Episode FR", vec![]),
+        )
+        .unwrap();
+
+        let mut items = vec![item("m1", Kind::Movie), item("e1", Kind::Episode)];
+        overlay_items(&p, &mut items, "fr").unwrap();
+
+        let m = items[0].metadata.as_ref().unwrap();
+        assert_eq!(m.title.as_deref(), Some("Titre FR"));
+        assert_eq!(m.cast[0].character.as_deref(), Some("Perso FR"));
+        // Untranslated fields keep the blob's original text.
+        assert_eq!(m.tagline.as_deref(), Some("orig tagline"));
+        assert_eq!(m.genres, vec!["Original".to_string()]);
+        assert_eq!(
+            items[1].metadata.as_ref().unwrap().title.as_deref(),
+            Some("Episode FR")
+        );
+
+        // Empty slice is a clean no-op.
+        overlay_items(&p, &mut [], "fr").unwrap();
+    }
+
+    #[test]
+    fn a_locale_overlay_rewrites_the_genre_names_and_leaves_their_ids_alone() {
+        let p = pool();
+        let tr = TransData {
+            genres: vec!["Science-fiction".into()],
+            ..Default::default()
+        };
+        translations::put(&p, metadata_core::ITEM, "m1", "fr", translations::TMDB, &tr).unwrap();
+        let mut items = vec![item("m1", Kind::Movie)];
+
+        overlay_items(&p, &mut items, "fr").unwrap();
+
+        let m = items[0].metadata.as_ref().unwrap();
+        assert_eq!(m.genres, vec!["Science-fiction".to_string()]);
+        assert_eq!(m.tmdb_genre_ids, vec![878]);
+    }
+
+    #[test]
+    fn a_translation_overlays_every_text_field_it_carries() {
+        let p = pool();
+        let tr = TransData {
+            title: Some("Titre FR".into()),
+            tagline: Some("Accroche FR".into()),
+            overview: Some("Synopsis FR".into()),
+            genres: vec!["Science-fiction".into()],
+            characters: vec![Some("Perso FR".into())],
+            ..Default::default()
+        };
+        translations::put(&p, metadata_core::ITEM, "m1", "fr", translations::TMDB, &tr).unwrap();
+
+        let mut items = vec![item("m1", Kind::Movie)];
+        overlay_items(&p, &mut items, "fr").unwrap();
+        let m = items[0].metadata.as_ref().unwrap();
+        assert_eq!(m.title.as_deref(), Some("Titre FR"));
+        assert_eq!(m.tagline.as_deref(), Some("Accroche FR"));
+        assert_eq!(m.overview.as_deref(), Some("Synopsis FR"));
+        assert_eq!(m.genres, vec!["Science-fiction".to_string()]);
+        assert_eq!(m.cast[0].character.as_deref(), Some("Perso FR"));
+
+        overlay_section_items(&p, &mut [], "fr").unwrap();
+    }
+}

package/rust/kroma-db/src/localize/shows.rs

@@ -0,0 +1,192 @@
+//! Overlaying a locale onto a show, its seasons and its episodes.
+
+use super::{apply, apply_show, overlay_season_cast};
+use crate::{metadata_core, translations, Pool};
+use anyhow::Result;
+
+use kroma_domain::{Show, ShowDetail};
+
+/// Overlay `locale` onto a batch of shows (their top-level metadata only).
+pub fn overlay_shows(pool: &Pool, shows: &mut [Show], locale: &str) -> Result<()> {
+    if shows.is_empty() {
+        return Ok(());
+    }
+    let conn = pool.get()?;
+    let ids: Vec<&str> = shows.iter().map(|s| s.id.as_str()).collect();
+    let tr = translations::resolve_many(&conn, metadata_core::SHOW, &ids, locale)?;
+    for show in shows.iter_mut() {
+        if let Some(t) = tr.get(&show.id) {
+            apply_show(show, t);
+        }
+    }
+    Ok(())
+}
+
+/// Overlay `locale` onto a full show detail: the show, every episode of every
+/// season, and each season's cast character names (`season_cast` translations
+/// keyed `"{show_id}:{season}"`).
+pub fn overlay_show_detail(pool: &Pool, detail: &mut ShowDetail, locale: &str) -> Result<()> {
+    let conn = pool.get()?;
+    // Show + episodes reuse the batch helpers over this one detail.
+    if let Some(t) = translations::resolve_many(
+        &conn,
+        metadata_core::SHOW,
+        &[detail.show.id.as_str()],
+        locale,
+    )?
+    .get(&detail.show.id)
+    {
+        apply_show(&mut detail.show, t);
+    }
+    let ep_ids: Vec<&str> = detail
+        .seasons
+        .iter()
+        .flat_map(|s| s.episodes.iter())
+        .map(|e| e.id.as_str())
+        .collect();
+    let ep_tr = translations::resolve_many(&conn, "episode", &ep_ids, locale)?;
+    for season in &mut detail.seasons {
+        for ep in &mut season.episodes {
+            if let Some(t) = ep_tr.get(&ep.id) {
+                apply(ep.metadata.as_mut(), t);
+                if let Some(title) = &t.title {
+                    ep.title = title.clone();
+                }
+            }
+        }
+        overlay_season_cast(&conn, &detail.show.id, season, locale)?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::localize::overlay_section_items;
+    use crate::localize::test_support::*;
+    use crate::translations::TransData;
+
+    use kroma_domain::{CastMember, Kind, Season, SectionItem};
+
+    #[test]
+    fn overlay_shows_and_section_items() {
+        let p = pool();
+        translations::put(
+            &p,
+            metadata_core::SHOW,
+            "s1",
+            "fr",
+            translations::TMDB,
+            &td("Serie FR", vec![]),
+        )
+        .unwrap();
+        translations::put(
+            &p,
+            metadata_core::ITEM,
+            "m1",
+            "fr",
+            translations::TMDB,
+            &td("Film FR", vec![]),
+        )
+        .unwrap();
+
+        let mut shows = vec![show("s1")];
+        overlay_shows(&p, &mut shows, "fr").unwrap();
+        assert_eq!(
+            shows[0].metadata.as_ref().unwrap().title.as_deref(),
+            Some("Serie FR")
+        );
+
+        let mut section = vec![
+            SectionItem::Movie {
+                item: Box::new(item("m1", Kind::Movie)),
+            },
+            SectionItem::Show {
+                show: Box::new(show("s1")),
+            },
+        ];
+        overlay_section_items(&p, &mut section, "fr").unwrap();
+        match &section[0] {
+            SectionItem::Movie { item } => assert_eq!(
+                item.metadata.as_ref().unwrap().title.as_deref(),
+                Some("Film FR")
+            ),
+            _ => panic!("expected movie"),
+        }
+        match &section[1] {
+            SectionItem::Show { show } => assert_eq!(
+                show.metadata.as_ref().unwrap().title.as_deref(),
+                Some("Serie FR")
+            ),
+            _ => panic!("expected show"),
+        }
+    }
+
+    #[test]
+    fn overlay_show_detail_covers_show_episodes_and_season_cast() {
+        let p = pool();
+        translations::put(
+            &p,
+            metadata_core::SHOW,
+            "s1",
+            "fr",
+            translations::TMDB,
+            &td("Serie FR", vec![]),
+        )
+        .unwrap();
+        translations::put(
+            &p,
+            "episode",
+            "e1",
+            "fr",
+            translations::TMDB,
+            &td("Ep FR", vec![]),
+        )
+        .unwrap();
+        translations::put(
+            &p,
+            "season_cast",
+            "s1:1",
+            "fr",
+            translations::TMDB,
+            &TransData {
+                characters: vec![Some("Perso Saison".into())],
+                ..Default::default()
+            },
+        )
+        .unwrap();
+
+        let mut detail = ShowDetail {
+            show: show("s1"),
+            seasons: vec![Season {
+                number: 1,
+                episodes: vec![item("e1", Kind::Episode)],
+                cast: vec![CastMember {
+                    name: "A".into(),
+                    tmdb_id: None,
+                    character: Some("orig".into()),
+                    profile_url: None,
+                }],
+            }],
+        };
+        overlay_show_detail(&p, &mut detail, "fr").unwrap();
+
+        assert_eq!(
+            detail.show.metadata.as_ref().unwrap().title.as_deref(),
+            Some("Serie FR")
+        );
+        assert_eq!(
+            detail.seasons[0].episodes[0]
+                .metadata
+                .as_ref()
+                .unwrap()
+                .title
+                .as_deref(),
+            Some("Ep FR")
+        );
+        assert_eq!(
+            detail.seasons[0].cast[0].character.as_deref(),
+            Some("Perso Saison")
+        );
+    }
+}