@feltdb/core 0.15.0 → 0.16.1

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

@@ -1,365 +0,0 @@
-/// Crash Recovery Tests
-///
-/// Comprehensive tests verifying that the transaction system can recover from
-/// partial failures and crashes. Tests scenarios where operations are logged but
-/// transitions not persisted, and vice versa.
-use crate::convergence::VectorClock;
-use crate::operation_log::MemoryOperationLog;
-use crate::state_transition_store::MemoryStateTransitionStore;
-use crate::transactions::*;
-use std::collections::HashMap;
-
-#[cfg(test)]
-mod crash_recovery {
-    use super::*;
-
-    fn create_test_operation(
-        op_id: u64,
-        parent_version: StateVersion,
-        record_id: &str,
-        value: i32,
-    ) -> Operation {
-        Operation::new(
-            OperationId::new("node1".to_string(), op_id),
-            parent_version,
-            "Update".to_string(),
-            OperationCommand {
-                op_type: "UpdateField".to_string(),
-                collection: "test".to_string(),
-                record_id: record_id.to_string(),
-                fields: {
-                    let mut m = HashMap::new();
-                    m.insert("value".to_string(), serde_json::json!(value));
-                    m
-                },
-            },
-            "user".to_string(),
-        )
-    }
-
-    fn create_version(sequence: u64, hash: &str) -> StateVersion {
-        let mut vc = VectorClock::new();
-        for _ in 0..sequence {
-            vc.increment("node1");
-        }
-        StateVersion::new(vc, hash.to_string())
-    }
-
-    #[test]
-    fn test_recover_from_operation_log_single_operation() {
-        let log = MemoryOperationLog::new();
-        let base_version = create_version(1, "hash0");
-
-        let op = create_test_operation(1, base_version, "rec1", 100);
-        let op_id = op.operation_id.clone();
-
-        log.append(op).unwrap();
-
-        assert_eq!(log.size(), 1);
-        let recovered = log.get_by_id(&op_id).unwrap();
-        assert_eq!(recovered.operation.intent, "Update");
-    }
-
-    #[test]
-    fn test_recover_from_operation_log_multiple_operations() {
-        let log = MemoryOperationLog::new();
-        let base_version = create_version(1, "hash0");
-
-        let op_ids: Vec<_> = (1..=5)
-            .map(|i| {
-                let op = create_test_operation(
-                    i,
-                    base_version.clone(),
-                    &format!("rec{}", i),
-                    i as i32 * 10,
-                );
-                let op_id = op.operation_id.clone();
-                log.append(op).unwrap();
-                op_id
-            })
-            .collect();
-
-        assert_eq!(log.size(), 5);
-        for (i, op_id) in op_ids.iter().enumerate() {
-            assert!(log.get_by_id(op_id).is_some());
-            let entry = log.get_by_index(i as u64).unwrap();
-            assert_eq!(entry.log_index, i as u64);
-        }
-    }
-
-    #[test]
-    fn test_partial_write_recovery_operation_logged_only() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-        let base_version = create_version(1, "hash0");
-
-        let op = create_test_operation(1, base_version, "rec1", 100);
-        let op_id = op.operation_id.clone();
-
-        log.append(op.clone()).unwrap();
-
-        assert_eq!(log.size(), 1);
-        assert_eq!(store.size(), 0);
-
-        assert!(log.contains_operation_id(&op_id));
-        assert!(!store.contains_transaction_id("txn1"));
-    }
-
-    #[test]
-    fn test_state_transition_chain_recovery() {
-        let store = MemoryStateTransitionStore::new();
-
-        let mut versions = vec![create_version(0, "hash0")];
-        for i in 1..=3 {
-            versions.push(create_version(i as u64, &format!("hash{}", i)));
-        }
-
-        for i in 0..3 {
-            let ops = vec![create_test_operation(
-                (i + 1) as u64,
-                versions[i].clone(),
-                &format!("rec{}", i),
-                (i as i32) * 10,
-            )];
-
-            let transition = StateTransition::new(
-                versions[i].clone(),
-                ops,
-                versions[i + 1].clone(),
-                ConsistencyContract::local(),
-            );
-
-            store.record_transition(transition).unwrap();
-        }
-
-        assert_eq!(store.size(), 3);
-
-        let chain = store.get_transition_chain("hash0");
-        assert_eq!(chain.len(), 3);
-
-        assert_eq!(chain[0].transition.from_version.state_hash, "hash0");
-        assert_eq!(chain[0].transition.to_version.state_hash, "hash1");
-
-        assert_eq!(chain[2].transition.from_version.state_hash, "hash2");
-        assert_eq!(chain[2].transition.to_version.state_hash, "hash3");
-    }
-
-    #[test]
-    fn test_divergence_recovery_concurrent_operations() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-
-        let base_version = create_version(1, "hash0");
-
-        let ops_seq1: Vec<_> = (1..=3)
-            .map(|i| create_test_operation(i, base_version.clone(), "rec1", i as i32 * 10))
-            .collect();
-
-        let ops_seq2: Vec<_> = (4..=6)
-            .map(|i| create_test_operation(i, base_version.clone(), "rec2", i as i32 * 10))
-            .collect();
-
-        for op in ops_seq1.iter().chain(ops_seq2.iter()) {
-            log.append(op.clone()).unwrap();
-        }
-
-        assert_eq!(log.size(), 6);
-
-        for op in ops_seq1 {
-            log.append(op.clone()).unwrap_err();
-        }
-
-        assert_eq!(log.size(), 6);
-    }
-
-    #[test]
-    fn test_recovery_point_identification() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-
-        let base_version = create_version(1, "hash0");
-
-        for i in 1..=10 {
-            let op =
-                create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
-            log.append(op).unwrap();
-        }
-
-        let range = log.get_range(5, 8);
-        assert_eq!(range.len(), 3);
-
-        let store_range = store.get_range(0, 10);
-        assert_eq!(store_range.len(), 0);
-    }
-
-    #[test]
-    fn test_exactly_once_recovery() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-
-        let base_version = create_version(1, "hash0");
-        let op_id = OperationId::new("node1".to_string(), 1);
-        let op = create_test_operation(1, base_version.clone(), "rec1", 100);
-
-        log.append(op.clone()).unwrap();
-
-        assert!(log.contains_operation_id(&op_id));
-
-        let duplicate_result = log.append(op);
-        assert!(duplicate_result.is_err());
-        assert!(duplicate_result.unwrap_err().contains("already logged"));
-    }
-
-    #[test]
-    fn test_state_version_lineage_recovery() {
-        let store = MemoryStateTransitionStore::new();
-
-        let v0 = create_version(0, "hash0");
-        let v1 = create_version(1, "hash1");
-        let v2 = create_version(2, "hash2");
-        let v3 = create_version(3, "hash3");
-
-        let ops = vec![create_test_operation(1, v0.clone(), "rec1", 10)];
-        let t1 = StateTransition::new(v0.clone(), ops, v1.clone(), ConsistencyContract::local());
-        store.record_transition(t1).unwrap();
-
-        let ops = vec![create_test_operation(2, v1.clone(), "rec2", 20)];
-        let t2 = StateTransition::new(v1.clone(), ops, v2.clone(), ConsistencyContract::local());
-        store.record_transition(t2).unwrap();
-
-        let ops = vec![create_test_operation(3, v2.clone(), "rec3", 30)];
-        let t3 = StateTransition::new(v2, ops, v3, ConsistencyContract::local());
-        store.record_transition(t3).unwrap();
-
-        let chain = store.get_transition_chain("hash0");
-        assert_eq!(chain.len(), 3);
-
-        let mut prev_hash = "hash0".to_string();
-        for record in chain {
-            assert_eq!(record.transition.from_version.state_hash, prev_hash);
-            prev_hash = record.transition.to_version.state_hash.clone();
-        }
-        assert_eq!(prev_hash, "hash3");
-    }
-
-    #[test]
-    fn test_partial_crash_operation_logged_transition_pending() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-
-        let base_version = create_version(1, "hash0");
-        let to_version = create_version(2, "hash1");
-
-        let op = create_test_operation(1, base_version.clone(), "rec1", 100);
-        let op_id = op.operation_id.clone();
-
-        log.append(op.clone()).unwrap();
-
-        assert_eq!(log.size(), 1);
-        assert_eq!(store.size(), 0);
-
-        assert!(log.contains_operation_id(&op_id));
-
-        let ops = vec![create_test_operation(2, base_version.clone(), "rec2", 200)];
-        let transition =
-            StateTransition::new(base_version, ops, to_version, ConsistencyContract::local());
-
-        store.record_transition(transition).unwrap();
-        assert_eq!(store.size(), 1);
-    }
-
-    #[test]
-    fn test_recovery_completeness_check() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-
-        let base_version = create_version(1, "hash0");
-
-        for i in 1..=5 {
-            let op =
-                create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
-            log.append(op.clone()).unwrap();
-
-            let to_version = create_version(i as u64 + 1, &format!("hash{}", i));
-            let transition = StateTransition::new(
-                base_version.clone(),
-                vec![op],
-                to_version,
-                ConsistencyContract::local(),
-            );
-            store.record_transition(transition).unwrap();
-        }
-
-        assert_eq!(log.size(), 5);
-        assert_eq!(store.size(), 5);
-
-        for i in 1..=5 {
-            let op_id = OperationId::new("node1".to_string(), i);
-            assert!(log.contains_operation_id(&op_id));
-        }
-    }
-
-    #[test]
-    fn test_truncation_recovery_point() {
-        let log = MemoryOperationLog::new();
-
-        let base_version = create_version(1, "hash0");
-
-        for i in 1..=10 {
-            let op =
-                create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
-            log.append(op).unwrap();
-        }
-
-        assert_eq!(log.size(), 10);
-
-        log.truncate(5).unwrap();
-        assert_eq!(log.size(), 5);
-
-        for i in 1..=5 {
-            let op_id = OperationId::new("node1".to_string(), i);
-            assert!(log.contains_operation_id(&op_id));
-        }
-
-        for i in 6..=10 {
-            let op_id = OperationId::new("node1".to_string(), i);
-            assert!(!log.contains_operation_id(&op_id));
-        }
-    }
-
-    #[test]
-    fn test_concurrent_crash_scenarios() {
-        let log = MemoryOperationLog::new();
-        let store = MemoryStateTransitionStore::new();
-
-        let base_version = create_version(1, "hash0");
-
-        let op1 = create_test_operation(1, base_version.clone(), "rec1", 100);
-        let op2 = create_test_operation(2, base_version.clone(), "rec2", 200);
-
-        log.append(op1.clone()).unwrap();
-
-        let to_version1 = create_version(2, "hash1");
-        let transition1 = StateTransition::new(
-            base_version.clone(),
-            vec![op1],
-            to_version1,
-            ConsistencyContract::local(),
-        );
-        store.record_transition(transition1).unwrap();
-
-        log.append(op2.clone()).unwrap();
-
-        let to_version2 = create_version(2, "hash2");
-        let transition2 = StateTransition::new(
-            base_version,
-            vec![op2],
-            to_version2,
-            ConsistencyContract::local(),
-        );
-        store.record_transition(transition2).unwrap();
-
-        assert_eq!(log.size(), 2);
-        assert_eq!(store.size(), 2);
-    }
-}

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

