json_eval_rs/jsoneval/

cache.rs

use super::JSONEval;
use crate::jsoneval::eval_cache::{CacheKey, CacheStats};
use crate::jsoneval::eval_data::EvalData;
use crate::jsoneval::path_utils;


use indexmap::IndexSet;
use serde_json::Value;

impl JSONEval {
    /// Check if a dependency should be part of the cache key
    /// Check if a dependency should be cached
    /// Caches everything except keys starting with $ (except $context)
    #[inline]
    pub fn should_cache_dependency(&self, key: &str) -> bool {
        if key.starts_with("/$") || key.starts_with('$') {
            // Only cache $context, exclude other $ keys like $params
            key.starts_with("$context.") || key.starts_with("/$context") || key.starts_with("$context/")
                || key.starts_with("$params.") || key.starts_with("/$params") || key.starts_with("$params/")
        } else {
            true
        }
    }

    /// Try to get a result from cache
    /// Helper: Try to get cached result for an evaluation (thread-safe)
    /// Try to get a value from cache if it exists and dependencies match
    pub(crate) fn try_get_cached(
        &self,
        eval_key: &str,
        eval_data_snapshot: &EvalData,
        missed_keys: &dashmap::DashSet<String>,
    ) -> Option<Value> {
        // Skip cache lookup if caching is disabled
        if !self.cache_enabled {
            return None;
        }

        // Get dependencies for this evaluation
        let deps = self.dependencies.get(eval_key)?;

        // If no dependencies, use simple cache key
        let cache_key = if deps.is_empty() {
            CacheKey::simple(eval_key.to_string())
        } else {
            // If any dependency missed the cache in this batch, force a cache miss
            // This prevents false cache hits when large data arrays are intentionally skipped in hashes
            if deps.iter().any(|dep| missed_keys.contains(dep)) {
                return None;
            }

            // Filter dependencies (exclude $ keys except $context)
            let filtered_deps: IndexSet<String> = deps
                .iter()
                .filter(|dep_key| self.should_cache_dependency(dep_key) && dep_key.as_str() != path_utils::normalize_to_json_pointer(eval_key))
                .cloned()
                .collect();

            // Collect dependency values
            let dep_values: Vec<(String, &Value)> = filtered_deps
                .iter()
                .filter_map(|dep_key| {
                    eval_data_snapshot.get(dep_key).and_then(|v| {
                        // Skip large arrays that contain no actionable schema keys
                        // to avoid hashing large amounts of pure data
                        if let Value::Array(arr) = v {
                            if arr.len() > 10 && !crate::parse_schema::common::has_actionable_keys(v) {
                                return None;
                            }
                        }
                        Some((dep_key.clone(), v))
                    })
                })
                .collect();

            CacheKey::new(eval_key.to_string(), &filtered_deps, &dep_values)            
        };

        // Try cache lookup (zero-copy via Arc, thread-safe)
        self.eval_cache
            .get(&cache_key)
            .map(|arc_val| (*arc_val).clone())
    }

    /// Cache a result
    /// Helper: Store evaluation result in cache (thread-safe)
    pub(crate) fn cache_result(
        &self,
        eval_key: &str,
        value: Value,
        eval_data_snapshot: &EvalData,
    ) {
        // Skip cache insertion if caching is disabled
        if !self.cache_enabled {
            return;
        }

        // Get dependencies for this evaluation
        let deps = match self.dependencies.get(eval_key) {
            Some(d) => d,
            None => {
                // No dependencies - use simple cache key
                let cache_key = CacheKey::simple(eval_key.to_string());
                self.eval_cache.insert(cache_key, value);
                return;
            }
        };

        // Filter and collect dependency values (exclude $ keys except $context)
        let filtered_deps: IndexSet<String> = deps
            .iter()
            .filter(|dep_key| self.should_cache_dependency(dep_key) && dep_key.as_str() != path_utils::normalize_to_json_pointer(eval_key))
            .cloned()
            .collect();

        let dep_values: Vec<(String, &Value)> = filtered_deps
            .iter()
            .filter_map(|dep_key| {
                eval_data_snapshot.get(dep_key).and_then(|v| {
                    if let Value::Array(arr) = v {
                        if arr.len() > 10 && !crate::parse_schema::common::has_actionable_keys(v) {
                            return None;
                        }
                    }
                    Some((dep_key.clone(), v))
                })
            })
            .collect();

        let cache_key = CacheKey::new(eval_key.to_string(), &filtered_deps, &dep_values);
        
        self.eval_cache.insert(cache_key, value);

    }

