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