@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-db/src/notifications/digest.rs

@@ -0,0 +1,143 @@
+//! Who a digest goes to, and what the library added since it last ran.
+
+use rusqlite::{params, Connection};
+
+use kroma_domain::User;
+
+/// Every account, for audience resolution: a household-sized table, scanned and
+/// filtered in Rust rather than queried with `LIKE` on the permissions JSON.
+/// Returns the full [`User`] since callers need both `permissions` (to filter)
+/// and `language` (to render).
+pub fn recipients(conn: &Connection) -> rusqlite::Result<Vec<User>> {
+    let mut stmt = conn.prepare(
+        "SELECT id,email,username,avatar_url,created_at,permissions,language,\
+         (pin_hash IS NOT NULL),audio_language,subtitle_language FROM users ORDER BY created_at",
+    )?;
+    let rows = stmt.query_map([], crate::row_to_user)?;
+    rows.collect()
+}
+
+/// The users who follow a show: it is in their list, they marked it watched, or
+/// they have playback progress on one of its episodes. Drives "a new episode of
+/// something you actually watch" without spamming the whole household.
+pub fn followers_of_show(conn: &Connection, show_id: &str) -> rusqlite::Result<Vec<String>> {
+    let mut stmt = conn.prepare(
+        "SELECT user_id FROM my_list WHERE item_id = ?1 \
+         UNION SELECT user_id FROM watched WHERE item_id = ?1 \
+         UNION SELECT p.user_id FROM progress p JOIN items i ON i.id = p.item_id \
+         WHERE i.show_id = ?1",
+    )?;
+    let rows = stmt.query_map(params![show_id], |r| r.get::<_, String>(0))?;
+    rows.collect()
+}
+
+/// A catalogue entry that appeared since a watermark, for the media digest.
+/// `poster_url` is the show's for an episode, the title's own otherwise: an
+/// episode's art is a still, which is not what an announcement should show.
+#[derive(Debug, Clone)]
+pub struct AddedTitle {
+    pub id: String,
+    pub kind: String,
+    pub title: String,
+    pub show_id: Option<String>,
+    pub show_title: Option<String>,
+    pub season: Option<u32>,
+    pub episode: Option<u32>,
+    pub added_at: String,
+    pub poster_url: Option<String>,
+}
+
+/// Everything added to the catalogue strictly after `since` (ISO-8601, compared
+/// lexicographically). `limit` bounds a first import or big re-scan from loading
+/// the whole catalogue, since the digest only reports a count and a sample title.
+pub fn items_added_since(
+    conn: &Connection,
+    since: &str,
+    limit: usize,
+) -> rusqlite::Result<Vec<AddedTitle>> {
+    let mut stmt = conn.prepare(
+        "SELECT i.id, i.kind, i.title, i.show_id, i.show_title, i.season, i.episode, i.added_at, \
+                COALESCE(mcs.poster_url, json_extract(sh.metadata,'$.posterUrl'), \
+                         mci.poster_url, json_extract(i.metadata,'$.posterUrl')) \
+           FROM items i \
+           LEFT JOIN shows sh ON sh.id = i.show_id \
+           LEFT JOIN metadata_core mcs \
+             ON mcs.subject_kind = 'show' AND mcs.subject_id = i.show_id \
+           LEFT JOIN metadata_core mci \
+             ON mci.subject_kind = 'item' AND mci.subject_id = i.id \
+          WHERE i.added_at > ?1 ORDER BY i.added_at DESC LIMIT ?2",
+    )?;
+    let rows = stmt.query_map(params![since, limit as i64], |r| {
+        Ok(AddedTitle {
+            id: r.get(0)?,
+            kind: r.get(1)?,
+            title: r.get(2)?,
+            show_id: r.get(3)?,
+            show_title: r.get(4)?,
+            season: r.get(5)?,
+            episode: r.get(6)?,
+            added_at: r.get(7)?,
+            poster_url: r.get(8)?,
+        })
+    })?;
+    rows.collect()
+}
+
+/// The newest `added_at` in the catalogue, for seeding the digest watermark on a
+/// first run so an initial import never notifies anyone about 4000 films.
+pub fn newest_added_at(conn: &Connection) -> rusqlite::Result<Option<String>> {
+    conn.query_row("SELECT MAX(added_at) FROM items", [], |r| r.get(0))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::notifications::test_support::*;
+
+    #[test]
+    fn an_addition_carries_the_poster_the_notification_will_show() {
+        let (p, _, _) = pool();
+        let conn = p.get().unwrap();
+        conn.execute_batch(
+            "INSERT INTO libraries (id,name,kind,path,added_at) \
+               VALUES ('lib','Films','movies','/x','2020-01-01T00:00:00Z'); \
+             INSERT INTO shows (id,library,title,metadata,added_at) \
+               VALUES ('shw','lib','Severance','{\"posterUrl\":\"/blob/shw.webp\"}','2020-01-01T00:00:00Z'); \
+             INSERT INTO items (id,kind,title,container,library,added_at) \
+               VALUES ('m1','movie','Dune','mkv','lib','2026-01-02T00:00:00Z'); \
+             INSERT INTO items (id,kind,title,container,library,metadata,added_at) \
+               VALUES ('m2','movie','Arrival','mkv','lib','{\"posterUrl\":\"/blob/m2.webp\"}','2026-01-03T00:00:00Z'); \
+             INSERT INTO items (id,kind,title,container,library,show_id,season,episode,added_at) \
+               VALUES ('e1','episode','Ep 4','mkv','lib','shw',1,4,'2026-01-04T00:00:00Z'); \
+             INSERT INTO metadata_core (subject_kind,subject_id,poster_url,updated_at) \
+               VALUES ('item','m1','/core/m1.webp',0);",
+        )
+        .unwrap();
+
+        let added = items_added_since(&conn, "2026-01-01", 10).unwrap();
+        let poster = |id: &str| {
+            added
+                .iter()
+                .find(|a| a.id == id)
+                .unwrap()
+                .poster_url
+                .clone()
+        };
+        assert_eq!(poster("m1").as_deref(), Some("/core/m1.webp"));
+        // Not yet re-enriched into `metadata_core`: the stored blob still answers.
+        assert_eq!(poster("m2").as_deref(), Some("/blob/m2.webp"));
+        // An episode has a still of its own, never a poster: the show's answers.
+        assert_eq!(poster("e1").as_deref(), Some("/blob/shw.webp"));
+    }
+
+    #[test]
+    fn the_digest_queries_report_a_missing_table_rather_than_an_empty_library() {
+        let (p, _, _) = pool();
+        let conn = p.get().unwrap();
+        conn.execute_batch("DROP TABLE my_list; DROP TABLE items")
+            .unwrap();
+
+        assert!(followers_of_show(&conn, "s1").is_err());
+        assert!(items_added_since(&conn, "2020-01-01", 10).is_err());
+    }
+}

