@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,323 @@
+//! Push endpoint persistence: one row per device a user has opted in on.
+//!
+//! A subscription is identified by `(transport, endpoint)`, not by user: a
+//! browser re-subscribing hands back the same endpoint, and the same laptop may
+//! be signed into a different account than last time. Upsert therefore moves an
+//! endpoint to its current owner rather than duplicating it.
+//!
+//! Dead endpoints are pruned rather than retried forever a push service
+//! rate-limits a sender that keeps posting to a 410.
+
+use rusqlite::OptionalExtension;
+
+use super::*;
+use kroma_domain::PushTransport;
+
+/// Consecutive failures after which an endpoint is dropped. Transient outages
+/// (a service blip, a laptop offline) recover well inside this; a genuinely
+/// dead endpoint reaches it and stops costing us requests.
+pub const MAX_FAILURES: i64 = 8;
+
+const SUB_COLS: &str = "id, user_id, transport, endpoint, p256dh, auth, device";
+
+/// One device's push endpoint.
+#[derive(Debug, Clone)]
+pub struct PushSubscription {
+    pub id: String,
+    pub user_id: String,
+    pub transport: PushTransport,
+    pub endpoint: String,
+    // Web Push only: the subscriber's public key and auth secret (base64url).
+    pub p256dh: Option<String>,
+    pub auth: Option<String>,
+    pub device: Option<String>,
+}
+
+fn row_to_sub(r: &Row) -> rusqlite::Result<PushSubscription> {
+    let transport: String = r.get(2)?;
+    Ok(PushSubscription {
+        id: r.get(0)?,
+        user_id: r.get(1)?,
+        // A row written by a newer build could name a transport this binary does
+        // not know; treat it as Web Push rather than dropping the device from
+        // the user's own "your devices" list.
+        transport: PushTransport::parse(&transport).unwrap_or(PushTransport::WebPush),
+        endpoint: r.get(3)?,
+        p256dh: r.get(4)?,
+        auth: r.get(5)?,
+        device: r.get(6)?,
+    })
+}
+
+/// A subscription to store.
+pub struct NewSubscription {
+    pub id: String,
+    pub user_id: String,
+    pub transport: PushTransport,
+    pub endpoint: String,
+    pub p256dh: Option<String>,
+    pub auth: Option<String>,
+    pub device: Option<String>,
+}
+
+/// Register (or re-register) an endpoint.
+///
+/// Conflicts on `(transport, endpoint)` reassign it to the calling user and
+/// reset the failure count: the browser just proved the endpoint is alive.
+pub fn upsert_subscription(pool: &Pool, sub: &NewSubscription, now_ms: i64) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "INSERT INTO push_subscriptions \
+         (id, user_id, transport, endpoint, p256dh, auth, device, failures, created_at, last_ok_at) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, 0, ?8, NULL) \
+         ON CONFLICT(transport, endpoint) DO UPDATE SET \
+           user_id = ?2, p256dh = ?5, auth = ?6, device = ?7, failures = 0",
+        params![
+            sub.id,
+            sub.user_id,
+            sub.transport.as_str(),
+            sub.endpoint,
+            sub.p256dh,
+            sub.auth,
+            sub.device,
+            now_ms
+        ],
+    )?;
+    Ok(())
+}
+
+/// Every endpoint a user has opted in on.
+pub fn subscriptions_for_user(
+    conn: &Connection,
+    user_id: &str,
+) -> rusqlite::Result<Vec<PushSubscription>> {
+    let sql = format!("SELECT {SUB_COLS} FROM push_subscriptions WHERE user_id = ?1");
+    let mut stmt = conn.prepare(&sql)?;
+    let rows = stmt.query_map(params![user_id], row_to_sub)?;
+    rows.collect()
+}
+
+/// Whether this user has any push endpoint at all (drives the settings toggle).
+pub fn has_subscription(conn: &Connection, user_id: &str) -> rusqlite::Result<bool> {
+    let n: i64 = conn.query_row(
+        "SELECT COUNT(*) FROM push_subscriptions WHERE user_id = ?1",
+        params![user_id],
+        |r| r.get(0),
+    )?;
+    Ok(n > 0)
+}
+
+/// Look one up by its endpoint (the browser knows only that).
+pub fn find_by_endpoint(
+    conn: &Connection,
+    endpoint: &str,
+) -> rusqlite::Result<Option<PushSubscription>> {
+    let sql = format!("SELECT {SUB_COLS} FROM push_subscriptions WHERE endpoint = ?1");
+    conn.query_row(&sql, params![endpoint], row_to_sub)
+        .optional()
+}
+
+/// Unsubscribe one endpoint, scoped to its owner so a known endpoint string
+/// can't be used to silence someone else's device.
+pub fn delete_subscription(pool: &Pool, user_id: &str, endpoint: &str) -> Result<bool> {
+    let conn = pool.get()?;
+    let n = conn.execute(
+        "DELETE FROM push_subscriptions WHERE user_id = ?1 AND endpoint = ?2",
+        params![user_id, endpoint],
+    )?;
+    Ok(n > 0)
+}
+
+/// Drop an endpoint outright the push service said it is gone.
+pub fn drop_subscription(pool: &Pool, id: &str) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute("DELETE FROM push_subscriptions WHERE id = ?1", params![id])?;
+    Ok(())
+}
+
+/// A delivery succeeded: clear the failure streak.
+pub fn record_success(pool: &Pool, id: &str, now_ms: i64) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "UPDATE push_subscriptions SET failures = 0, last_ok_at = ?2 WHERE id = ?1",
+        params![id, now_ms],
+    )?;
+    Ok(())
+}
+
+/// A delivery failed. Returns true once the endpoint has failed
+/// [`MAX_FAILURES`] times in a row and should be dropped.
+pub fn record_failure(pool: &Pool, id: &str) -> Result<bool> {
+    let conn = pool.get()?;
+    conn.execute(
+        "UPDATE push_subscriptions SET failures = failures + 1 WHERE id = ?1",
+        params![id],
+    )?;
+    let failures: i64 = conn
+        .query_row(
+            "SELECT failures FROM push_subscriptions WHERE id = ?1",
+            params![id],
+            |r| r.get(0),
+        )
+        .optional()?
+        .unwrap_or(0);
+    Ok(failures >= MAX_FAILURES)
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use crate::testing::TempPool;
+
+    fn pool() -> (TempPool, String, String) {
+        let p = crate::testing::temp_pool("push");
+        let a = crate::create_user(&p, "a@test.dev", "A", "h", &[])
+            .unwrap()
+            .id;
+        let b = crate::create_user(&p, "b@test.dev", "B", "h", &[])
+            .unwrap()
+            .id;
+        (p, a, b)
+    }
+
+    fn sub(id: &str, user: &str, endpoint: &str) -> NewSubscription {
+        NewSubscription {
+            id: id.into(),
+            user_id: user.into(),
+            transport: PushTransport::WebPush,
+            endpoint: endpoint.into(),
+            p256dh: Some("BCVxsr7N".into()),
+            auth: Some("BTBZMqHH".into()),
+            device: Some("Firefox on Mac".into()),
+        }
+    }
+
+    #[test]
+    fn upsert_stores_and_reads_back_the_keys() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        let conn = p.get().unwrap();
+        let list = subscriptions_for_user(&conn, &a).unwrap();
+        assert_eq!(list.len(), 1);
+        assert_eq!(list[0].endpoint, "https://push.example/1");
+        assert_eq!(list[0].p256dh.as_deref(), Some("BCVxsr7N"));
+        assert_eq!(list[0].transport, PushTransport::WebPush);
+        assert!(has_subscription(&conn, &a).unwrap());
+    }
+
+    #[test]
+    fn re_subscribing_the_same_endpoint_updates_rather_than_duplicates() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        let mut again = sub("s2", &a, "https://push.example/1");
+        again.p256dh = Some("ROTATED".into());
+        upsert_subscription(&p, &again, 2_000).unwrap();
+
+        let conn = p.get().unwrap();
+        let list = subscriptions_for_user(&conn, &a).unwrap();
+        assert_eq!(list.len(), 1, "one endpoint, one row");
+        assert_eq!(list[0].p256dh.as_deref(), Some("ROTATED"));
+    }
+
+    #[test]
+    fn an_endpoint_moves_to_whoever_last_subscribed_it() {
+        // The same browser, now signed into a different account. Leaving it on
+        // the old account would push one user's notifications to another's screen.
+        let (p, a, b) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        upsert_subscription(&p, &sub("s2", &b, "https://push.example/1"), 2_000).unwrap();
+
+        let conn = p.get().unwrap();
+        assert!(subscriptions_for_user(&conn, &a).unwrap().is_empty());
+        assert_eq!(subscriptions_for_user(&conn, &b).unwrap().len(), 1);
+    }
+
+    #[test]
+    fn delete_is_scoped_to_the_owner() {
+        let (p, a, b) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        assert!(!delete_subscription(&p, &b, "https://push.example/1").unwrap());
+        assert!(delete_subscription(&p, &a, "https://push.example/1").unwrap());
+        let conn = p.get().unwrap();
+        assert!(!has_subscription(&conn, &a).unwrap());
+    }
+
+    #[test]
+    fn failures_accumulate_until_the_endpoint_is_declared_dead() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        for i in 1..MAX_FAILURES {
+            assert!(
+                !record_failure(&p, "s1").unwrap(),
+                "still alive after {i} failures"
+            );
+        }
+        assert!(
+            record_failure(&p, "s1").unwrap(),
+            "dead on the {MAX_FAILURES}th"
+        );
+    }
+
+    #[test]
+    fn a_success_clears_the_failure_streak() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        for _ in 0..(MAX_FAILURES - 1) {
+            record_failure(&p, "s1").unwrap();
+        }
+        record_success(&p, "s1", 5_000).unwrap();
+        // A laptop that was merely offline must not be one failure from eviction.
+        assert!(!record_failure(&p, "s1").unwrap());
+    }
+
+    #[test]
+    fn re_subscribing_also_clears_the_failure_streak() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        for _ in 0..(MAX_FAILURES - 1) {
+            record_failure(&p, "s1").unwrap();
+        }
+        // The browser just proved the endpoint works by handing it to us again.
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 2_000).unwrap();
+        assert!(!record_failure(&p, "s1").unwrap());
+    }
+
+    #[test]
+    fn dropping_and_finding_by_endpoint() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        let conn = p.get().unwrap();
+        assert!(find_by_endpoint(&conn, "https://push.example/1")
+            .unwrap()
+            .is_some());
+        assert!(find_by_endpoint(&conn, "https://push.example/nope")
+            .unwrap()
+            .is_none());
+        drop(conn);
+        drop_subscription(&p, "s1").unwrap();
+        let conn = p.get().unwrap();
+        assert!(find_by_endpoint(&conn, "https://push.example/1")
+            .unwrap()
+            .is_none());
+    }
+
+    #[test]
+    fn deleting_a_user_takes_their_endpoints_with_them() {
+        let (p, a, _) = pool();
+        upsert_subscription(&p, &sub("s1", &a, "https://push.example/1"), 1_000).unwrap();
+        let conn = p.get().unwrap();
+        conn.execute("DELETE FROM users WHERE id = ?1", params![a])
+            .unwrap();
+        assert!(!has_subscription(&conn, &a).unwrap());
+    }
+
+    #[test]
+    fn a_missing_endpoint_table_errors_rather_than_reporting_nobody_subscribed() {
+        let (p, a, _) = pool();
+        let conn = p.get().unwrap();
+        conn.execute_batch("DROP TABLE push_subscriptions").unwrap();
+
+        assert!(has_subscription(&conn, &a).is_err());
+    }
+}

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

