@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/src/trigger.rs

@@ -1,390 +0,0 @@
-use crate::Operation;
-/// Trigger Engine module for event-driven execution
-///
-/// Triggers map operations to execution events based on:
-/// - Event type (e.g., OrderCreated when Order is inserted)
-/// - Optional filter conditions
-/// - Capability to execute
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-/// A trigger that maps operations to capability executions
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Trigger {
-    /// Unique trigger identifier
-    pub trigger_id: String,
-
-    /// Capability to execute when trigger fires
-    pub capability: String,
-
-    /// Event type this trigger listens for (e.g., "OrderCreated", "ItemUpdated")
-    pub event_type: String,
-
-    /// Collection this trigger applies to
-    pub collection: String,
-
-    /// Optional filter predicate (serialized as a JSON value)
-    /// Format: { "field": "total", "operator": ">", "value": 100 }
-    pub filter: Option<TriggerFilter>,
-
-    /// Whether this trigger is enabled
-    pub enabled: bool,
-}
-
-/// Filter condition for triggers
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TriggerFilter {
-    /// The field path to check (e.g., "total", "user.role")
-    pub field: String,
-
-    /// The operator to use ("==", "!=", ">", "<", ">=", "<=", "contains", "in")
-    pub operator: String,
-
-    /// The value to compare against
-    pub value: Value,
-}
-
-impl Trigger {
-    /// Create a new trigger without filter
-    pub fn new(
-        trigger_id: String,
-        capability: String,
-        event_type: String,
-        collection: String,
-    ) -> Self {
-        Self {
-            trigger_id,
-            capability,
-            event_type,
-            collection,
-            filter: None,
-            enabled: true,
-        }
-    }
-
-    /// Create a new trigger with filter
-    pub fn with_filter(
-        trigger_id: String,
-        capability: String,
-        event_type: String,
-        collection: String,
-        filter: TriggerFilter,
-    ) -> Self {
-        Self {
-            trigger_id,
-            capability,
-            event_type,
-            collection,
-            filter: Some(filter),
-            enabled: true,
-        }
-    }
-
-    /// Check if this trigger matches an operation
-    pub fn matches(&self, operation: &Operation) -> bool {
-        if !self.enabled {
-            return false;
-        }
-
-        // Check if collection matches
-        if operation.capability != self.collection {
-            return false;
-        }
-
-        // Check if event type matches (for now, we map operation type to event type)
-        // Insert -> event_type + "Created"
-        // Update -> event_type + "Updated"
-        // Delete -> event_type + "Deleted"
-        let expected_event = match operation.op_type {
-            crate::OperationType::Insert => {
-                format!("{}Created", capitalize_singular(&self.collection))
-            }
-            crate::OperationType::Update => {
-                format!("{}Updated", capitalize_singular(&self.collection))
-            }
-            crate::OperationType::Delete => {
-                format!("{}Deleted", capitalize_singular(&self.collection))
-            }
-        };
-
-        if expected_event != self.event_type {
-            return false;
-        }
-
-        // Check filter if present
-        if let Some(filter) = &self.filter {
-            if let Some(value) = &operation.value {
-                return filter.matches(value);
-            } else {
-                return false;
-            }
-        }
-
-        true
-    }
-}
-
-impl TriggerFilter {
-    /// Check if this filter matches a value
-    pub fn matches(&self, data: &Value) -> bool {
-        let field_value = get_nested_value(data, &self.field);
-
-        match field_value {
-            None => false,
-            Some(val) => match self.operator.as_str() {
-                "==" => val == self.value,
-                "!=" => val != self.value,
-                ">" => compare_numeric(&val, &self.value, |a, b| a > b),
-                "<" => compare_numeric(&val, &self.value, |a, b| a < b),
-                ">=" => compare_numeric(&val, &self.value, |a, b| a >= b),
-                "<=" => compare_numeric(&val, &self.value, |a, b| a <= b),
-                "contains" => {
-                    if let (Value::String(s), Value::String(needle)) = (val, &self.value) {
-                        s.contains(needle.as_str())
-                    } else {
-                        false
-                    }
-                }
-                "in" => {
-                    if let Value::Array(arr) = &self.value {
-                        arr.contains(&val)
-                    } else {
-                        false
-                    }
-                }
-                _ => false,
-            },
-        }
-    }
-}
-
-/// Trigger registry - manages all triggers
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct TriggerRegistry {
-    /// All triggers by trigger_id
-    triggers: std::collections::HashMap<String, Trigger>,
-
-    /// Triggers by collection
-    triggers_by_collection: std::collections::HashMap<String, Vec<String>>,
-
-    /// Triggers by event type
-    triggers_by_event: std::collections::HashMap<String, Vec<String>>,
-}
-
-impl TriggerRegistry {
-    /// Create a new trigger registry
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Register a new trigger
-    pub fn register(&mut self, trigger: Trigger) {
-        let trigger_id = trigger.trigger_id.clone();
-        let collection = trigger.collection.clone();
-        let event_type = trigger.event_type.clone();
-
-        self.triggers.insert(trigger_id.clone(), trigger);
-
-        self.triggers_by_collection
-            .entry(collection)
-            .or_insert_with(Vec::new)
-            .push(trigger_id.clone());
-
-        self.triggers_by_event
-            .entry(event_type)
-            .or_insert_with(Vec::new)
-            .push(trigger_id);
-    }
-
-    /// Unregister a trigger
-    pub fn unregister(&mut self, trigger_id: &str) -> Option<Trigger> {
-        if let Some(trigger) = self.triggers.remove(trigger_id) {
-            // Remove from indexes
-            if let Some(refs) = self.triggers_by_collection.get_mut(&trigger.collection) {
-                refs.retain(|id| id != trigger_id);
-            }
-            if let Some(refs) = self.triggers_by_event.get_mut(&trigger.event_type) {
-                refs.retain(|id| id != trigger_id);
-            }
-            Some(trigger)
-        } else {
-            None
-        }
-    }
-
-    /// Get triggers that match an operation
-    pub fn find_matching(&self, operation: &Operation) -> Vec<Trigger> {
-        self.triggers_by_collection
-            .get(&operation.capability)
-            .unwrap_or(&vec![])
-            .iter()
-            .filter_map(|id| self.triggers.get(id))
-            .filter(|trigger| trigger.matches(operation))
-            .cloned()
-            .collect()
-    }
-
-    /// Get a trigger by ID
-    pub fn get(&self, trigger_id: &str) -> Option<Trigger> {
-        self.triggers.get(trigger_id).cloned()
-    }
-
-    /// Get all triggers
-    pub fn all(&self) -> Vec<Trigger> {
-        self.triggers.values().cloned().collect()
-    }
-}
-
-// Helper functions
-
-fn capitalize_singular(s: &str) -> String {
-    // Convert "orders" -> "Order", "tasks" -> "Task"
-    if s.ends_with('s') {
-        let singular = &s[..s.len() - 1];
-        format!(
-            "{}{}",
-            singular.chars().next().unwrap().to_uppercase(),
-            &singular[1..]
-        )
-    } else {
-        format!("{}{}", s.chars().next().unwrap().to_uppercase(), &s[1..])
-    }
-}
-
-fn get_nested_value(obj: &Value, path: &str) -> Option<Value> {
-    let parts: Vec<&str> = path.split('.').collect();
-    let mut current = obj;
-
-    for part in parts {
-        current = &current[part];
-        if current.is_null() {
-            return None;
-        }
-    }
-
-    Some(current.clone())
-}
-
-fn compare_numeric<F>(a: &Value, b: &Value, cmp: F) -> bool
-where
-    F: Fn(f64, f64) -> bool,
-{
-    match (a.as_f64(), b.as_f64()) {
-        (Some(av), Some(bv)) => cmp(av, bv),
-        _ => false,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_trigger_creation() {
-        let trigger = Trigger::new(
-            "trigger-1".to_string(),
-            "process_order".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-        );
-
-        assert_eq!(trigger.trigger_id, "trigger-1");
-        assert_eq!(trigger.capability, "process_order");
-        assert_eq!(trigger.enabled, true);
-    }
-
-    #[test]
-    fn test_trigger_matching() {
-        let trigger = Trigger::new(
-            "trigger-1".to_string(),
-            "process_order".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-        );
-
-        let op = Operation::insert(
-            1,
-            "inst-a".to_string(),
-            1,
-            "orders:123".to_string(),
-            serde_json::json!({"total": 100}),
-            "Order".to_string(),
-            "orders".to_string(),
-        );
-
-        assert!(trigger.matches(&op));
-    }
-
-    #[test]
-    fn test_trigger_with_filter() {
-        let filter = TriggerFilter {
-            field: "total".to_string(),
-            operator: ">".to_string(),
-            value: serde_json::json!(100),
-        };
-
-        let trigger = Trigger::with_filter(
-            "trigger-1".to_string(),
-            "send_discount".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-            filter,
-        );
-
-        // Should match order with total > 100
-        let op1 = Operation::insert(
-            1,
-            "inst-a".to_string(),
-            1,
-            "orders:123".to_string(),
-            serde_json::json!({"total": 150}),
-            "Order".to_string(),
-            "orders".to_string(),
-        );
-        assert!(trigger.matches(&op1));
-
-        // Should not match order with total <= 100
-        let op2 = Operation::insert(
-            2,
-            "inst-a".to_string(),
-            2,
-            "orders:124".to_string(),
-            serde_json::json!({"total": 50}),
-            "Order".to_string(),
-            "orders".to_string(),
-        );
-        assert!(!trigger.matches(&op2));
-    }
-
-    #[test]
-    fn test_trigger_registry() {
-        let mut registry = TriggerRegistry::new();
-
-        let trigger1 = Trigger::new(
-            "trigger-1".to_string(),
-            "process_order".to_string(),
-            "OrderCreated".to_string(),
-            "orders".to_string(),
-        );
-
-        let trigger2 = Trigger::new(
-            "trigger-2".to_string(),
-            "send_notification".to_string(),
-            "OrderUpdated".to_string(),
-            "orders".to_string(),
-        );
-
-        registry.register(trigger1);
-        registry.register(trigger2);
-
-        assert_eq!(registry.all().len(), 2);
-        assert!(registry.get("trigger-1").is_some());
-    }
-
-    #[test]
-    fn test_capitalize_singular() {
-        assert_eq!(capitalize_singular("orders"), "Order");
-        assert_eq!(capitalize_singular("tasks"), "Task");
-        assert_eq!(capitalize_singular("items"), "Item");
-    }
-}