chore: publish clean community baseline

crates/crank-runtime/src/redaction.rs

@@ -0,0 +1,124 @@
+use serde_json::Value;
+
+pub fn redact_paths(value: &mut Value, paths: &[String]) {
+    for path in paths {
+        let segments = parse_path(path);
+        if segments.is_empty() {
+            continue;
+        }
+
+        redact_path(value, &segments);
+    }
+}
+
+pub fn truncate_item_fields(value: &mut Value, max_len: usize) {
+    match value {
+        Value::String(text) => {
+            if text != "[REDACTED]" && text.chars().count() > max_len {
+                let truncated = text.chars().take(max_len).collect::<String>();
+                *text = format!("{truncated}...");
+            }
+        }
+        Value::Array(items) => {
+            for item in items {
+                truncate_item_fields(item, max_len);
+            }
+        }
+        Value::Object(map) => {
+            for value in map.values_mut() {
+                truncate_item_fields(value, max_len);
+            }
+        }
+        Value::Null | Value::Bool(_) | Value::Number(_) => {}
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum PathSegment {
+    Field(String),
+    Wildcard,
+}
+
+fn parse_path(path: &str) -> Vec<PathSegment> {
+    let path = path.strip_prefix("$.").or_else(|| path.strip_prefix('$'));
+    let Some(path) = path else {
+        return Vec::new();
+    };
+
+    path.split('.')
+        .flat_map(|segment| {
+            if let Some(field) = segment.strip_suffix("[*]") {
+                vec![PathSegment::Field(field.to_owned()), PathSegment::Wildcard]
+            } else if segment == "*" {
+                vec![PathSegment::Wildcard]
+            } else {
+                vec![PathSegment::Field(segment.to_owned())]
+            }
+        })
+        .collect()
+}
+
+fn redact_path(value: &mut Value, segments: &[PathSegment]) {
+    let Some((current, rest)) = segments.split_first() else {
+        *value = Value::String("[REDACTED]".to_owned());
+        return;
+    };
+
+    match current {
+        PathSegment::Field(field) => {
+            if let Some(next) = value
+                .as_object_mut()
+                .and_then(|object| object.get_mut(field))
+            {
+                redact_path(next, rest);
+            }
+        }
+        PathSegment::Wildcard => {
+            if let Some(items) = value.as_array_mut() {
+                for item in items {
+                    redact_path(item, rest);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::{redact_paths, truncate_item_fields};
+
+    #[test]
+    fn redacts_simple_and_wildcard_paths() {
+        let mut value = json!({
+            "summary": { "token": "secret" },
+            "items": [
+                { "token": "a", "message": "keep" },
+                { "token": "b", "message": "keep" }
+            ]
+        });
+
+        redact_paths(
+            &mut value,
+            &["$.summary.token".to_owned(), "$.items[*].token".to_owned()],
+        );
+
+        assert_eq!(value["summary"]["token"], json!("[REDACTED]"));
+        assert_eq!(value["items"][0]["token"], json!("[REDACTED]"));
+        assert_eq!(value["items"][1]["token"], json!("[REDACTED]"));
+    }
+
+    #[test]
+    fn truncates_long_strings_recursively() {
+        let mut value = json!({
+            "message": "abcdefghijklmnop",
+            "nested": [{ "message": "qrstuvwxyz" }]
+        });
+
+        truncate_item_fields(&mut value, 4);
+
+        assert_eq!(value["message"], json!("abcd..."));
+        assert_eq!(value["nested"][0]["message"], json!("qrst..."));
+    }
+}