aleph-types 0.13.0

Definitions for the most commonly used types in the Aleph Cloud network.
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
104
105
106
107
108
109
110

use chrono::{DateTime, TimeZone, Timelike, Utc};
use serde::{Deserialize, Serialize};
use std::fmt::Display;

#[derive(Debug, thiserror::Error)]
pub enum TimestampError {
    #[error("Timestamp out of bounds")]
    OutOfBounds,
    #[error("Failed to parse timestamp")]
    ParseError,
}

/// Timestamp type on the Aleph Cloud network.
///
/// Time in Aleph messages is usually represented as a floating-point epoch timestamp. This type
/// keeps the floating point representation for fast serialization/deserialization and to avoid
/// loss of precision, but provides helpers to convert to datetime for human readability.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Timestamp(f64);

impl From<f64> for Timestamp {
    fn from(value: f64) -> Self {
        Self(value)
    }
}

impl From<DateTime<Utc>> for Timestamp {
    fn from(datetime: DateTime<Utc>) -> Self {
        Self(datetime.timestamp() as f64 + datetime.nanosecond() as f64 / 1_000_000_000.0)
    }
}

impl Timestamp {
    pub fn now() -> Self {
        Self::from(chrono::Utc::now())
    }

    pub fn as_f64(&self) -> f64 {
        self.0
    }

    pub fn to_datetime(&self) -> Result<DateTime<Utc>, TimestampError> {
        let secs = self.0.floor() as i64;
        let nsecs = ((self.0.fract() * 1_000_000_000.0).round() as u32).min(999_999_999);
        match Utc.timestamp_opt(secs, nsecs) {
            chrono::LocalResult::Single(dt) => Ok(dt),
            chrono::LocalResult::Ambiguous(earliest, latest) => {
                panic!(
                    "Ambiguous timestamp (earliest: {} - latest: {}), which should be impossible when importing a timestamp to UTC datetime",
                    earliest.to_rfc3339(),
                    latest.to_rfc3339()
                )
            }
            chrono::LocalResult::None => Err(TimestampError::OutOfBounds),
        }
    }
}

impl Display for Timestamp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let datetime_str = match self.to_datetime() {
            Ok(dt) => dt.to_rfc3339(),
            Err(_) => "invalid datetime".to_string(),
        };

        write!(f, "{} ({})", self.0, datetime_str)
    }
}

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

    #[test]
    fn test_timestamp_serialization() {
        let dt = Utc.timestamp_opt(1635789600, 500_000_000).unwrap();
        let timestamp = Timestamp::from(dt);
        let serialized = serde_json::to_string(&timestamp).unwrap();
        assert_eq!(serialized, "1635789600.5");
    }

    #[test]
    fn test_timestamp_deserialization() {
        let json = "1635789600.5";
        let timestamp: Timestamp = serde_json::from_str(json).unwrap();
        assert_eq!(timestamp.0, 1635789600.5);
    }

    #[test]
    fn test_timestamp_now() {
        let before = chrono::Utc::now().timestamp() as f64;
        let ts = Timestamp::now();
        let after = chrono::Utc::now().timestamp() as f64;

        let ts_f64 = ts.as_f64();
        assert!(ts_f64 >= before);
        assert!(ts_f64 <= after + 1.0);
    }

    #[test]
    fn test_timestamp_display() {
        let dt = Utc.timestamp_opt(1635789600, 500_000_000).unwrap();
        let timestamp = Timestamp::from(dt);
        assert_eq!(
            format!("{}", timestamp),
            "1635789600.5 (2021-11-01T18:00:00.500+00:00)"
        );
    }
}