lenso_process_protocol/
strict_json.rs1use std::collections::HashSet;
2
3use serde::{Deserialize, Serialize, de::DeserializeOwned};
4
5use super::ProtocolError;
6
7pub const MAX_STRICT_JSON_NESTING: usize = 127;
12
13pub 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
20pub 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}