    /// Purge cache entries affected by changed data paths, comparing old and new values
    /// Selectively purge cache entries that depend on changed data paths
    /// Only removes cache entries whose dependencies intersect with changed_paths
    /// Recursively find all paths where the values differ
    fn compute_changed_paths(old: &Value, new: &Value, current_path: String, changed: &mut Vec<String>) {
        if old == new {
            return;
        }

        match (old, new) {
            (Value::Object(o1), Value::Object(o2)) => {
                for (k, v2) in o2 {
                    if let Some(v1) = o1.get(k) {
                        if v1 != v2 {
                            let path = format!("{}/{}", current_path, k);
                            Self::compute_changed_paths(v1, v2, path, changed);
                        }
                    } else {
                        let path = format!("{}/{}", current_path, k);
                        changed.push(path);
                    }
                }
                for k in o1.keys() {
                    if !o2.contains_key(k) {
                        let path = format!("{}/{}", current_path, k);
                        changed.push(path);
                    }
                }
            }
            (Value::Array(a1), Value::Array(a2)) if a1.len() == a2.len() => {
                for (i, (v1, v2)) in a1.iter().zip(a2.iter()).enumerate() {
                    if v1 != v2 {
                        let path = format!("{}/{}", current_path, i);
                        Self::compute_changed_paths(v1, v2, path, changed);
                    }
                }
            }
            _ => {
                if current_path.is_empty() {
                    changed.push("/".to_string());
                } else {
                    changed.push(current_path);
                }
            }
        }
    }

    /// Compares old vs new values by deep diffing and purges affected entries
    pub fn purge_cache_for_changed_data_with_comparison(
        &self,
        old_data: &Value,
        new_data: &Value,
    ) {
        let mut actually_changed_paths = Vec::new();
        Self::compute_changed_paths(old_data, new_data, "".to_string(), &mut actually_changed_paths);

        // If no values actually changed, no need to purge
        if actually_changed_paths.is_empty() {
            return;
        }

        // Find all eval_keys that depend on the actually changed data paths
        let mut affected_eval_keys = IndexSet::new();

        for (eval_key, deps) in self.dependencies.iter() {
            // Check if this evaluation depends on any of the changed paths
            let is_affected = deps.iter().any(|dep| {
                // Check if the dependency matches any changed path
                actually_changed_paths.iter().any(|changed_path| {
                    // Exact match or prefix match (for nested fields)
                    dep == changed_path
                        || dep.starts_with(&format!("{}/", changed_path))
                        || changed_path.starts_with(&format!("{}/", dep))
                })
            });

            if is_affected {
                affected_eval_keys.insert(eval_key.clone());
            }
        }

        // Remove all cache entries for affected eval_keys using retain
        // Keep entries whose eval_key is NOT in the affected set
        self.eval_cache
            .retain(|cache_key, _| !affected_eval_keys.contains(&cache_key.eval_key));
    }

    /// Selectively purge cache entries that depend on changed data paths
    /// Finds all eval_keys that depend on the changed paths and removes them
    /// Selectively purge cache entries that depend on changed data paths
    /// Simpler version without value comparison for cases where we don't have old data
    pub fn purge_cache_for_changed_data(&self, changed_data_paths: &[String]) {
        if changed_data_paths.is_empty() {
            return;
        }

        // Find all eval_keys that depend on the changed paths
        let mut affected_eval_keys = IndexSet::new();

        for (eval_key, deps) in self.dependencies.iter() {
            // Check if this evaluation depends on any of the changed paths
            let is_affected = deps.iter().any(|dep| {
                // Check if dependency path matches any changed data path using flexible matching
                changed_data_paths.iter().any(|changed_for_purge| {
                    // Check both directions:
                    // 1. Dependency matches changed data (dependency is child of change)
                    // 2. Changed data matches dependency (change is child of dependency)
                    Self::paths_match_flexible(dep, changed_for_purge)
                        || Self::paths_match_flexible(changed_for_purge, dep)
                })
            });

            if is_affected {
                affected_eval_keys.insert(eval_key.clone());
            }
        }

        // Remove all cache entries for affected eval_keys using retain
        // Keep entries whose eval_key is NOT in the affected set
        self.eval_cache
            .retain(|cache_key, _| !affected_eval_keys.contains(&cache_key.eval_key));
    }

