@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-domain/src/naming/title.rs

@@ -0,0 +1,349 @@
+//! Title cleaning and the release-junk tokenizer: turn a raw filename/folder
+//! fragment into a clean movie/show/episode title and pull out the year.
+
+// "Hard" release tokens (lowercase): unambiguous scene/source/codec markers.
+// Nobody titles a film `BluRay` or `x265`, so the first one reliably ends the
+// real title.
+const HARD_TOKENS: &[&str] = &[
+    "4k",
+    "uhd",
+    "bluray",
+    "blu",
+    "brrip",
+    "bdrip",
+    "bdremux",
+    "webrip",
+    "webdl",
+    "hdtv",
+    "sdtv",
+    "pdtv",
+    "dvdrip",
+    "dvdscr",
+    "dvd",
+    "remux",
+    "hdrip",
+    "x264",
+    "x265",
+    "h264",
+    "h265",
+    "hevc",
+    "avc",
+    "xvid",
+    "divx",
+    "av1",
+    "mpeg2",
+    "vc1",
+    "aac",
+    "ac3",
+    "eac3",
+    "dts",
+    "truehd",
+    "atmos",
+    "ddp",
+    "dd5",
+    "flac",
+    "opus",
+    "hdr",
+    "hdr10",
+    "hdr10plus",
+    "dv",
+    "dovi",
+    "sdr",
+    "10bit",
+    "8bit",
+    "vostfr",
+];
+
+// "Soft" tokens: real dictionary words that also appear as release tags
+// (`FRENCH` dub, `EXTENDED`/`UNCUT` cut, `IMAX`…). They end the title **only**
+// when they sit directly inside the trailing release run (adjacent to a hard
+// marker), so legitimate titles like "The French Dispatch" and "Uncut Gems"
+// survive intact.
+const SOFT_TOKENS: &[&str] = &[
+    "french",
+    "truefrench",
+    "subfrench",
+    "vff",
+    "vof",
+    "vfq",
+    "multi",
+    "extended",
+    "unrated",
+    "uncut",
+    "imax",
+    "proper",
+    "repack",
+    "remastered",
+    "remaster",
+    "theatrical",
+    "integrale",
+];
+
+/// Clean a movie/show title: drop a trailing `(year)` and any release metadata,
+/// normalise separators, collapse whitespace.
+///
+/// A parenthesised `(YYYY)` is treated as the authoritative year cut, so a title
+/// that legitimately contains a number "Blade Runner 2049 (2017)" keeps the
+/// number and loses only the real year.
+pub fn clean_title(raw: &str) -> String {
+    // normalize_separators preserves byte length (ASCII punctuation → space), so
+    // a paren index found in `raw` is valid in `spaced`.
+    let spaced = normalize_separators(raw);
+
+    // A parenthesised `(YYYY)` is the authoritative title boundary: cut there and
+    // ignore dictionary-word release tags that precede it. This keeps "The French
+    // Dispatch (2021)" whole and lets "Blade Runner 2049 (2017)" keep its number.
+    if let Some((i, _)) = paren_year(raw) {
+        return finalize(&spaced[..i]);
+    }
+
+    // No parenthesised year: the title ends at the earliest of a bare 4-digit
+    // year or the start of the trailing release run.
+    let cut = [find_year_index(&spaced), release_cut_index(&spaced)]
+        .into_iter()
+        .flatten()
+        .min();
+    let title = match cut {
+        Some(i) => finalize(&spaced[..i]),
+        None => finalize(&spaced),
+    };
+
+    // A *leading* year (home video "2018 - LaserGame - Indian Forest") would
+    // truncate the title to nothing; recover the text that follows it instead.
+    if title.is_empty() {
+        if let Some(i) = find_year_index(&spaced) {
+            let after = finalize(&spaced[i + 4..]);
+            if !after.is_empty() {
+                return clean_title(&after);
+            }
+        }
+    }
+    title
+}
+
+// A parenthesised year `(YYYY)`; returns the index of the `(` and the year.
+fn paren_year(raw: &str) -> Option<(usize, u32)> {
+    let b = raw.as_bytes();
+    let mut i = 0;
+    while i + 6 <= b.len() {
+        if b[i] == b'(' && b[i + 5] == b')' && b[i + 1..i + 5].iter().all(u8::is_ascii_digit) {
+            // Digits are verified ASCII above, so fold them directly no UTF-8
+            // decode / parse / unreachable fallback.
+            let y = (b[i + 1] - b'0') as u32 * 1000
+                + (b[i + 2] - b'0') as u32 * 100
+                + (b[i + 3] - b'0') as u32 * 10
+                + (b[i + 4] - b'0') as u32;
+            if (1900..=2099).contains(&y) {
+                return Some((i, y));
+            }
+        }
+        i += 1;
+    }
+    None
+}
+
+/// Clean an episode title (text after the marker). No year-cut episode names
+/// can legitimately contain numbers but release junk is still stripped.
+pub(super) fn clean_episode_title(raw: &str) -> String {
+    let spaced = normalize_separators(raw);
+    let end = release_cut_index(&spaced).unwrap_or(spaced.len());
+    finalize(&spaced[..end])
+}
+
+fn normalize_separators(raw: &str) -> String {
+    raw.replace(['.', '_'], " ")
+        .replace(['[', ']', '{', '}', '(', ')'], " ")
+}
+
+fn finalize(s: &str) -> String {
+    s.split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ")
+        .trim()
+        .trim_matches('-')
+        .trim()
+        .to_string()
+}
+
+// Byte index where the trailing release run begins, or `None`.
+//
+// A hard marker (`1080p`, `BluRay`, `x265`, …) opens the run; soft dictionary
+// words (`FRENCH`, `EXTENDED`, `UNCUT`, …) are absorbed only when they sit
+// directly before it. So "Movie FRENCH 1080p" drops both words, while "The
+// French Dispatch" and "Uncut Gems" (no adjacent hard marker) keep theirs.
+fn release_cut_index(s: &str) -> Option<usize> {
+    let mut off = 0usize;
+    let words: Vec<(usize, &str)> = s
+        .split(' ')
+        .map(|w| {
+            let at = off;
+            off += w.len() + 1; // +1 for the space we split on
+            (at, w)
+        })
+        .collect();
+
+    let hard = words.iter().position(|(_, w)| is_hard_word(w))?;
+    let mut start = hard;
+    while start > 0 && is_soft_word(words[start - 1].1) {
+        start -= 1;
+    }
+    Some(words[start].0)
+}
+
+// Strip surrounding punctuation and keep the part before a `-` (so `BluRay-1080p`
+// and `AAC-trailer` reduce to their leading token), lowercased.
+fn token_head(word: &str) -> String {
+    let w = word
+        .trim_matches(|c: char| !c.is_ascii_alphanumeric())
+        .to_ascii_lowercase();
+    w.split('-').next().unwrap_or(&w).to_string()
+}
+
+// A resolution token like `720p` / `1080p` / `2160p` / `1080i`.
+fn is_resolution(head: &str) -> bool {
+    head.strip_suffix(|c| c == 'p' || c == 'i')
+        .map(|rest| !rest.is_empty() && rest.bytes().all(|b| b.is_ascii_digit()))
+        .unwrap_or(false)
+}
+
+fn is_hard_word(word: &str) -> bool {
+    let head = token_head(word);
+    !head.is_empty() && (HARD_TOKENS.contains(&head.as_str()) || is_resolution(&head))
+}
+
+fn is_soft_word(word: &str) -> bool {
+    let head = token_head(word);
+    !head.is_empty() && SOFT_TOKENS.contains(&head.as_str())
+}
+
+/// Find the byte index of a standalone 4-digit year (1900–2099).
+pub fn find_year_index(s: &str) -> Option<usize> {
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i + 4 <= bytes.len() {
+        if bytes[i..i + 4].iter().all(u8::is_ascii_digit) {
+            let boundary_before = i == 0 || !bytes[i - 1].is_ascii_alphanumeric();
+            let boundary_after = i + 4 == bytes.len() || !bytes[i + 4].is_ascii_alphanumeric();
+            if boundary_before && boundary_after && is_plausible_year(&s[i..i + 4]) {
+                return Some(i);
+            }
+        }
+        i += 1;
+    }
+    None
+}
+
+fn is_plausible_year(chunk: &str) -> bool {
+    chunk
+        .parse::<u32>()
+        .map(|y| (1900..=2099).contains(&y))
+        .unwrap_or(false)
+}
+
+/// Best-effort year parse from a name. A parenthesised `(YYYY)` wins over a bare
+/// 4-digit number so "Blade Runner 2049 (2017)" resolves to 2017.
+pub fn parse_year(name: &str) -> Option<u32> {
+    if let Some((_, y)) = paren_year(name) {
+        return Some(y);
+    }
+    let s = normalize_separators(name);
+    let idx = find_year_index(&s)?;
+    s[idx..idx + 4].parse::<u32>().ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clean_title_strips_release_run() {
+        assert_eq!(
+            clean_title("The.Matrix.1999.1080p.BluRay.x264-GRP"),
+            "The Matrix"
+        );
+        assert_eq!(clean_title("Movie FRENCH 1080p x264"), "Movie");
+        assert_eq!(clean_title("Just A Clean Title"), "Just A Clean Title");
+    }
+
+    #[test]
+    fn a_leading_year_hands_the_title_back_to_the_text_behind_it() {
+        assert_eq!(
+            clean_title("2018 - LaserGame - Indian Forest"),
+            "LaserGame - Indian Forest"
+        );
+        assert_eq!(clean_title("2018"), "");
+    }
+
+    #[test]
+    fn clean_title_paren_year_is_authoritative() {
+        assert_eq!(
+            clean_title("Blade Runner 2049 (2017) 2160p"),
+            "Blade Runner 2049"
+        );
+        assert_eq!(clean_title("Uncut Gems (2019) WEBDL-1080p"), "Uncut Gems");
+    }
+
+    #[test]
+    fn clean_episode_title_strips_junk_but_keeps_numbers() {
+        assert_eq!(clean_episode_title("The Dundies 1080p x265"), "The Dundies");
+        assert_eq!(clean_episode_title("Episode 50"), "Episode 50");
+        assert_eq!(clean_episode_title(""), "");
+        assert_eq!(clean_episode_title("1080p BluRay"), "");
+    }
+
+    #[test]
+    fn parse_year_prefers_parenthesized() {
+        assert_eq!(parse_year("Blade Runner 2049 (2017)"), Some(2017));
+        assert_eq!(parse_year("The Matrix 1999"), Some(1999));
+        assert_eq!(parse_year("No Year Here"), None);
+        // Out of the plausible 1900..=2099 range.
+        assert_eq!(parse_year("(1850)"), None);
+        assert_eq!(parse_year("2049"), Some(2049));
+    }
+
+    #[test]
+    fn find_year_index_needs_word_boundaries() {
+        assert_eq!(find_year_index("The Matrix 1999"), Some(11));
+        // Embedded in a larger token is not a year.
+        assert_eq!(find_year_index("abc1999def"), None);
+        assert_eq!(find_year_index("no digits here"), None);
+    }
+
+    #[test]
+    fn a_year_scan_never_splits_a_multibyte_character() {
+        assert_eq!(find_year_index("12 émissions"), None);
+        assert_eq!(find_year_index("10 話"), None);
+        assert_eq!(parse_year("12 émissions"), None);
+        assert_eq!(clean_title("12 émissions"), "12 émissions");
+        assert_eq!(parse_year("Amélie 2001 1080p"), Some(2001));
+    }
+
+    #[test]
+    fn paren_year_detects_and_bounds() {
+        assert_eq!(paren_year("Movie (2001)"), Some((6, 2001)));
+        // Five digits inside the parens: not a (YYYY) form.
+        assert_eq!(paren_year("Movie (12345)"), None);
+        assert_eq!(paren_year("Movie 2001"), None);
+    }
+
+    #[test]
+    fn resolution_and_token_head_helpers() {
+        assert!(is_resolution("1080p"));
+        assert!(is_resolution("720i"));
+        assert!(!is_resolution("p"));
+        assert!(!is_resolution("bluray"));
+        assert_eq!(token_head("BluRay-1080p"), "bluray");
+        assert!(is_hard_word("x265"));
+        assert!(is_hard_word("2160p"));
+        assert!(is_soft_word("FRENCH"));
+        assert!(!is_soft_word("Matrix"));
+    }
+
+    #[test]
+    fn leading_year_recovers_the_title() {
+        assert_eq!(
+            clean_title("2018 - LaserGame - Indian Forest"),
+            "LaserGame - Indian Forest"
+        );
+    }
+}

