Skip to main content

appstruct_runtime/
bigint.rs

1//! Lossless JSON transport for business bigint fields. Rust and PostgreSQL still use i64.
2
3use serde::{Deserialize, Deserializer, Serializer, de};
4
5#[derive(Deserialize)]
6#[serde(untagged)]
7enum Input {
8    Text(String),
9    Number(i64),
10}
11
12impl Input {
13    fn value<E: de::Error>(self) -> Result<i64, E> {
14        match self {
15            Self::Text(value) => {
16                let digits = value.strip_prefix('-').unwrap_or(&value);
17                if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
18                    return Err(E::custom("bigint must be a decimal integer string"));
19                }
20                value.parse().map_err(E::custom)
21            }
22            Self::Number(value)
23                if (-9_007_199_254_740_991..=9_007_199_254_740_991).contains(&value) =>
24            {
25                Ok(value)
26            }
27            Self::Number(_) => Err(E::custom(
28                "bigint outside the safe JSON integer range must be a string",
29            )),
30        }
31    }
32}
33
34/// # Errors
35/// Returns the serializer's error if the decimal string cannot be written.
36pub fn serialize<S: Serializer>(value: &i64, serializer: S) -> Result<S::Ok, S::Error> {
37    serializer.collect_str(value)
38}
39
40/// # Errors
41/// Rejects invalid integers, values outside i64, and unsafe numeric JSON inputs.
42pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<i64, D::Error> {
43    Input::deserialize(deserializer)?.value()
44}
45
46pub mod optional {
47    use super::{Deserialize, Deserializer, Input, Serializer};
48
49    /// # Errors
50    /// Returns the serializer's error if the string or null cannot be written.
51    pub fn serialize<S: Serializer>(value: &Option<i64>, serializer: S) -> Result<S::Ok, S::Error> {
52        match value {
53            Some(value) => serializer.collect_str(value),
54            None => serializer.serialize_none(),
55        }
56    }
57
58    /// # Errors
59    /// Rejects present values that do not satisfy the bigint transport contract.
60    pub fn deserialize<'de, D: Deserializer<'de>>(
61        deserializer: D,
62    ) -> Result<Option<i64>, D::Error> {
63        Option::<Input>::deserialize(deserializer)?
64            .map(Input::value)
65            .transpose()
66    }
67}
68
69pub mod patch {
70    use super::{Deserializer, Serializer, optional};
71
72    /// # Errors
73    /// Returns the serializer's error if the patch value cannot be written.
74    pub fn serialize<S: Serializer>(
75        value: &Option<Option<i64>>,
76        serializer: S,
77    ) -> Result<S::Ok, S::Error> {
78        optional::serialize(&value.flatten(), serializer)
79    }
80
81    /// # Errors
82    /// Rejects non-null values that do not satisfy the bigint transport contract.
83    pub fn deserialize<'de, D: Deserializer<'de>>(
84        deserializer: D,
85    ) -> Result<Option<Option<i64>>, D::Error> {
86        optional::deserialize(deserializer).map(Some)
87    }
88}
89
90#[cfg(test)]
91mod tests {
92    use serde::{Deserialize, Serialize};
93    use serde_json::json;
94
95    #[derive(Debug, Deserialize, Serialize, PartialEq)]
96    #[allow(clippy::option_option)]
97    struct Record {
98        #[serde(with = "super")]
99        required: i64,
100        #[serde(default, with = "super::optional")]
101        optional: Option<i64>,
102        #[serde(
103            default,
104            with = "super::patch",
105            skip_serializing_if = "Option::is_none"
106        )]
107        patch: Option<Option<i64>>,
108    }
109
110    #[test]
111    fn full_i64_range_round_trips_without_numeric_json() {
112        for value in [
113            i64::MIN,
114            -9_007_199_254_740_993,
115            0,
116            9_007_199_254_740_993,
117            i64::MAX,
118        ] {
119            let record = Record {
120                required: value,
121                optional: Some(value),
122                patch: Some(Some(value)),
123            };
124            let encoded = serde_json::to_value(&record).unwrap();
125            assert_eq!(encoded["required"], value.to_string());
126            assert_eq!(serde_json::from_value::<Record>(encoded).unwrap(), record);
127        }
128    }
129
130    #[test]
131    fn patch_preserves_omitted_null_and_present_values() {
132        for (input, expected) in [
133            (json!({"required": "1"}), None),
134            (json!({"required": "1", "patch": null}), Some(None)),
135            (json!({"required": "1", "patch": "2"}), Some(Some(2))),
136        ] {
137            assert_eq!(
138                serde_json::from_value::<Record>(input).unwrap().patch,
139                expected
140            );
141        }
142    }
143
144    #[test]
145    fn accepts_legacy_safe_integers_and_rejects_lossy_or_invalid_inputs() {
146        assert_eq!(
147            serde_json::from_value::<Record>(json!({"required": 42}))
148                .unwrap()
149                .required,
150            42
151        );
152        for value in [
153            json!(9_007_199_254_740_993_i64),
154            json!(1.5),
155            json!("1.0"),
156            json!("1e3"),
157            json!("+1"),
158            json!("9223372036854775808"),
159        ] {
160            assert!(serde_json::from_value::<Record>(json!({"required": value})).is_err());
161        }
162    }
163}