Skip to main content

lenso_process_protocol/
strict_json.rs

1use std::collections::HashSet;
2
3use serde::{Deserialize, Serialize, de::DeserializeOwned};
4
5use super::ProtocolError;
6
7/// Decodes strict JSON, rejecting duplicate object keys before typed decoding.
8pub fn decode_strict<T: DeserializeOwned>(wire: &[u8]) -> Result<T, ProtocolError> {
9    serde_json::from_slice::<StrictValue>(wire)
10        .map_err(|error| ProtocolError::new(format!("invalid strict JSON: {error}")))?;
11    serde_json::from_slice(wire)
12        .map_err(|error| ProtocolError::new(format!("invalid protocol document: {error}")))
13}
14
15/// Encodes an already validated protocol document as compact JSON.
16pub fn encode_compact<T: Serialize>(value: &T) -> Result<Vec<u8>, ProtocolError> {
17    serde_json::to_vec(value)
18        .map_err(|error| ProtocolError::new(format!("cannot encode protocol document: {error}")))
19}
20
21#[derive(Clone, Debug)]
22struct StrictValue;
23
24impl<'de> Deserialize<'de> for StrictValue {
25    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
26    where
27        D: serde::Deserializer<'de>,
28    {
29        deserializer.deserialize_any(StrictValueVisitor)
30    }
31}
32
33struct StrictValueVisitor;
34
35impl<'de> serde::de::Visitor<'de> for StrictValueVisitor {
36    type Value = StrictValue;
37
38    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
39        formatter.write_str("strict JSON without duplicate object keys")
40    }
41
42    fn visit_bool<E>(self, _value: bool) -> Result<Self::Value, E> {
43        Ok(StrictValue)
44    }
45    fn visit_i64<E>(self, _value: i64) -> Result<Self::Value, E> {
46        Ok(StrictValue)
47    }
48    fn visit_u64<E>(self, _value: u64) -> Result<Self::Value, E> {
49        Ok(StrictValue)
50    }
51    fn visit_f64<E>(self, _value: f64) -> Result<Self::Value, E> {
52        Ok(StrictValue)
53    }
54    fn visit_str<E>(self, _value: &str) -> Result<Self::Value, E> {
55        Ok(StrictValue)
56    }
57    fn visit_string<E>(self, _value: String) -> Result<Self::Value, E> {
58        Ok(StrictValue)
59    }
60    fn visit_none<E>(self) -> Result<Self::Value, E> {
61        Ok(StrictValue)
62    }
63    fn visit_unit<E>(self) -> Result<Self::Value, E> {
64        Ok(StrictValue)
65    }
66
67    fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
68    where
69        A: serde::de::SeqAccess<'de>,
70    {
71        while sequence.next_element::<StrictValue>()?.is_some() {}
72        Ok(StrictValue)
73    }
74
75    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
76    where
77        A: serde::de::MapAccess<'de>,
78    {
79        let mut keys = HashSet::new();
80        while let Some(key) = map.next_key::<String>()? {
81            if !keys.insert(key.clone()) {
82                return Err(serde::de::Error::custom(format!(
83                    "duplicate object key {key:?}"
84                )));
85            }
86            map.next_value::<StrictValue>()?;
87        }
88        Ok(StrictValue)
89    }
90}