async_graphql_value/
value_serde.rs

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

async_graphql_value/
value_serde.rs