package/rust/kroma-domain/src/notifications/action.rs

@@ -0,0 +1,50 @@
+//! A notification's action buttons, in both their unrendered and rendered form.
+
+use serde::{Deserialize, Serialize};
+
+/// What an action button does when tapped.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ActionKind {
+    Link,
+    Api,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ActionStyle {
+    #[default]
+    Default,
+    Primary,
+    Danger,
+}
+
+/// One button on a notification. `label` is rendered from an i18n key before it
+/// goes out (see [`NotificationSpec`], which carries `label_key` instead).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NotificationAction {
+    pub id: String,
+    pub label: String,
+    pub kind: ActionKind,
+    // Client route for `ActionKind::Link`, API path for `ActionKind::Api`.
+    pub href: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub method: Option<String>,
+    #[serde(default)]
+    pub style: ActionStyle,
+}
+
+/// The unrendered half of an action, as producers declare it.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActionSpec {
+    pub id: String,
+    pub label_key: String,
+    pub kind: ActionKind,
+    pub href: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub method: Option<String>,
+    #[serde(default)]
+    pub style: ActionStyle,
+}

package/rust/kroma-domain/src/notifications/event.rs

@@ -0,0 +1,225 @@
+//! The notification vocabulary: what a notification is about, and which
+//! preference bucket it falls in.
+
+use serde::{Deserialize, Serialize};
+
+/// What a notification is about. Users switch delivery on and off per category
+/// (`notification_prefs`), so these are the knobs in the settings UI.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum NotificationCategory {
+    Requests,
+    Media,
+    Reports,
+    Downloads,
+    // Admin-only (`settings.manage`).
+    System,
+}
+
+impl NotificationCategory {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            NotificationCategory::Requests => "requests",
+            NotificationCategory::Media => "media",
+            NotificationCategory::Reports => "reports",
+            NotificationCategory::Downloads => "downloads",
+            NotificationCategory::System => "system",
+        }
+    }
+
+    pub fn parse(s: &str) -> Option<NotificationCategory> {
+        match s {
+            "requests" => Some(NotificationCategory::Requests),
+            "media" => Some(NotificationCategory::Media),
+            "reports" => Some(NotificationCategory::Reports),
+            "downloads" => Some(NotificationCategory::Downloads),
+            "system" => Some(NotificationCategory::System),
+            _ => None,
+        }
+    }
+
+    pub const ALL: [NotificationCategory; 5] = [
+        NotificationCategory::Requests,
+        NotificationCategory::Media,
+        NotificationCategory::Reports,
+        NotificationCategory::Downloads,
+        NotificationCategory::System,
+    ];
+}
+
+/// The specific thing that happened. Core events are named here; anything a
+/// module raises is [`NotificationEvent::Custom`], which states its category on
+/// the spec instead.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum NotificationEvent {
+    #[serde(rename = "request.submitted")]
+    RequestSubmitted,
+    #[serde(rename = "request.approved")]
+    RequestApproved,
+    #[serde(rename = "request.denied")]
+    RequestDenied,
+    #[serde(rename = "request.available")]
+    RequestAvailable,
+    #[serde(rename = "media.added")]
+    MediaAdded,
+    #[serde(rename = "media.episode")]
+    MediaEpisode,
+    #[serde(rename = "report.submitted")]
+    ReportSubmitted,
+    #[serde(rename = "report.resolved")]
+    ReportResolved,
+    #[serde(rename = "report.dismissed")]
+    ReportDismissed,
+    #[serde(rename = "download.imported")]
+    DownloadImported,
+    #[serde(rename = "download.failed")]
+    DownloadFailed,
+    #[serde(rename = "system.job.failed")]
+    SystemJobFailed,
+    #[serde(rename = "system.disk.low")]
+    SystemDiskLow,
+    // A "push is working" message from settings. Never persisted.
+    #[serde(rename = "system.test")]
+    SystemTest,
+    #[serde(rename = "custom")]
+    Custom,
+}
+
+impl NotificationEvent {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            NotificationEvent::RequestSubmitted => "request.submitted",
+            NotificationEvent::RequestApproved => "request.approved",
+            NotificationEvent::RequestDenied => "request.denied",
+            NotificationEvent::RequestAvailable => "request.available",
+            NotificationEvent::MediaAdded => "media.added",
+            NotificationEvent::MediaEpisode => "media.episode",
+            NotificationEvent::ReportSubmitted => "report.submitted",
+            NotificationEvent::ReportResolved => "report.resolved",
+            NotificationEvent::ReportDismissed => "report.dismissed",
+            NotificationEvent::DownloadImported => "download.imported",
+            NotificationEvent::DownloadFailed => "download.failed",
+            NotificationEvent::SystemJobFailed => "system.job.failed",
+            NotificationEvent::SystemDiskLow => "system.disk.low",
+            NotificationEvent::SystemTest => "system.test",
+            NotificationEvent::Custom => "custom",
+        }
+    }
+
+    pub fn parse(s: &str) -> Option<NotificationEvent> {
+        match s {
+            "request.submitted" => Some(NotificationEvent::RequestSubmitted),
+            "request.approved" => Some(NotificationEvent::RequestApproved),
+            "request.denied" => Some(NotificationEvent::RequestDenied),
+            "request.available" => Some(NotificationEvent::RequestAvailable),
+            "media.added" => Some(NotificationEvent::MediaAdded),
+            "media.episode" => Some(NotificationEvent::MediaEpisode),
+            "report.submitted" => Some(NotificationEvent::ReportSubmitted),
+            "report.resolved" => Some(NotificationEvent::ReportResolved),
+            "report.dismissed" => Some(NotificationEvent::ReportDismissed),
+            "download.imported" => Some(NotificationEvent::DownloadImported),
+            "download.failed" => Some(NotificationEvent::DownloadFailed),
+            "system.job.failed" => Some(NotificationEvent::SystemJobFailed),
+            "system.disk.low" => Some(NotificationEvent::SystemDiskLow),
+            "system.test" => Some(NotificationEvent::SystemTest),
+            "custom" => Some(NotificationEvent::Custom),
+            _ => None,
+        }
+    }
+
+    /// The admin console's test bench walks this, so an event missing here is
+    /// an event nobody can preview.
+    pub const ALL: [NotificationEvent; 14] = [
+        NotificationEvent::RequestSubmitted,
+        NotificationEvent::RequestApproved,
+        NotificationEvent::RequestDenied,
+        NotificationEvent::RequestAvailable,
+        NotificationEvent::MediaAdded,
+        NotificationEvent::MediaEpisode,
+        NotificationEvent::ReportSubmitted,
+        NotificationEvent::ReportResolved,
+        NotificationEvent::ReportDismissed,
+        NotificationEvent::DownloadImported,
+        NotificationEvent::DownloadFailed,
+        NotificationEvent::SystemJobFailed,
+        NotificationEvent::SystemDiskLow,
+        NotificationEvent::SystemTest,
+    ];
+
+    pub fn category(self) -> NotificationCategory {
+        match self {
+            NotificationEvent::RequestSubmitted
+            | NotificationEvent::RequestApproved
+            | NotificationEvent::RequestDenied
+            | NotificationEvent::RequestAvailable => NotificationCategory::Requests,
+            NotificationEvent::MediaAdded | NotificationEvent::MediaEpisode => {
+                NotificationCategory::Media
+            }
+            NotificationEvent::ReportSubmitted
+            | NotificationEvent::ReportResolved
+            | NotificationEvent::ReportDismissed => NotificationCategory::Reports,
+            NotificationEvent::DownloadImported | NotificationEvent::DownloadFailed => {
+                NotificationCategory::Downloads
+            }
+            NotificationEvent::SystemJobFailed
+            | NotificationEvent::SystemDiskLow
+            | NotificationEvent::SystemTest
+            // Fallback bucket; a spec that means otherwise says so with `in_category`.
+            | NotificationEvent::Custom => NotificationCategory::System,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_category_round_trips_through_its_wire_string() {
+        for c in NotificationCategory::ALL {
+            assert_eq!(NotificationCategory::parse(c.as_str()), Some(c));
+        }
+        assert_eq!(NotificationCategory::parse("nope"), None);
+    }
+
+    #[test]
+    fn every_event_round_trips_and_has_a_category() {
+        for e in NotificationEvent::ALL
+            .into_iter()
+            .chain([NotificationEvent::Custom])
+        {
+            assert_eq!(
+                NotificationEvent::parse(e.as_str()),
+                Some(e),
+                "{}",
+                e.as_str()
+            );
+            let json = serde_json::to_string(&e).unwrap();
+            assert_eq!(json, format!("\"{}\"", e.as_str()));
+        }
+        assert_eq!(
+            NotificationEvent::RequestDenied.category(),
+            NotificationCategory::Requests
+        );
+        assert_eq!(
+            NotificationEvent::MediaEpisode.category(),
+            NotificationCategory::Media
+        );
+        assert_eq!(
+            NotificationEvent::SystemDiskLow.category(),
+            NotificationCategory::System
+        );
+        assert_eq!(
+            NotificationEvent::ReportResolved.category(),
+            NotificationCategory::Reports
+        );
+        assert_eq!(
+            NotificationEvent::DownloadImported.category(),
+            NotificationCategory::Downloads
+        );
+        assert_eq!(
+            NotificationEvent::DownloadFailed.category(),
+            NotificationCategory::Downloads
+        );
+    }
+}

package/rust/kroma-domain/src/notifications/mod.rs

@@ -0,0 +1,18 @@
+//! Notifications as pure data (serde); persistence lives in
+//! `crate::db::notifications`, delivery in `crate::services::notify`.
+//!
+//! Stored rows hold an i18n key plus params, never rendered text; the wire shape
+//! below is the RENDERED form and is a public client contract, so field names,
+//! casing and epoch-millisecond timestamps must not drift.
+
+mod action;
+mod event;
+mod param;
+mod spec;
+mod view;
+
+pub use action::*;
+pub use event::*;
+pub use param::*;
+pub use spec::*;
+pub use view::*;