@@ -0,0 +1,231 @@
+//! Problem-report persistence: insert, list, triage-status transitions, delete.
+
+use super::*;
+use kroma_domain::{Report, ReportCategory, ReportStatus, ReportSubjectKind};
+
+// Positional order must match [`row_to_report`].
+const REPORT_COLS: &str = "r.id, r.subject_kind, r.subject_id, r.subject_title, r.category, \
+    r.message, r.status, r.reported_by, u.username, r.resolved_by, r.resolved_at, \
+    r.created_at, r.updated_at";
+
+fn row_to_report(r: &Row) -> rusqlite::Result<Report> {
+    let subject_kind: String = r.get(1)?;
+    let category: String = r.get(4)?;
+    let status: String = r.get(6)?;
+    Ok(Report {
+        id: r.get(0)?,
+        subject_kind: ReportSubjectKind::parse(&subject_kind).unwrap_or(ReportSubjectKind::Movie),
+        subject_id: r.get(2)?,
+        subject_title: r.get(3)?,
+        category: ReportCategory::parse(&category).unwrap_or(ReportCategory::Other),
+        message: r.get(5)?,
+        status: ReportStatus::parse(&status).unwrap_or(ReportStatus::Open),
+        reported_by: r.get(7)?,
+        reported_by_name: r.get(8)?,
+        resolved_by: r.get(9)?,
+        resolved_at: r.get(10)?,
+        created_at: r.get(11)?,
+        updated_at: r.get(12)?,
+    })
+}
+
+pub struct NewReport {
+    pub id: String,
+    pub subject_kind: ReportSubjectKind,
+    pub subject_id: String,
+    pub subject_title: String,
+    pub category: ReportCategory,
+    pub message: Option<String>,
+    pub reported_by: Option<String>,
+}
+
+pub fn insert_report(pool: &Pool, report: &NewReport, now_ms: i64) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "INSERT INTO reports \
+         (id, subject_kind, subject_id, subject_title, category, message, status, reported_by, created_at, updated_at) \
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'open', ?7, ?8, ?8)",
+        params![
+            report.id,
+            report.subject_kind.as_str(),
+            report.subject_id,
+            report.subject_title,
+            report.category.as_str(),
+            report.message,
+            report.reported_by,
+            now_ms
+        ],
+    )?;
+    Ok(())
+}
+
+/// All reports newest-first, optionally scoped to one reporter.
+pub fn list_reports(conn: &Connection, only_user: Option<&str>) -> rusqlite::Result<Vec<Report>> {
+    let base =
+        format!("SELECT {REPORT_COLS} FROM reports r LEFT JOIN users u ON u.id = r.reported_by");
+    match only_user {
+        Some(uid) => {
+            let mut stmt = conn.prepare(&format!(
+                "{base} WHERE r.reported_by = ?1 ORDER BY r.created_at DESC"
+            ))?;
+            let rows = stmt.query_map(params![uid], row_to_report)?;
+            rows.collect()
+        }
+        None => {
+            let mut stmt = conn.prepare(&format!("{base} ORDER BY r.created_at DESC"))?;
+            let rows = stmt.query_map([], row_to_report)?;
+            rows.collect()
+        }
+    }
+}
+
+pub fn get_report(conn: &Connection, id: &str) -> rusqlite::Result<Option<Report>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {REPORT_COLS} FROM reports r LEFT JOIN users u ON u.id = r.reported_by WHERE r.id = ?1"
+    ))?;
+    let mut rows = stmt.query_map(params![id], row_to_report)?;
+    rows.next().transpose()
+}
+
+/// A terminal state records the acting admin and timestamp; reopening clears
+/// both. `false` when the id is absent.
+pub fn set_report_status(
+    pool: &Pool,
+    id: &str,
+    status: ReportStatus,
+    actor: Option<&str>,
+    now_ms: i64,
+) -> Result<bool> {
+    let conn = pool.get()?;
+    let (resolved_by, resolved_at) = match status {
+        ReportStatus::Open => (None, None),
+        _ => (actor, Some(now_ms)),
+    };
+    let n = conn.execute(
+        "UPDATE reports SET status = ?2, resolved_by = ?3, resolved_at = ?4, updated_at = ?5 WHERE id = ?1",
+        params![id, status.as_str(), resolved_by, resolved_at, now_ms],
+    )?;
+    Ok(n > 0)
+}
+
+/// `false` when the id is absent.
+pub fn delete_report(pool: &Pool, id: &str) -> Result<bool> {
+    let conn = pool.get()?;
+    Ok(conn.execute("DELETE FROM reports WHERE id = ?1", params![id])? > 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::TempPool;
+
+    fn pool() -> TempPool {
+        crate::testing::temp_pool("report")
+    }
+
+    fn new_report(id: &str, kind: ReportSubjectKind, category: ReportCategory) -> NewReport {
+        NewReport {
+            id: id.into(),
+            subject_kind: kind,
+            subject_id: format!("{id}-subj"),
+            subject_title: "Title".into(),
+            category,
+            message: Some("broken".into()),
+            reported_by: None,
+        }
+    }
+
+    #[test]
+    fn insert_list_and_get_roundtrip() {
+        let p = pool();
+        insert_report(
+            &p,
+            &new_report("r1", ReportSubjectKind::Movie, ReportCategory::Audio),
+            1000,
+        )
+        .unwrap();
+        insert_report(
+            &p,
+            &new_report("r2", ReportSubjectKind::Show, ReportCategory::Metadata),
+            2000,
+        )
+        .unwrap();
+
+        let conn = p.get().unwrap();
+        let all = list_reports(&conn, None).unwrap();
+        assert_eq!(all.len(), 2);
+        assert_eq!(all[0].id, "r2");
+        assert_eq!(all[0].category, ReportCategory::Metadata);
+        assert_eq!(all[0].status, ReportStatus::Open);
+
+        let one = get_report(&conn, "r1").unwrap().unwrap();
+        assert_eq!(one.subject_kind, ReportSubjectKind::Movie);
+        assert_eq!(one.message.as_deref(), Some("broken"));
+        assert!(get_report(&conn, "ghost").unwrap().is_none());
+    }
+
+    #[test]
+    fn status_transitions_set_and_clear_resolver_fields() {
+        let p = pool();
+        // resolved_by FKs users, so the acting admin must be a real account.
+        let admin = crate::create_user(&p, "admin@test.dev", "admin", "h", &[])
+            .unwrap()
+            .id;
+        insert_report(
+            &p,
+            &new_report("r1", ReportSubjectKind::Movie, ReportCategory::Video),
+            1000,
+        )
+        .unwrap();
+
+        assert!(set_report_status(&p, "r1", ReportStatus::Resolved, Some(&admin), 5000).unwrap());
+        let conn = p.get().unwrap();
+        let r = get_report(&conn, "r1").unwrap().unwrap();
+        assert_eq!(r.status, ReportStatus::Resolved);
+        assert_eq!(r.resolved_by.as_deref(), Some(admin.as_str()));
+        assert_eq!(r.resolved_at, Some(5000));
+        drop(conn);
+
+        assert!(set_report_status(&p, "r1", ReportStatus::Open, None, 6000).unwrap());
+        let conn = p.get().unwrap();
+        let r = get_report(&conn, "r1").unwrap().unwrap();
+        assert_eq!(r.status, ReportStatus::Open);
+        assert_eq!(r.resolved_by, None);
+        assert_eq!(r.resolved_at, None);
+        drop(conn);
+
+        assert!(
+            !set_report_status(&p, "ghost", ReportStatus::Dismissed, Some(&admin), 7000).unwrap()
+        );
+    }
+
+    #[test]
+    fn list_scopes_to_one_reporter_and_delete_removes() {
+        let p = pool();
+        // reported_by FKs users, so the reporter must be a real account.
+        let alice = crate::create_user(&p, "a@test.dev", "alice", "h", &[])
+            .unwrap()
+            .id;
+        let mut ra = new_report("ra", ReportSubjectKind::Movie, ReportCategory::Other);
+        ra.reported_by = Some(alice.clone());
+        insert_report(&p, &ra, 1000).unwrap();
+        insert_report(
+            &p,
+            &new_report("rb", ReportSubjectKind::Movie, ReportCategory::Other),
+            2000,
+        )
+        .unwrap();
+
+        let conn = p.get().unwrap();
+        let mine = list_reports(&conn, Some(&alice)).unwrap();
+        assert_eq!(mine.len(), 1);
+        assert_eq!(mine[0].id, "ra");
+        assert_eq!(mine[0].reported_by_name.as_deref(), Some("alice"));
+        drop(conn);
+
+        assert!(delete_report(&p, "ra").unwrap());
+        assert!(!delete_report(&p, "ra").unwrap());
+        let conn = p.get().unwrap();
+        assert_eq!(list_reports(&conn, None).unwrap().len(), 1);
+    }
+}