castrum 0.9.2 → 0.9.4

package/rust/json/json_ops.rs

@@ -0,0 +1,121 @@
+// rust/json/json_ops.rs — zero-DOM JSON validation/sum + DOM parse.
+//
+// `json_valid_bytes` / `json_sum_ids_bytes` operate on raw bytes with no
+// per-key heap `String` DOM; `json_parse` materializes a `serde_json::Value`
+// when a caller needs the full DOM. Heavily inlined for the hot paths.
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use serde::de::{Deserializer, IgnoredAny, SeqAccess, Visitor};
+use serde::Deserialize;
+use std::fmt;
+
+#[derive(Deserialize)]
+struct IdRow {
+    #[serde(default)]
+    id: Option<i64>,
+}
+
+struct IdSumVisitor;
+
+impl<'de> Visitor<'de> for IdSumVisitor {
+    type Value = i64;
+
+    #[inline]
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("an array of objects with numeric ids")
+    }
+
+    #[inline]
+    fn visit_seq<A: SeqAccess<'de>>(
+        self,
+        mut seq: A,
+    ) -> std::result::Result<Self::Value, A::Error> {
+        let mut sum = 0i64;
+        while let Some(row) = seq.next_element::<Option<IdRow>>()? {
+            if let Some(IdRow { id: Some(id) }) = row {
+                sum = sum.saturating_add(id);
+            }
+        }
+        Ok(sum)
+    }
+}
+
+struct IdSum(i64);
+
+impl<'de> Deserialize<'de> for IdSum {
+    #[inline]
+    fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
+        d.deserialize_seq(IdSumVisitor).map(IdSum)
+    }
+}
+
+#[inline(always)]
+pub fn json_valid_bytes(input: &[u8]) -> bool {
+    // sonic-rs uses SIMD validation internally — already optimal.
+    sonic_rs::from_slice::<IgnoredAny>(input).is_ok()
+}
+
+#[inline]
+pub fn json_sum_ids_bytes(input: &[u8]) -> Result<i64> {
+    sonic_rs::from_slice::<IdSum>(input)
+        .map(|s| s.0)
+        .map_err(|e| Error::from_reason(e.to_string()))
+}
+
+#[napi]
+pub fn json_valid(input: Uint8Array) -> bool {
+    json_valid_bytes(input.as_ref())
+}
+
+/// Parse JSON into a JS value (sonic-rs → compact `sonic_rs::Value` → hand
+/// written napi marshal). This replaces the old `serde_json::Value` DOM +
+/// generic napi `serde-json` marshal — the sonic Value build is cheaper (no
+/// per-key heap `String`) and the walker avoids serde trait dispatch. Number
+/// marshaling stays byte-parity with the old path (PosInt → BigInt, NegInt/
+/// Float → Number).
+///
+/// This is the "parse to a usable JS object" path — directly comparable to
+/// `JSON.parse`. Throws on invalid JSON. Note: napi marshaling of the DOM has
+/// real cost, so this is intentionally NOT a zero-copy / validation-only path.
+#[napi]
+pub fn json_parse(env: Env, input: Uint8Array) -> Result<Unknown<'static>> {
+    let value: sonic_rs::Value = sonic_rs::from_slice(input.as_ref())
+        .map_err(|e| Error::from_reason(format!("JSON parse error: {e}")))?;
+    crate::json::napi_marshal::sonic_value_to_js(&env, &value)
+}
+
+#[napi]
+pub fn json_sum_ids(input: Uint8Array) -> Result<i64> {
+    json_sum_ids_bytes(input.as_ref())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn json_parse_roundtrip() {
+        let v =
+            sonic_rs::from_slice::<serde_json::Value>(br#"{"a":1,"b":[true,null,"x"]}"#).unwrap();
+        assert_eq!(v["a"], 1);
+        assert_eq!(v["b"][0], true);
+        assert_eq!(v["b"][2], "x");
+    }
+
+    #[test]
+    fn json_parse_rejects_invalid() {
+        assert!(sonic_rs::from_slice::<serde_json::Value>(b"{not json").is_err());
+        assert!(sonic_rs::from_slice::<serde_json::Value>(b"").is_err());
+    }
+
+    #[test]
+    fn json_valid_matches_parse() {
+        let good = br#"{"id":1,"name":"x"}"#;
+        assert!(json_valid_bytes(good));
+        assert!(sonic_rs::from_slice::<serde_json::Value>(good).is_ok());
+        let bad = b"nope";
+        assert!(!json_valid_bytes(bad));
+        assert!(sonic_rs::from_slice::<serde_json::Value>(bad).is_err());
+    }
+}