appstruct_runtime/
bigint.rs1use 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
34pub fn serialize<S: Serializer>(value: &i64, serializer: S) -> Result<S::Ok, S::Error> {
37 serializer.collect_str(value)
38}
39
40pub 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 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 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 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 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}