async_graphql_value/
value_serde.rs

1use std::fmt::{self, Formatter};
2
3use indexmap::IndexMap;
4use serde::{
5    Deserialize, Deserializer, Serialize, Serializer,
6    de::{Error as DeError, MapAccess, SeqAccess, Visitor},
7    ser::SerializeMap,
8};
9
10use crate::{ConstValue, Name, Number, Value};
11
12/// The token used by `serde_json` to represent raw values.
13///
14/// It should be kept in sync with the following original until made public:
15/// https://github.com/serde-rs/json/blob/b48b9a3a0c09952579e98c8940fe0d1ee4aae588/src/raw.rs#L292
16#[cfg(feature = "raw_value")]
17pub const RAW_VALUE_TOKEN: &str = "$serde_json::private::RawValue";
18
19impl Serialize for ConstValue {
20    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
21        match self {
22            ConstValue::Null => serializer.serialize_none(),
23            ConstValue::Number(v) => v.serialize(serializer),
24            ConstValue::String(v) => serializer.serialize_str(v),
25            ConstValue::Boolean(v) => serializer.serialize_bool(*v),
26            ConstValue::Binary(v) => serializer.serialize_bytes(v),
27            ConstValue::Enum(v) => serializer.serialize_str(v),
28            ConstValue::List(v) => v.serialize(serializer),
29            ConstValue::Object(v) => {
30                #[cfg(feature = "raw_value")]
31                if v.len() == 1
32                    && let Some(ConstValue::String(v)) = v.get(RAW_VALUE_TOKEN)
33                    && let Ok(v) = serde_json::value::RawValue::from_string(v.clone())
34                {
35                    return v.serialize(serializer);
36                }
37                v.serialize(serializer)
38            }
39        }
40    }
41}
42
43impl<'de> Deserialize<'de> for ConstValue {
44    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
45        struct ValueVisitor;
46
47        impl<'de> Visitor<'de> for ValueVisitor {
48            type Value = ConstValue;
49
50            #[inline]
51            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
52                formatter.write_str("any valid value")
53            }
54
55            #[inline]
56            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
57            where
58                E: DeError,
59            {
60                Ok(ConstValue::Boolean(v))
61            }
62
63            #[inline]
64            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
65            where
66                E: DeError,
67            {
68                Ok(ConstValue::Number(v.into()))
69            }
70
71            #[inline]
72            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
73            where
74                E: DeError,
75            {
76                Ok(ConstValue::Number(v.into()))
77            }
78
79            #[inline]
80            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
81            where
82                E: DeError,
83            {
84                Ok(Number::from_f64(v).map_or(ConstValue::Null, ConstValue::Number))
85            }
86
87            #[inline]
88            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
89            where
90                E: DeError,
91            {
92                Ok(ConstValue::String(v.to_string()))
93            }
94
95            #[inline]
96            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
97            where
98                E: DeError,
99            {
100                Ok(ConstValue::String(v))
101            }
102
103            #[inline]
104            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
105            where
106                E: DeError,
107            {
108                Ok(ConstValue::Binary(v.to_vec().into()))
109            }
110
111            #[inline]
112            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
113            where
114                E: DeError,
115            {
116                Ok(ConstValue::Binary(v.into()))
117            }
118
119            #[inline]
120            fn visit_none<E>(self) -> Result<Self::Value, E>
121            where
122                E: DeError,
123            {
124                Ok(ConstValue::Null)
125            }
126
127            #[inline]
128            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
129            where
130                D: Deserializer<'de>,
131            {
132                Deserialize::deserialize(deserializer)
133            }
134
135            #[inline]
136            fn visit_unit<E>(self) -> Result<Self::Value, E>
137            where
138                E: DeError,
139            {
140                Ok(ConstValue::Null)
141            }
142
143            fn visit_seq<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
144            where
145                A: SeqAccess<'de>,
146            {
147                let mut vec = Vec::new();
148                while let Some(elem) = visitor.next_element()? {
149                    vec.push(elem);
150                }
151                Ok(ConstValue::List(vec))
152            }
153
154            fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
155            where
156                A: MapAccess<'de>,
157            {
158                let mut map = IndexMap::new();
159                while let Some((name, value)) = visitor.next_entry()? {
160                    map.insert(name, value);
161                }
162                Ok(ConstValue::Object(map))
163            }
164        }
165
166        deserializer.deserialize_any(ValueVisitor)
167    }
168}
169
170#[derive(Debug)]
171struct SerdeVariable(Name);
172
173impl Serialize for SerdeVariable {
174    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
175        let mut s = serializer.serialize_map(Some(1))?;
176        s.serialize_entry("$var", &self.0)?;
177        s.end()
178    }
179}
180
181impl Serialize for Value {
182    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
183        match self {
184            Value::Variable(name) => SerdeVariable(name.clone()).serialize(serializer),
185            Value::Null => serializer.serialize_none(),
186            Value::Number(v) => v.serialize(serializer),
187            Value::String(v) => serializer.serialize_str(v),
188            Value::Boolean(v) => serializer.serialize_bool(*v),
189            Value::Binary(v) => serializer.serialize_bytes(v),
190            Value::Enum(v) => serializer.serialize_str(v),
191            Value::List(v) => v.serialize(serializer),
192            Value::Object(v) => v.serialize(serializer),
193        }
194    }
195}
196
197impl<'de> Deserialize<'de> for Value {
198    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
199        struct ValueVisitor;
200
201        impl<'de> Visitor<'de> for ValueVisitor {
202            type Value = Value;
203
204            #[inline]
205            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
206                formatter.write_str("any valid value")
207            }
208
209            #[inline]
210            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
211            where
212                E: DeError,
213            {
214                Ok(Value::Boolean(v))
215            }
216
217            #[inline]
218            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
219            where
220                E: DeError,
221            {
222                Ok(Value::Number(v.into()))
223            }
224
225            #[inline]
226            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
227            where
228                E: DeError,
229            {
230                Ok(Value::Number(v.into()))
231            }
232
233            #[inline]
234            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
235            where
236                E: DeError,
237            {
238                Ok(Number::from_f64(v).map_or(Value::Null, Value::Number))
239            }
240
241            #[inline]
242            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
243            where
244                E: DeError,
245            {
246                Ok(Value::String(v.to_string()))
247            }
248
249            #[inline]
250            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
251            where
252                E: DeError,
253            {
254                Ok(Value::String(v))
255            }
256
257            #[inline]
258            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
259            where
260                E: DeError,
261            {
262                Ok(Value::Binary(v.to_vec().into()))
263            }
264
265            #[inline]
266            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
267            where
268                E: DeError,
269            {
270                Ok(Value::Binary(v.into()))
271            }
272
273            #[inline]
274            fn visit_none<E>(self) -> Result<Self::Value, E>
275            where
276                E: DeError,
277            {
278                Ok(Value::Null)
279            }
280
281            #[inline]
282            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
283            where
284                D: Deserializer<'de>,
285            {
286                Deserialize::deserialize(deserializer)
287            }
288
289            #[inline]
290            fn visit_unit<E>(self) -> Result<Self::Value, E>
291            where
292                E: DeError,
293            {
294                Ok(Value::Null)
295            }
296
297            fn visit_seq<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
298            where
299                A: SeqAccess<'de>,
300            {
301                let mut vec = Vec::new();
302                while let Some(elem) = visitor.next_element()? {
303                    vec.push(elem);
304                }
305                Ok(Value::List(vec))
306            }
307
308            fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
309            where
310                A: MapAccess<'de>,
311            {
312                let mut map = IndexMap::new();
313                while let Some((name, value)) = visitor.next_entry()? {
314                    match &value {
315                        Value::String(value) if name == "$var" => {
316                            return Ok(Value::Variable(Name::new(value)));
317                        }
318                        _ => {
319                            map.insert(name, value);
320                        }
321                    }
322                }
323                Ok(Value::Object(map))
324            }
325        }
326
327        deserializer.deserialize_any(ValueVisitor)
328    }
329}
330
331#[cfg(test)]
332mod tests {
333    use super::*;
334
335    #[test]
336    fn var_serde() {
337        let var = Value::Variable(Name::new("abc"));
338        let s = serde_json::to_string(&var).unwrap();
339        assert_eq!(s, r#"{"$var":"abc"}"#);
340        assert_eq!(var, serde_json::from_str(&s).unwrap());
341    }
342}
async_graphql_value/value_serde.rs

async_graphql_value/
value_serde.rs
