branch error filtering

src/lib.rs

@@ -91,13 +91,16 @@ fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
       match cache.schemas.validate(&instance_value, *sch_index) {
         Ok(_) => JsonB(json!({ "success": true })),
         Err(validation_error) => {
-          // Directly use the result of format_validation_error
-          // which now includes the top-level success indicator and flat error list
-          let mut error_list = Vec::new();
-          collect_leaf_errors(&validation_error, &mut error_list);
+          // Collect all leaf errors first
+          let mut raw_error_list = Vec::new();
+          collect_leaf_errors(&validation_error, &mut raw_error_list);
+
+          // Filter the errors (e.g., deduplicate by instance_path)
+          let filtered_error_list = filter_boon_errors(raw_error_list);
+
           JsonB(json!({
             "success": false,
-            "error": error_list // Flat list of specific errors
+            "error": filtered_error_list // Return the filtered list
           }))
         }
       }
@@ -127,6 +130,31 @@ fn collect_leaf_errors(error: &ValidationError, errors_list: &mut Vec<Value>) {
   }
 }
 
+// Filters collected errors, e.g., deduplicating by instance_path
+fn filter_boon_errors(raw_errors: Vec<Value>) -> Vec<Value> {
+    use std::collections::HashMap;
+    use std::collections::hash_map::Entry;
+
+    // Use a HashMap to keep only the first error for each instance_path
+    let mut unique_errors: HashMap<String, Value> = HashMap::new();
+
+    for error_value in raw_errors {
+        if let Some(instance_path_value) = error_value.get("instance_path") {
+            if let Some(instance_path_str) = instance_path_value.as_str() {
+                // Use Entry API to insert only if the key is not present
+                if let Entry::Vacant(entry) = unique_errors.entry(instance_path_str.to_string()) {
+                    entry.insert(error_value);
+                }
+            }
+        }
+        // If error doesn't have instance_path or it's not a string, we might ignore it or handle differently.
+        // For now, we implicitly ignore errors without a valid string instance_path for deduplication.
+    }
+
+    // Collect the unique errors from the map values
+    unique_errors.into_values().collect()
+}
+
 #[pg_extern(strict, parallel_safe)]
 fn json_schema_cached(schema_id: &str) -> bool {
   let cache = SCHEMA_CACHE.read().unwrap();