package/rust/kroma-db/src/notifications/preferences.rs

@@ -0,0 +1,138 @@
+//! The per-user delivery matrix: which categories reach which channel.
+
+use std::collections::BTreeMap;
+
+use crate::Pool;
+use anyhow::Result;
+use rusqlite::{params, Connection};
+
+use kroma_domain::{CategoryPref, NotificationCategory};
+
+/// One user's full preference matrix, defaults filled in.
+///
+/// A missing row means "on", so this always returns every category and callers
+/// never have to know which ones were explicitly set.
+pub fn prefs(conn: &Connection, user_id: &str) -> rusqlite::Result<Vec<CategoryPref>> {
+    let mut stmt =
+        conn.prepare("SELECT category, in_app, push FROM notification_prefs WHERE user_id = ?1")?;
+    let rows = stmt.query_map(params![user_id], |r| {
+        let category: String = r.get(0)?;
+        let in_app: i64 = r.get(1)?;
+        let push: i64 = r.get(2)?;
+        Ok((category, (in_app != 0, push != 0)))
+    })?;
+    let set: BTreeMap<String, (bool, bool)> = rows.collect::<rusqlite::Result<_>>()?;
+    Ok(NotificationCategory::ALL
+        .into_iter()
+        .map(|category| {
+            let (in_app, push) = set.get(category.as_str()).copied().unwrap_or((true, true));
+            CategoryPref {
+                category,
+                in_app,
+                push,
+            }
+        })
+        .collect())
+}
+
+/// Whether a category may be delivered to this user, as `(in_app, push)`.
+/// Defined in terms of [`prefs`] so the "missing row means on" rule has one home.
+pub fn allows(
+    conn: &Connection,
+    user_id: &str,
+    category: NotificationCategory,
+) -> rusqlite::Result<(bool, bool)> {
+    Ok(prefs(conn, user_id)?
+        .into_iter()
+        .find(|p| p.category == category)
+        .map_or((true, true), |p| (p.in_app, p.push)))
+}
+
+/// Replace a user's preference matrix.
+pub fn set_prefs(pool: &Pool, user_id: &str, prefs: &[CategoryPref]) -> Result<()> {
+    let mut conn = pool.get()?;
+    let tx = conn.transaction()?;
+    for p in prefs {
+        tx.execute(
+            "INSERT INTO notification_prefs (user_id, category, in_app, push) \
+             VALUES (?1, ?2, ?3, ?4) \
+             ON CONFLICT(user_id, category) DO UPDATE SET in_app = ?3, push = ?4",
+            params![user_id, p.category.as_str(), p.in_app as i64, p.push as i64],
+        )?;
+    }
+    tx.commit()?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::notifications::test_support::*;
+
+    #[test]
+    fn prefs_default_to_on_for_every_category() {
+        let (p, u1, _) = pool();
+        let conn = p.get().unwrap();
+        let prefs = prefs(&conn, &u1).unwrap();
+        assert_eq!(prefs.len(), NotificationCategory::ALL.len());
+        assert!(prefs.iter().all(|p| p.in_app && p.push));
+        assert_eq!(
+            allows(&conn, &u1, NotificationCategory::Media).unwrap(),
+            (true, true)
+        );
+    }
+
+    #[test]
+    fn setting_prefs_persists_and_is_read_back_per_category() {
+        let (p, u1, u2) = pool();
+        set_prefs(
+            &p,
+            &u1,
+            &[CategoryPref {
+                category: NotificationCategory::Media,
+                in_app: true,
+                push: false,
+            }],
+        )
+        .unwrap();
+        let conn = p.get().unwrap();
+        assert_eq!(
+            allows(&conn, &u1, NotificationCategory::Media).unwrap(),
+            (true, false)
+        );
+        assert_eq!(
+            allows(&conn, &u1, NotificationCategory::Requests).unwrap(),
+            (true, true)
+        );
+        assert_eq!(
+            allows(&conn, &u2, NotificationCategory::Media).unwrap(),
+            (true, true)
+        );
+    }
+
+    #[test]
+    fn setting_prefs_twice_updates_in_place() {
+        let (p, u1, _) = pool();
+        let off = CategoryPref {
+            category: NotificationCategory::System,
+            in_app: false,
+            push: false,
+        };
+        set_prefs(&p, &u1, &[off]).unwrap();
+        set_prefs(
+            &p,
+            &u1,
+            &[CategoryPref {
+                category: NotificationCategory::System,
+                in_app: true,
+                push: false,
+            }],
+        )
+        .unwrap();
+        let conn = p.get().unwrap();
+        assert_eq!(
+            allows(&conn, &u1, NotificationCategory::System).unwrap(),
+            (true, false)
+        );
+    }
+}

