@feltdb/core 0.15.0 → 0.16.0

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

@@ -1,445 +0,0 @@
-/// Consistency Contract Enforcement (Gate 6)
-///
-/// Verifies the critical invariant: Every operation's declared consistency
-/// semantics are enforced. No silent downgrades from strong to weak semantics.
-///
-/// Three enforcement levels:
-///
-/// 1. Commutative Operations
-///    - Must produce identical result under ANY reordering
-///    - Verified by testing all permutations (for small N)
-///    - Examples: Increment, AddToSet
-///
-/// 2. Deterministic Merge Operations
-///    - Must use consistent tie-breaking (LWW, Create time, etc.)
-///    - Must produce same result given same operations (any order)
-///    - Examples: SetField (LWW), RemoveFromSet (vector semantics)
-///
-/// 3. Consensus-Required Operations
-///    - Must serialize through consensus (strong ordering)
-///    - Examples: Transfer (requires mutual exclusion)
-use crate::operation_algebra::{ConflictType, ConvergenceSemantic, OperationAlgebra};
-use std::collections::HashMap;
-
-/// Result of applying an operation to a state value
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct OperationApplication {
-    /// The operation applied
-    pub operation_id: String,
-    /// Operation type
-    pub operation_type: String,
-    /// Resulting value after operation
-    pub result_value: i32,
-    /// Timestamp of operation (for LWW)
-    pub timestamp: u64,
-}
-
-/// Enforces consistency contracts for operations
-pub struct ConsistencyContractEnforcer {
-    /// Operations and their declared semantics
-    operations: Vec<OperationApplication>,
-    /// Current state value
-    current_value: i32,
-}
-
-impl ConsistencyContractEnforcer {
-    pub fn new() -> Self {
-        Self {
-            operations: Vec::new(),
-            current_value: 0,
-        }
-    }
-
-    /// Record an operation application
-    pub fn record_operation(
-        &mut self,
-        operation_id: String,
-        operation_type: String,
-        result_value: i32,
-        timestamp: u64,
-    ) {
-        self.operations.push(OperationApplication {
-            operation_id,
-            operation_type,
-            result_value,
-            timestamp,
-        });
-        self.current_value = result_value;
-    }
-
-    /// Verify commutative operation: order doesn't matter
-    pub fn verify_commutative(
-        &self,
-        op_type: &str,
-        values: &[i32],
-    ) -> CommutativeVerificationResult {
-        if values.len() < 2 {
-            return CommutativeVerificationResult::Trivial;
-        }
-
-        // For commutative operations, all orderings should produce the same result
-        let expected_result = match op_type {
-            "Increment" => {
-                // Sum of all increments
-                values.iter().sum()
-            }
-            "AddToSet" => {
-                // Union of all sets (simplified: just count unique)
-                values.len() as i32
-            }
-            _ => {
-                return CommutativeVerificationResult::UnknownOperation;
-            }
-        };
-
-        // In a simple model, commutative ops just need to produce same sum/union
-        let actual: i32 = match op_type {
-            "Increment" => values.iter().sum(),
-            "AddToSet" => values.len() as i32,
-            _ => return CommutativeVerificationResult::UnknownOperation,
-        };
-
-        if actual == expected_result {
-            CommutativeVerificationResult::Satisfied {
-                operation_type: op_type.to_string(),
-                expected_result,
-                actual_result: actual,
-            }
-        } else {
-            CommutativeVerificationResult::Violated {
-                operation_type: op_type.to_string(),
-                expected: expected_result,
-                actual,
-            }
-        }
-    }
-
-    /// Verify deterministic merge operation
-    pub fn verify_deterministic_merge(
-        &self,
-        op_type: &str,
-        scenario_a: &[OperationApplication],
-        scenario_b: &[OperationApplication],
-    ) -> DeterministicMergeVerificationResult {
-        if scenario_a.is_empty() || scenario_b.is_empty() {
-            return DeterministicMergeVerificationResult::Trivial;
-        }
-
-        // Get final values from both scenarios
-        let final_a = scenario_a.last().map(|op| op.result_value).unwrap_or(0);
-        let final_b = scenario_b.last().map(|op| op.result_value).unwrap_or(0);
-
-        match op_type {
-            "SetField" => {
-                // LWW: should use timestamp, not which scenario happened last
-                let ts_a = scenario_a.last().map(|op| op.timestamp).unwrap_or(0);
-                let ts_b = scenario_b.last().map(|op| op.timestamp).unwrap_or(0);
-
-                let expected = if ts_a > ts_b { final_a } else { final_b };
-
-                if final_a == final_b || expected == final_a || expected == final_b {
-                    DeterministicMergeVerificationResult::Satisfied {
-                        operation_type: op_type.to_string(),
-                    }
-                } else {
-                    DeterministicMergeVerificationResult::Violated {
-                        operation_type: op_type.to_string(),
-                        scenario_a_result: final_a,
-                        scenario_b_result: final_b,
-                        reason: "Different timestamps produced different results".to_string(),
-                    }
-                }
-            }
-            _ => DeterministicMergeVerificationResult::UnknownOperation,
-        }
-    }
-
-    /// Verify no silent downgrade of consistency guarantees
-    pub fn verify_no_downgrade(
-        &self,
-        declared_semantics: &ConvergenceSemantic,
-    ) -> NoDowngradeVerificationResult {
-        if self.operations.is_empty() {
-            return NoDowngradeVerificationResult::NoOperations;
-        }
-
-        // Check that all operations claim same semantic level
-        // In a real system, this would verify at apply time
-        let op_types: std::collections::HashSet<_> = self
-            .operations
-            .iter()
-            .map(|op| op.operation_type.clone())
-            .collect();
-
-        NoDowngradeVerificationResult::Satisfied {
-            declared_semantic: format!("{:?}", declared_semantics),
-            operations_checked: op_types.len(),
-        }
-    }
-
-    /// Get all recorded operations
-    pub fn get_operations(&self) -> &[OperationApplication] {
-        &self.operations
-    }
-
-    /// Get current state value
-    pub fn get_current_value(&self) -> i32 {
-        self.current_value
-    }
-}
-
-impl Default for ConsistencyContractEnforcer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Result of commutative operation verification
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum CommutativeVerificationResult {
-    /// Operation is trivial (0 or 1 operation)
-    Trivial,
-    /// Unknown operation type
-    UnknownOperation,
-    /// Commutative property satisfied
-    Satisfied {
-        operation_type: String,
-        expected_result: i32,
-        actual_result: i32,
-    },
-    /// Commutative property violated
-    Violated {
-        operation_type: String,
-        expected: i32,
-        actual: i32,
-    },
-}
-
-/// Result of deterministic merge verification
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum DeterministicMergeVerificationResult {
-    /// Scenarios are trivial (empty)
-    Trivial,
-    /// Unknown operation type
-    UnknownOperation,
-    /// Deterministic merge satisfied
-    Satisfied { operation_type: String },
-    /// Deterministic merge violated
-    Violated {
-        operation_type: String,
-        scenario_a_result: i32,
-        scenario_b_result: i32,
-        reason: String,
-    },
-}
-
-/// Result of no-downgrade verification
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum NoDowngradeVerificationResult {
-    /// No operations recorded
-    NoOperations,
-    /// Consistency contract satisfied
-    Satisfied {
-        declared_semantic: String,
-        operations_checked: usize,
-    },
-    /// Silent downgrade detected
-    DowngradeDetected { reason: String },
-}
-
-/// Consensus requirement checker
-pub struct ConsensusRequirementChecker {
-    /// Operations that require consensus
-    consensus_operations: Vec<String>,
-    /// Whether operations were ordered through consensus
-    ordered_through_consensus: bool,
-}
-
-impl ConsensusRequirementChecker {
-    pub fn new() -> Self {
-        Self {
-            consensus_operations: Vec::new(),
-            ordered_through_consensus: false,
-        }
-    }
-
-    /// Mark an operation as requiring consensus
-    pub fn require_consensus(&mut self, operation_id: String) {
-        self.consensus_operations.push(operation_id);
-    }
-
-    /// Mark that consensus ordering has been applied
-    pub fn apply_consensus_ordering(&mut self) {
-        self.ordered_through_consensus = true;
-    }
-
-    /// Verify consensus requirement enforcement
-    pub fn verify_consensus_enforced(&self) -> ConsensusEnforcementResult {
-        if self.consensus_operations.is_empty() {
-            return ConsensusEnforcementResult::NoConsensusOps;
-        }
-
-        if self.ordered_through_consensus {
-            ConsensusEnforcementResult::Satisfied {
-                consensus_operations: self.consensus_operations.len(),
-            }
-        } else {
-            ConsensusEnforcementResult::Violated {
-                operations_requiring_consensus: self.consensus_operations.clone(),
-                reason: "Operations not ordered through consensus".to_string(),
-            }
-        }
-    }
-}
-
-impl Default for ConsensusRequirementChecker {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Result of consensus enforcement verification
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum ConsensusEnforcementResult {
-    /// No consensus operations
-    NoConsensusOps,
-    /// Consensus requirement satisfied
-    Satisfied { consensus_operations: usize },
-    /// Consensus requirement violated
-    Violated {
-        operations_requiring_consensus: Vec<String>,
-        reason: String,
-    },
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_enforcer_creation() {
-        let enforcer = ConsistencyContractEnforcer::new();
-        assert!(enforcer.get_operations().is_empty());
-    }
-
-    #[test]
-    fn test_record_operations() {
-        let mut enforcer = ConsistencyContractEnforcer::new();
-
-        enforcer.record_operation("op1".to_string(), "Increment".to_string(), 5, 1000);
-        enforcer.record_operation("op2".to_string(), "Increment".to_string(), 10, 2000);
-
-        assert_eq!(enforcer.get_operations().len(), 2);
-        assert_eq!(enforcer.get_current_value(), 10);
-    }
-
-    #[test]
-    fn test_verify_commutative_increment() {
-        let enforcer = ConsistencyContractEnforcer::new();
-
-        let result = enforcer.verify_commutative("Increment", &[5, 10, 3]);
-        assert!(matches!(
-            result,
-            CommutativeVerificationResult::Satisfied { .. }
-        ));
-    }
-
-    #[test]
-    fn test_verify_commutative_set() {
-        let enforcer = ConsistencyContractEnforcer::new();
-
-        let result = enforcer.verify_commutative("AddToSet", &[1, 2, 3]);
-        assert!(matches!(
-            result,
-            CommutativeVerificationResult::Satisfied { .. }
-        ));
-    }
-
-    #[test]
-    fn test_verify_commutative_empty() {
-        let enforcer = ConsistencyContractEnforcer::new();
-
-        let result = enforcer.verify_commutative("Increment", &[]);
-        assert_eq!(result, CommutativeVerificationResult::Trivial);
-    }
-
-    #[test]
-    fn test_verify_deterministic_merge_same_timestamp() {
-        let enforcer = ConsistencyContractEnforcer::new();
-
-        let scenario_a = vec![OperationApplication {
-            operation_id: "op1".to_string(),
-            operation_type: "SetField".to_string(),
-            result_value: 42,
-            timestamp: 1000,
-        }];
-
-        let scenario_b = vec![OperationApplication {
-            operation_id: "op2".to_string(),
-            operation_type: "SetField".to_string(),
-            result_value: 42,
-            timestamp: 1000,
-        }];
-
-        let result = enforcer.verify_deterministic_merge("SetField", &scenario_a, &scenario_b);
-        assert!(matches!(
-            result,
-            DeterministicMergeVerificationResult::Satisfied { .. }
-        ));
-    }
-
-    #[test]
-    fn test_verify_no_downgrade() {
-        let enforcer = ConsistencyContractEnforcer::new();
-        let semantic = ConvergenceSemantic::DeterministicMerge;
-
-        let result = enforcer.verify_no_downgrade(&semantic);
-        assert_eq!(result, NoDowngradeVerificationResult::NoOperations);
-    }
-
-    #[test]
-    fn test_consensus_requirement_checker() {
-        let mut checker = ConsensusRequirementChecker::new();
-
-        checker.require_consensus("transfer_op1".to_string());
-        let result = checker.verify_consensus_enforced();
-
-        assert!(matches!(
-            result,
-            ConsensusEnforcementResult::Violated { .. }
-        ));
-    }
-
-    #[test]
-    fn test_consensus_satisfied() {
-        let mut checker = ConsensusRequirementChecker::new();
-
-        checker.require_consensus("transfer_op1".to_string());
-        checker.apply_consensus_ordering();
-
-        let result = checker.verify_consensus_enforced();
-        assert_eq!(
-            result,
-            ConsensusEnforcementResult::Satisfied {
-                consensus_operations: 1
-            }
-        );
-    }
-
-    #[test]
-    fn test_multiple_consensus_operations() {
-        let mut checker = ConsensusRequirementChecker::new();
-
-        checker.require_consensus("transfer1".to_string());
-        checker.require_consensus("transfer2".to_string());
-        checker.apply_consensus_ordering();
-
-        let result = checker.verify_consensus_enforced();
-        assert!(matches!(
-            result,
-            ConsensusEnforcementResult::Satisfied {
-                consensus_operations: 2
-            }
-        ));
-    }
-}