Skip to main content

yaiko_core/
serialize.rs

1//! Deterministic JSON serialization facade.
2use serde_json::Value;
3#[derive(Debug, Clone, PartialEq, Eq)]
4pub enum SerializeError {
5    TooLarge,
6    InvalidValue,
7    Serialization,
8}
9#[derive(Debug, Clone)]
10pub struct Serializer {
11    max_bytes: usize,
12}
13impl Serializer {
14    pub fn new(max_bytes: usize) -> Self {
15        Self { max_bytes }
16    }
17    pub fn render(&self, value: &Value) -> Result<Vec<u8>, SerializeError> {
18        if contains_invalid(value) {
19            return Err(SerializeError::InvalidValue);
20        }
21        let bytes = serde_json::to_vec(value).map_err(|_| SerializeError::Serialization)?;
22        if bytes.len() > self.max_bytes {
23            Err(SerializeError::TooLarge)
24        } else {
25            Ok(bytes)
26        }
27    }
28    pub fn render_string(&self, value: &Value) -> Result<String, SerializeError> {
29        String::from_utf8(self.render(value)?).map_err(|_| SerializeError::Serialization)
30    }
31}
32fn contains_invalid(value: &Value) -> bool {
33    match value {
34        Value::Number(n) => n.as_f64().is_some_and(|x| !x.is_finite()),
35        Value::Array(a) => a.iter().any(contains_invalid),
36        Value::Object(o) => o.values().any(contains_invalid),
37        _ => false,
38    }
39}
40#[cfg(test)]
41mod tests {
42    use super::*;
43    use serde_json::json;
44    #[test]
45    fn renders_stable_json_and_escapes_values() {
46        let s = Serializer::new(128);
47        assert_eq!(
48            s.render_string(&json!({"z":1,"a":"<&"})).unwrap(),
49            r#"{"a":"<&","z":1}"#
50        )
51    }
52    #[test]
53    fn enforces_output_bounds() {
54        assert_eq!(
55            Serializer::new(1).render(&json!({"x":1})),
56            Err(SerializeError::TooLarge)
57        );
58    }
59}