use std::io;
use serde::Serialize;
use serde_json::Value;
pub(super) enum BoundedJsonValue {
Value(Value),
TooLarge,
}
pub(super) fn to_bounded_json_value<T>(
value: &T,
max_bytes: usize,
) -> Result<BoundedJsonValue, serde_json::Error>
where
T: Serialize + ?Sized,
{
let mut writer = LimitedVecWriter {
bytes: Vec::with_capacity(max_bytes.min(1024)),
max_bytes,
limit_exceeded: false,
};
if let Err(error) = serde_json::to_writer(&mut writer, value) {
return if writer.limit_exceeded {
Ok(BoundedJsonValue::TooLarge)
} else {
Err(error)
};
}
serde_json::from_slice(&writer.bytes).map(BoundedJsonValue::Value)
}
struct LimitedVecWriter {
bytes: Vec<u8>,
max_bytes: usize,
limit_exceeded: bool,
}
impl io::Write for LimitedVecWriter {
fn write(&mut self, buffer: &[u8]) -> io::Result<usize> {
let Some(total) = self.bytes.len().checked_add(buffer.len()) else {
self.limit_exceeded = true;
return Err(io::Error::other("JSON 字节数溢出"));
};
if total > self.max_bytes {
self.limit_exceeded = true;
return Err(io::Error::other("JSON 超过字节限制"));
}
self.bytes.extend_from_slice(buffer);
Ok(buffer.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serialization_stops_at_the_configured_limit() {
let value = "x".repeat(1024);
assert!(matches!(
to_bounded_json_value(&value, 64).unwrap(),
BoundedJsonValue::TooLarge
));
}
#[test]
fn serialization_preserves_json_types() {
let value = serde_json::json!({ "count": 2, "enabled": true });
let BoundedJsonValue::Value(serialized) = to_bounded_json_value(&value, 1024).unwrap()
else {
panic!("小型 JSON 不应触发容量限制");
};
assert_eq!(serialized, value);
}
}