    /// Flexible path matching that handles structural schema keywords (e.g. properties, oneOf)
    /// Returns true if schema_path structurally matches data_path
    fn paths_match_flexible(schema_path: &str, data_path: &str) -> bool {
        let s_segs: Vec<&str> = schema_path
            .trim_start_matches('#')
            .trim_start_matches('/')
            .split('/')
            .filter(|s| !s.is_empty())
            .collect();
        let d_segs: Vec<&str> = data_path
            .trim_start_matches('/')
            .split('/')
            .filter(|s| !s.is_empty())
            .collect();

        let mut d_idx = 0;

        for s_seg in s_segs {
            // If we matched all data segments, we are good (schema is deeper/parent)
            if d_idx >= d_segs.len() {
                return true;
            }

            let d_seg = d_segs[d_idx];

            if s_seg == d_seg {
                // Exact match, advance data pointer
                d_idx += 1;
            } else if s_seg == "items"
                || s_seg == "additionalProperties"
                || s_seg == "patternProperties"
            {
                // Wildcard match for arrays/maps - consume data segment if it looks valid
                // Note: items matches array index (numeric). additionalProperties matches any key.
                if s_seg == "items" {
                    // Only match if data segment is numeric (array index)
                    if d_seg.chars().all(|c| c.is_ascii_digit()) {
                        d_idx += 1;
                    }
                } else {
                    // additionalProperties/patternProperties matches any string key
                    d_idx += 1;
                }
            } else if Self::is_structural_keyword(s_seg)
                || s_seg.chars().all(|c| c.is_ascii_digit())
            {
                // Skip structural keywords (properties, oneOf, etc) and numeric indices in schema (e.g. oneOf/0)
                continue;
            } else {
                // Mismatch: schema has a named segment that data doesn't have
                return false;
            }
        }

        // Return true if we consumed all data segments
        true
    }
    
    /// Purge cache entries affected by context changes
    /// Purge cache entries that depend on context
    pub fn purge_cache_for_context_change(&self) {
        // Find all eval_keys that depend on $context
        let mut affected_eval_keys = IndexSet::new();

        for (eval_key, deps) in self.dependencies.iter() {
            let is_affected = deps.iter().any(|dep| {
                dep == "$context" || dep.starts_with("$context.") || dep.starts_with("/$context")
            });

            if is_affected {
                affected_eval_keys.insert(eval_key.clone());
            }
        }

        self.eval_cache
            .retain(|cache_key, _| !affected_eval_keys.contains(&cache_key.eval_key));
    }

    /// Get cache statistics
    pub fn cache_stats(&self) -> CacheStats {
        self.eval_cache.stats()
    }

    /// Clear the cache manually
    pub fn clear_cache(&self) {
        self.eval_cache.clear();
    }

    /// Enable caching
    pub fn enable_cache(&mut self) {
        self.cache_enabled = true;
        for subform in self.subforms.values_mut() {
            subform.enable_cache();
        }
    }

    /// Disable caching
    pub fn disable_cache(&mut self) {
        self.cache_enabled = false;
        self.eval_cache.clear();
        for subform in self.subforms.values_mut() {
            subform.disable_cache();
        }
    }
    
    /// Check if cache is enabled
    pub fn is_cache_enabled(&self) -> bool {
        self.cache_enabled
    }

    /// Helper to check if a key is a structural JSON Schema keyword
    /// Helper to check if a key is a structural JSON Schema keyword
    fn is_structural_keyword(key: &str) -> bool {
        matches!(
            key,
            "properties"
                | "definitions"
                | "$defs"
                | "allOf"
                | "anyOf"
                | "oneOf"
                | "not"
                | "if"
                | "then"
                | "else"
                | "dependentSchemas"
                | "$params"
                | "dependencies"
        )
    }
    
    /// Get cache size
    pub fn cache_len(&self) -> usize {
        self.eval_cache.len()
    }
}