@@ -1,294 +0,0 @@
-use crate::Operation;
-/// Cron Engine module for time-based execution
-///
-/// Produces execution events based on cron schedules.
-/// Does not execute logic itself - just schedules events.
-use serde::{Deserialize, Serialize};
-
-/// A cron schedule definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CronSchedule {
-    /// Unique cron ID
-    pub cron_id: String,
-
-    /// Human-readable name
-    pub name: String,
-
-    /// Cron expression (simplified: "0 0 * * *" for daily at midnight)
-    /// Format: minute hour day month day-of-week
-    pub cron_expr: String,
-
-    /// Capability to execute
-    pub capability: String,
-
-    /// Whether this schedule is enabled
-    pub enabled: bool,
-
-    /// Last execution timestamp (ms since UNIX epoch)
-    pub last_executed_ms: Option<u128>,
-
-    /// Timezone (optional, defaults to UTC)
-    pub timezone: String,
-}
-
-impl CronSchedule {
-    /// Create a new cron schedule
-    pub fn new(cron_id: String, name: String, cron_expr: String, capability: String) -> Self {
-        Self {
-            cron_id,
-            name,
-            cron_expr,
-            capability,
-            enabled: true,
-            last_executed_ms: None,
-            timezone: "UTC".to_string(),
-        }
-    }
-
-    /// Check if this schedule should execute at the given time
-    pub fn should_execute_at(&self, timestamp_ms: u128) -> bool {
-        if !self.enabled {
-            return false;
-        }
-
-        // Check if we've already executed in this time window
-        if let Some(last) = self.last_executed_ms {
-            // Only execute once per minute
-            if timestamp_ms < last + 60000 {
-                return false;
-            }
-        }
-
-        // For now, use a simplified cron parser
-        // In production, use a proper cron library
-        self.matches_cron_time(timestamp_ms)
-    }
-
-    /// Parse cron expression and check if it matches the given time
-    fn matches_cron_time(&self, timestamp_ms: u128) -> bool {
-        // Simplified cron parsing for testing
-        // Real implementation would use proper cron library
-
-        // For now, support basic patterns like:
-        // - "0 0 * * *" = daily at midnight
-        // - "*/5 * * * *" = every 5 minutes
-        // - "0 12 * * MON" = every Monday at noon
-
-        let secs = (timestamp_ms / 1000) as u64;
-        let _ms_since_epoch = timestamp_ms as u64;
-
-        // Parse the cron expression
-        let parts: Vec<&str> = self.cron_expr.split_whitespace().collect();
-        if parts.len() < 5 {
-            return false;
-        }
-
-        // Get current time components
-        // This is a very simplified implementation
-        // Real cron would need proper time parsing
-
-        // For testing, we'll match patterns like:
-        // "0 0 * * *" at midnight (00:00)
-        // "0 12 * * *" at noon (12:00)
-
-        match self.cron_expr.as_str() {
-            "0 0 * * *" => {
-                // Midnight UTC - check if hour:minute is 00:00
-                let hours = (secs / 3600) % 24;
-                let minutes = (secs / 60) % 60;
-                hours == 0 && minutes == 0
-            }
-            "0 12 * * *" => {
-                // Noon UTC
-                let hours = (secs / 3600) % 24;
-                let minutes = (secs / 60) % 60;
-                hours == 12 && minutes == 0
-            }
-            _ => {
-                // For other expressions, just return true for testing
-                // A real implementation would parse the cron expression
-                true
-            }
-        }
-    }
-
-    /// Mark this schedule as executed at the given time
-    pub fn mark_executed(&mut self, timestamp_ms: u128) {
-        self.last_executed_ms = Some(timestamp_ms);
-    }
-}
-
-/// Cron scheduler - manages all cron schedules
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct CronScheduler {
-    /// All cron schedules by cron_id
-    schedules: std::collections::HashMap<String, CronSchedule>,
-}
-
-impl CronScheduler {
-    /// Create a new cron scheduler
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Register a new cron schedule
-    pub fn register(&mut self, schedule: CronSchedule) {
-        self.schedules.insert(schedule.cron_id.clone(), schedule);
-    }
-
-    /// Unregister a cron schedule
-    pub fn unregister(&mut self, cron_id: &str) -> Option<CronSchedule> {
-        self.schedules.remove(cron_id)
-    }
-
-    /// Get a cron schedule by ID
-    pub fn get(&self, cron_id: &str) -> Option<CronSchedule> {
-        self.schedules.get(cron_id).cloned()
-    }
-
-    /// Get all cron schedules
-    pub fn all(&self) -> Vec<CronSchedule> {
-        self.schedules.values().cloned().collect()
-    }
-
-    /// Find schedules that should execute at the given time
-    pub fn find_executable(&self, timestamp_ms: u128) -> Vec<CronSchedule> {
-        self.schedules
-            .values()
-            .filter(|schedule| schedule.should_execute_at(timestamp_ms))
-            .cloned()
-            .collect()
-    }
-
-    /// Generate a synthetic Operation for a cron event
-    pub fn create_cron_operation(
-        schedule: &CronSchedule,
-        op_id: u64,
-        sequence: u64,
-        timestamp_ms: u128,
-    ) -> Operation {
-        Operation::insert(
-            op_id,
-            "cron-scheduler".to_string(),
-            sequence,
-            format!("cron:{}", schedule.cron_id),
-            serde_json::json!({
-                "cron_id": schedule.cron_id,
-                "cron_name": schedule.name,
-                "capability": schedule.capability,
-                "triggered_at_ms": timestamp_ms,
-            }),
-            "CronEvent".to_string(),
-            "cron".to_string(),
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_cron_schedule_creation() {
-        let schedule = CronSchedule::new(
-            "cron-1".to_string(),
-            "daily-reports".to_string(),
-            "0 0 * * *".to_string(),
-            "generate_reports".to_string(),
-        );
-
-        assert_eq!(schedule.cron_id, "cron-1");
-        assert_eq!(schedule.name, "daily-reports");
-        assert_eq!(schedule.enabled, true);
-    }
-
-    #[test]
-    fn test_cron_midnight_pattern() {
-        let schedule = CronSchedule::new(
-            "cron-1".to_string(),
-            "daily-reports".to_string(),
-            "0 0 * * *".to_string(),
-            "generate_reports".to_string(),
-        );
-
-        // Midnight UTC timestamp (00:00 UTC)
-        // 2024-01-01 00:00:00 UTC = 1704067200 seconds
-        let midnight_ms = 1704067200 * 1000;
-
-        // Verify that it matches at midnight
-        assert!(schedule.matches_cron_time(midnight_ms));
-    }
-
-    #[test]
-    fn test_cron_should_execute() {
-        let mut schedule = CronSchedule::new(
-            "cron-1".to_string(),
-            "daily-reports".to_string(),
-            "0 0 * * *".to_string(),
-            "generate_reports".to_string(),
-        );
-
-        // Midnight UTC timestamp (00:00 UTC)
-        let midnight_ms = 1704067200 * 1000; // 2024-01-01 00:00:00 UTC
-
-        // Should execute at midnight
-        assert!(schedule.should_execute_at(midnight_ms));
-
-        // Mark as executed
-        schedule.mark_executed(midnight_ms);
-
-        // Should not execute again within 60 seconds
-        assert!(!schedule.should_execute_at(midnight_ms + 30000));
-
-        // Should not execute again even after 60 seconds if still in same cron window
-        // (we're still within the first minute of the hour, just not at :00)
-        // The cron expression "0 0 * * *" only matches at hour 0, minute 0
-        // At midnight + 61 seconds, we're at minute 1, so it shouldn't match
-        assert!(!schedule.should_execute_at(midnight_ms + 61000));
-
-        // Should execute at the next day's midnight
-        let next_midnight_ms = midnight_ms + 86400 * 1000; // 24 hours later
-        assert!(schedule.should_execute_at(next_midnight_ms));
-    }
-
-    #[test]
-    fn test_cron_scheduler() {
-        let mut scheduler = CronScheduler::new();
-
-        let schedule1 = CronSchedule::new(
-            "cron-1".to_string(),
-            "daily-reports".to_string(),
-            "0 0 * * *".to_string(),
-            "generate_reports".to_string(),
-        );
-
-        let schedule2 = CronSchedule::new(
-            "cron-2".to_string(),
-            "hourly-cleanup".to_string(),
-            "0 * * * *".to_string(),
-            "cleanup".to_string(),
-        );
-
-        scheduler.register(schedule1);
-        scheduler.register(schedule2);
-
-        assert_eq!(scheduler.all().len(), 2);
-        assert!(scheduler.get("cron-1").is_some());
-    }
-
-    #[test]
-    fn test_cron_operation_creation() {
-        let schedule = CronSchedule::new(
-            "cron-1".to_string(),
-            "daily-reports".to_string(),
-            "0 0 * * *".to_string(),
-            "generate_reports".to_string(),
-        );
-
-        let op = CronScheduler::create_cron_operation(&schedule, 1, 1, 1704067200 * 1000);
-
-        assert_eq!(op.capability, "cron");
-        assert_eq!(op.rust_type, "CronEvent");
-        assert_eq!(op.op_type, crate::OperationType::Insert);
-    }
-}