origin-domain 0.2.0

Origin domain primitives and platform ports. Knows no product, no Tauri, no storage engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! Background jobs. Everything long-running reports progress the same way, so every
//! product can reuse one progress UI.

use crate::ids::JobId;
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "ts", derive(ts_rs::TS))]
#[serde(rename_all = "snake_case")]
pub enum JobStatus {
    Queued,
    Running,
    Succeeded,
    Failed,
    Cancelled,
}

impl JobStatus {
    pub fn is_terminal(self) -> bool {
        matches!(self, Self::Succeeded | Self::Failed | Self::Cancelled)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "ts", derive(ts_rs::TS))]
pub struct Progress {
    pub current: u64,
    /// `None` while the total is not yet known — the UI shows an indeterminate bar.
    pub total: Option<u64>,
}

impl Progress {
    pub fn indeterminate() -> Self {
        Self {
            current: 0,
            total: None,
        }
    }

    pub fn of(current: u64, total: u64) -> Self {
        Self {
            current,
            total: Some(total),
        }
    }

    /// Completion between `0.0` and `1.0`, if the total is known and non-zero.
    pub fn ratio(&self) -> Option<f64> {
        match self.total {
            Some(total) if total > 0 => Some((self.current as f64 / total as f64).clamp(0.0, 1.0)),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "ts", derive(ts_rs::TS))]
pub struct Job {
    pub id: JobId,
    /// Product-defined job kind, e.g. `scan-repository`.
    pub kind: String,
    pub status: JobStatus,
    pub progress: Progress,
    pub cancelable: bool,
    #[serde(with = "time::serde::rfc3339")]
    #[cfg_attr(feature = "ts", ts(type = "string"))]
    pub started_at: OffsetDateTime,
    #[serde(with = "time::serde::rfc3339::option")]
    #[cfg_attr(feature = "ts", ts(type = "string | null"))]
    pub finished_at: Option<OffsetDateTime>,
    pub error: Option<String>,
}

impl Job {
    pub fn queued(kind: impl Into<String>, started_at: OffsetDateTime) -> Self {
        Self {
            id: JobId::generate(),
            kind: kind.into(),
            status: JobStatus::Queued,
            progress: Progress::indeterminate(),
            cancelable: true,
            started_at,
            finished_at: None,
            error: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ratio_is_none_while_the_total_is_unknown() {
        assert_eq!(Progress::indeterminate().ratio(), None);
    }

    #[test]
    fn ratio_never_exceeds_one() {
        assert_eq!(Progress::of(12, 10).ratio(), Some(1.0));
    }
}