cot 0.4.0

The Rust web framework for lazy developers.
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
111
112
113
114
115
116
117
118
119
120
121
122

pub(crate) mod humantime {
    use std::time::Duration;

    use serde::{Deserialize, Deserializer, Serializer};

    #[expect(clippy::ref_option, reason = "&Option<_> needed for serde")]
    pub(crate) fn serialize<S>(
        duration: &Option<Duration>,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match duration {
            Some(duration) => {
                serializer.serialize_str(&humantime::format_duration(*duration).to_string())
            }
            None => serializer.serialize_none(),
        }
    }

    pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = Option::<String>::deserialize(deserializer)?;
        match s {
            None => Ok(None),
            Some(value) => humantime::parse_duration(&value)
                .map(Some)
                .map_err(serde::de::Error::custom),
        }
    }
}

pub(crate) mod session_expiry_time {
    use chrono::DateTime;
    use serde::{Deserialize, Deserializer, Serializer};

    use crate::config::Expiry;

    pub(crate) fn serialize<S>(expiry: &Expiry, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match expiry {
            Expiry::OnSessionEnd => serializer.serialize_none(),
            Expiry::OnInactivity(time) => super::humantime::serialize(&Some(*time), serializer),
            Expiry::AtDateTime(time) => serializer.serialize_str(&time.to_string()),
        }
    }

    pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<Expiry, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = Option::<String>::deserialize(deserializer)?;
        match s {
            None => Ok(Expiry::OnSessionEnd),
            Some(value) => {
                humantime::parse_duration(&value)
                    .map(Expiry::OnInactivity)
                    // On failure, fall back to RFC3339 format
                    .or_else(|_| {
                        DateTime::parse_from_rfc3339(&value)
                            .map(Expiry::AtDateTime)
                            .map_err(|e| {
                                serde::de::Error::custom(format!(
                                    "expiry must be a humantime duration or RFC3339 timestamp; got {value:?}: {e:?}"
                                ))
                            })
                    })
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use chrono::DateTime;
    use serde::Serialize;

    use crate::config::Expiry;

    #[derive(Serialize)]
    struct Wrapper {
        #[serde(with = "crate::serializers::session_expiry_time")]
        expiry: Expiry,
    }
    #[test]
    fn json_serialize_session_expiry_time() {
        let opts = [
            (
                Wrapper {
                    expiry: Expiry::OnSessionEnd,
                },
                r#"{"expiry":null}"#,
            ),
            (
                Wrapper {
                    expiry: Expiry::OnInactivity(Duration::from_secs(3600)),
                },
                r#"{"expiry":"1h"}"#,
            ),
            (
                Wrapper {
                    expiry: Expiry::AtDateTime(
                        DateTime::parse_from_rfc3339("2025-12-31T23:59:59+00:00").unwrap(),
                    ),
                },
                r#"{"expiry":"2025-12-31 23:59:59 +00:00"}"#,
            ),
        ];

        for (wrapper, expected) in opts {
            let json = serde_json::to_string(&wrapper).unwrap();
            assert_eq!(json, expected);
        }
    }
}