package/rust/kroma-db/src/notifications/read_state.rs

@@ -0,0 +1,167 @@
+//! Moving a row between read and unread, and deleting it.
+
+use crate::{Pool, IN_CHUNK};
+use anyhow::Result;
+use rusqlite::params;
+
+/// Mark some (or, with `None`, all) of a user's notifications read. Scoped to
+/// `user_id` so an id guessed from another account is a no-op, not a leak.
+/// Returns how many rows changed.
+pub fn mark_read(pool: &Pool, user_id: &str, ids: Option<&[String]>, now_ms: i64) -> Result<usize> {
+    set_read_at(pool, user_id, ids, Some(now_ms))
+}
+
+/// Put rows back in the unread pile, so a reader who marked one read by mistake
+/// can undo it without waiting for the event to happen again. Scoped like
+/// [`mark_read`]. There is no `None` case on purpose: "mark everything unread"
+/// is not an affordance anyone wants.
+pub fn mark_unread(pool: &Pool, user_id: &str, ids: &[String]) -> Result<usize> {
+    set_read_at(pool, user_id, Some(ids), None)
+}
+
+fn set_read_at(
+    pool: &Pool,
+    user_id: &str,
+    ids: Option<&[String]>,
+    read_at: Option<i64>,
+) -> Result<usize> {
+    let mut conn = pool.get()?;
+    // Only rows on the far side of the transition, so the count is what moved.
+    let side = if read_at.is_some() {
+        "read_at IS NULL"
+    } else {
+        "read_at IS NOT NULL"
+    };
+    let Some(ids) = ids else {
+        return Ok(conn.execute(
+            &format!("UPDATE notifications SET read_at = ?2 WHERE user_id = ?1 AND {side}"),
+            params![user_id, read_at],
+        )?);
+    };
+    if ids.is_empty() {
+        return Ok(0);
+    }
+
+    // One transaction over the chunks: a caller that marks a list read sees all
+    // of it move or none of it, whatever the list's length.
+    let tx = conn.transaction()?;
+    let mut changed = 0;
+    for chunk in ids.chunks(IN_CHUNK) {
+        let placeholders = vec!["?"; chunk.len()].join(",");
+        let sql = format!(
+            "UPDATE notifications SET read_at = ? WHERE user_id = ? AND {side} \
+             AND id IN ({placeholders})"
+        );
+        let mut args: Vec<&dyn rusqlite::ToSql> = Vec::with_capacity(chunk.len() + 2);
+        args.push(&read_at);
+        args.push(&user_id);
+        for id in chunk {
+            args.push(id);
+        }
+        changed += tx.execute(&sql, args.as_slice())?;
+    }
+    tx.commit()?;
+    Ok(changed)
+}
+
+/// Delete one of the caller's own notifications.
+pub fn delete_notification(pool: &Pool, user_id: &str, id: &str) -> Result<bool> {
+    let conn = pool.get()?;
+    let n = conn.execute(
+        "DELETE FROM notifications WHERE user_id = ?1 AND id = ?2",
+        params![user_id, id],
+    )?;
+    Ok(n > 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::notifications::test_support::*;
+    use crate::notifications::{list_notifications, unread_count};
+
+    #[test]
+    fn mark_read_all_then_only_unread_listing_is_empty() {
+        let (p, u1, _) = pool();
+        insert(&p, "n1", &u1, 1_000);
+        insert(&p, "n2", &u1, 2_000);
+        assert_eq!(mark_read(&p, &u1, None, 9_000).unwrap(), 2);
+        let conn = p.get().unwrap();
+        assert_eq!(unread_count(&conn, &u1).unwrap(), 0);
+        assert!(list_notifications(&conn, &u1, 50, true).unwrap().is_empty());
+        drop(conn);
+        assert_eq!(mark_read(&p, &u1, None, 9_001).unwrap(), 0);
+    }
+
+    #[test]
+    fn mark_read_by_id_cannot_touch_another_users_rows() {
+        let (p, u1, u2) = pool();
+        insert(&p, "mine", &u1, 1_000);
+        insert(&p, "theirs", &u2, 1_000);
+        let ids = vec!["theirs".to_string()];
+        assert_eq!(mark_read(&p, &u1, Some(&ids), 9_000).unwrap(), 0);
+        let conn = p.get().unwrap();
+        assert_eq!(unread_count(&conn, &u2).unwrap(), 1);
+        drop(conn);
+        let ids = vec!["mine".to_string()];
+        assert_eq!(mark_read(&p, &u1, Some(&ids), 9_000).unwrap(), 1);
+    }
+
+    #[test]
+    fn a_read_list_longer_than_sqlite_can_bind_still_marks_the_rows() {
+        const SQLITE_BIND_LIMIT: usize = 32_766;
+        let (p, u1, _) = pool();
+        insert(&p, "n1", &u1, 1_000);
+        let mut ids: Vec<String> = (0..=SQLITE_BIND_LIMIT)
+            .map(|n| format!("absent{n}"))
+            .collect();
+        ids.push("n1".to_string());
+
+        assert_eq!(mark_read(&p, &u1, Some(&ids), 9_000).unwrap(), 1);
+
+        let conn = p.get().unwrap();
+        assert_eq!(unread_count(&conn, &u1).unwrap(), 0);
+    }
+
+    #[test]
+    fn mark_unread_puts_a_row_back_and_counts_only_what_moved() {
+        let (p, u1, _) = pool();
+        insert(&p, "n1", &u1, 1_000);
+        insert(&p, "n2", &u1, 2_000);
+        assert_eq!(mark_read(&p, &u1, None, 9_000).unwrap(), 2);
+
+        let ids = vec!["n1".to_string()];
+        assert_eq!(mark_unread(&p, &u1, &ids).unwrap(), 1);
+        let conn = p.get().unwrap();
+        assert_eq!(unread_count(&conn, &u1).unwrap(), 1);
+        assert_eq!(list_notifications(&conn, &u1, 50, true).unwrap().len(), 1);
+        drop(conn);
+        // Already unread: nothing moves, and nothing is double-counted.
+        assert_eq!(mark_unread(&p, &u1, &ids).unwrap(), 0);
+        assert_eq!(mark_unread(&p, &u1, &[]).unwrap(), 0);
+    }
+
+    #[test]
+    fn mark_unread_cannot_touch_another_users_rows() {
+        let (p, u1, u2) = pool();
+        insert(&p, "theirs", &u2, 1_000);
+        assert_eq!(mark_read(&p, &u2, None, 9_000).unwrap(), 1);
+
+        let ids = vec!["theirs".to_string()];
+        assert_eq!(mark_unread(&p, &u1, &ids).unwrap(), 0);
+        let conn = p.get().unwrap();
+        assert_eq!(unread_count(&conn, &u2).unwrap(), 0);
+    }
+
+    #[test]
+    fn delete_is_scoped_to_the_owner() {
+        let (p, u1, u2) = pool();
+        insert(&p, "n1", &u1, 1_000);
+        assert!(!delete_notification(&p, &u2, "n1").unwrap());
+        assert!(delete_notification(&p, &u1, "n1").unwrap());
+        let conn = p.get().unwrap();
+        assert!(list_notifications(&conn, &u1, 50, false)
+            .unwrap()
+            .is_empty());
+    }
+}

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

@@ -0,0 +1,50 @@
+use std::collections::BTreeMap;
+
+use super::{insert_notification, StoredNotification};
+use crate::testing::TempPool;
+use crate::Pool;
+
+use kroma_domain::{
+    ActionKind, ActionSpec, ActionStyle, NotificationEvent, ParamValue, PushCategory,
+};
+
+// Real accounts: notifications.user_id FKs users (and cascades).
+pub(super) fn pool() -> (TempPool, String, String) {
+    let p = crate::testing::temp_pool("notif");
+    let u1 = crate::create_user(&p, "ana@test.dev", "Ana", "h", &[])
+        .unwrap()
+        .id;
+    let u2 = crate::create_user(&p, "bo@test.dev", "Bo", "h", &[])
+        .unwrap()
+        .id;
+    (p, u1, u2)
+}
+
+pub(super) fn new(id: &str, created_at: i64) -> StoredNotification {
+    StoredNotification {
+        id: id.into(),
+        category: NotificationEvent::RequestApproved.category(),
+        event: NotificationEvent::RequestApproved,
+        title_key: "notifications.request.approved.title".into(),
+        body_key: "notifications.request.approved.body".into(),
+        params: BTreeMap::from([("title".to_string(), ParamValue::Text("Dune".into()))]),
+        link: Some("/movie/ab12".into()),
+        image_url: Some("https://img/p.jpg".into()),
+        actions: vec![ActionSpec {
+            id: "view".into(),
+            label_key: "notifications.action.view".into(),
+            kind: ActionKind::Link,
+            href: "/movie/ab12".into(),
+            method: None,
+            style: ActionStyle::Primary,
+        }],
+        push_category: Some(PushCategory::MediaAvailable),
+        read: false,
+        created_at,
+    }
+}
+
+pub(super) fn insert(p: &Pool, id: &str, user: &str, at: i64) -> u32 {
+    let conn = p.get().unwrap();
+    insert_notification(&conn, user, &new(id, at)).unwrap()
+}