@feltdb/core 0.8.4 → 0.8.6

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

@@ -157,13 +157,19 @@ impl Storage for FileStorage {
             let file = OpenOptions::new().read(true).open(&self.path)?;
             let reader = BufReader::new(file);
 
-            for line in reader.lines() {
+            for (index, line) in reader.lines().enumerate() {
                 let line = line?;
                 if line.trim().is_empty() {
                     continue;
                 }
-                let row: StoredRow = serde_json::from_str(&line)
-                    .map_err(|_| FlowError::CorruptLogLine(line.clone()))?;
+                let row: StoredRow = serde_json::from_str(&line).map_err(|_| {
+                    FlowError::CorruptLogLine(Box::new(crate::LogCorruption {
+                        line_number: index + 1,
+                        byte_offset: 0,
+                        reason: "not a durable record this build understands".to_string(),
+                        excerpt: line.chars().take(120).collect(),
+                    }))
+                })?;
                 operations.push(row);
             }
         }

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

@@ -2,7 +2,6 @@
 ///
 /// Integrates the admission contract with actual operation submission,
 /// ensuring no silent failures and explicit rejection semantics.
-
 use crate::admission::{ProductionRetryPolicy, RejectionReason, SubmissionOutcome};
 use crate::transaction_api::{TransactionManager, TxError};
 use crate::transactions::{ConsistencyContract, Operation};
@@ -243,11 +242,8 @@ impl SubmissionManager {
         let mut manager = self.transaction_manager.lock().unwrap();
 
         // Extract operation ID - this is the unique identifier
-        let operation_id = u64::from_str_radix(
-            &operation.operation_id.sequence.to_string(),
-            10,
-        )
-        .unwrap_or(0);
+        let operation_id =
+            u64::from_str_radix(&operation.operation_id.sequence.to_string(), 10).unwrap_or(0);
 
         // Attempt to execute transaction
         match manager.execute_and_commit(
@@ -259,11 +255,9 @@ impl SubmissionManager {
             Err(err) => {
                 // Map TxError to RejectionReason
                 match err {
-                    TxError::OperationDeduplication(_) => {
-                        Err(RejectionReason::DuplicateDetected {
-                            original_operation_id: operation_id,
-                        })
-                    }
+                    TxError::OperationDeduplication(_) => Err(RejectionReason::DuplicateDetected {
+                        original_operation_id: operation_id,
+                    }),
                     TxError::PreconditionFailed(_) | TxError::ConflictDetected(_) => {
                         // These could indicate lock contention
                         Err(RejectionReason::TransientLockContention)

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

@@ -17,7 +17,6 @@
 /// - Bounded buffers (prevent unbounded growth)
 ///
 /// Deduplication/idempotency/retry logic is the protocol's responsibility via DistributedTransactionExecutor.
-
 use crate::distributed_transactions::ReplicationMessage;
 use crate::replica_acknowledgements::ReplicaAcknowledgement;
 
@@ -286,10 +285,7 @@ mod tests {
         tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
 
         // Client connects
-        client
-            .connect(server_addr)
-            .await
-            .expect("client connect");
+        client.connect(server_addr).await.expect("client connect");
 
         // Wait for server to process connection
         tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
@@ -376,7 +372,8 @@ mod tests {
         );
 
         let serialized = serde_json::to_vec(&msg).expect("serialize");
-        let deserialized: ReplicationMessage = serde_json::from_slice(&serialized).expect("deserialize");
+        let deserialized: ReplicationMessage =
+            serde_json::from_slice(&serialized).expect("deserialize");
 
         assert_eq!(msg.from_node, deserialized.from_node);
         assert_eq!(msg.to_node, deserialized.to_node);
@@ -387,8 +384,8 @@ mod tests {
     fn bincode_serialization_with_operation() {
         use crate::convergence::VectorClock;
         use crate::transactions::{Operation, OperationCommand, OperationId, StateVersion};
-        use std::collections::HashMap;
         use serde_json::json;
+        use std::collections::HashMap;
 
         let mut fields = HashMap::new();
         fields.insert("key1".to_string(), json!("value1"));
@@ -426,7 +423,8 @@ mod tests {
         let serialized = serde_json::to_vec(&msg).expect("serialize");
         println!("Serialized {} bytes", serialized.len());
 
-        let deserialized: ReplicationMessage = serde_json::from_slice(&serialized).expect("deserialize");
+        let deserialized: ReplicationMessage =
+            serde_json::from_slice(&serialized).expect("deserialize");
 
         assert_eq!(msg.from_node, deserialized.from_node);
         assert_eq!(msg.to_node, deserialized.to_node);

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

@@ -6,7 +6,6 @@
 /// - StateTransitionStore for transition durability
 /// - Precondition validation
 /// - Read/write dependency tracking
-
 use crate::convergence::VectorClock;
 use crate::operation_log::{MemoryOperationLog, OperationLogEntry};
 use crate::state_transition_store::{MemoryStateTransitionStore, StateTransitionRecord};
@@ -31,7 +30,9 @@ impl std::fmt::Display for TxError {
         match self {
             TxError::PreconditionFailed(msg) => write!(f, "Precondition failed: {}", msg),
             TxError::ConflictDetected(msg) => write!(f, "Conflict detected: {}", msg),
-            TxError::OperationDeduplication(msg) => write!(f, "Operation already executed: {}", msg),
+            TxError::OperationDeduplication(msg) => {
+                write!(f, "Operation already executed: {}", msg)
+            }
             TxError::InvalidState(msg) => write!(f, "Invalid state: {}", msg),
             TxError::PersistenceFailure(msg) => write!(f, "Persistence failure: {}", msg),
         }
@@ -99,7 +100,9 @@ impl TransactionManager {
 
         // 4. Validate transition succeeded
         if !transition.is_successful() {
-            return Err(TxError::InvalidState("Transaction execution failed".to_string()));
+            return Err(TxError::InvalidState(
+                "Transaction execution failed".to_string(),
+            ));
         }
 
         // 5. Persist operations to operation log
@@ -110,7 +113,8 @@ impl TransactionManager {
         }
 
         // 6. Persist transition to state transition store
-        let store_index = self.transition_store
+        let store_index = self
+            .transition_store
             .record_transition(transition.clone())
             .map_err(|e| TxError::PersistenceFailure(e))?;
 
@@ -121,9 +125,12 @@ impl TransactionManager {
         }
 
         // 8. Retrieve the recorded transition
-        let record = self.transition_store
+        let record = self
+            .transition_store
             .get_by_index(store_index)
-            .ok_or_else(|| TxError::PersistenceFailure("Failed to retrieve recorded transition".to_string()))?;
+            .ok_or_else(|| {
+                TxError::PersistenceFailure("Failed to retrieve recorded transition".to_string())
+            })?;
 
         Ok(record)
     }
@@ -191,10 +198,7 @@ impl TransactionManager {
 
     /// Validate preconditions for an operation
     /// (Simple string matching - production would have actual condition evaluation)
-    pub fn validate_preconditions(
-        &self,
-        operation: &Operation,
-    ) -> TxResult<()> {
+    pub fn validate_preconditions(&self, operation: &Operation) -> TxResult<()> {
         if operation.preconditions.is_empty() {
             return Ok(());
         }
@@ -257,11 +261,8 @@ mod tests {
             "user".to_string(),
         );
 
-        let result = manager.execute_and_commit(
-            "txn1".to_string(),
-            vec![op],
-            ConsistencyContract::local(),
-        );
+        let result =
+            manager.execute_and_commit("txn1".to_string(), vec![op], ConsistencyContract::local());
 
         assert!(result.is_ok());
         assert_eq!(manager.operation_log_size(), 1);
@@ -299,11 +300,8 @@ mod tests {
             ConsistencyContract::local(),
         );
 
-        let result = manager.execute_and_commit(
-            "txn2".to_string(),
-            vec![op],
-            ConsistencyContract::local(),
-        );
+        let result =
+            manager.execute_and_commit("txn2".to_string(), vec![op], ConsistencyContract::local());
 
         assert!(result.is_err());
         assert!(result.unwrap_err().to_string().contains("already executed"));
@@ -335,11 +333,8 @@ mod tests {
             "user".to_string(),
         );
 
-        let _ = manager.execute_and_commit(
-            "txn1".to_string(),
-            vec![op],
-            ConsistencyContract::local(),
-        );
+        let _ =
+            manager.execute_and_commit("txn1".to_string(), vec![op], ConsistencyContract::local());
 
         let retrieved = manager.get_operation(&op_id);
         assert!(retrieved.is_some());
@@ -370,11 +365,8 @@ mod tests {
             "user".to_string(),
         );
 
-        let _ = manager.execute_and_commit(
-            "txn1".to_string(),
-            vec![op],
-            ConsistencyContract::local(),
-        );
+        let _ =
+            manager.execute_and_commit("txn1".to_string(), vec![op], ConsistencyContract::local());
 
         let transition = manager.get_transition("txn1");
         assert!(transition.is_some());
@@ -461,11 +453,8 @@ mod tests {
             "user".to_string(),
         );
 
-        let _ = manager.execute_and_commit(
-            "txn1".to_string(),
-            vec![op],
-            ConsistencyContract::local(),
-        );
+        let _ =
+            manager.execute_and_commit("txn1".to_string(), vec![op], ConsistencyContract::local());
 
         let new_version = manager.current_state_version();
         assert_ne!(new_version.state_hash, initial_hash);

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

@@ -10,7 +10,6 @@
 /// 6. Consistency Contracts: Per-transaction guarantees
 /// 7. Derived State: Rebuildable from operation log
 /// 8. Partition Tolerance: Divergence + deterministic reconciliation
-
 use crate::convergence::VectorClock;
 use crate::transactions::*;
 use std::collections::HashMap;
@@ -235,7 +234,10 @@ mod invariant_tests {
         assert!(tx2.is_successful());
 
         let conflicts = CommitValidator::detect_conflicts(&tx1, &[tx2]);
-        assert!(conflicts.is_empty(), "Non-overlapping writes should not conflict");
+        assert!(
+            conflicts.is_empty(),
+            "Non-overlapping writes should not conflict"
+        );
     }
 
     #[test]
@@ -322,7 +324,10 @@ mod invariant_tests {
         assert!(tx2.is_successful());
 
         let conflicts = CommitValidator::detect_conflicts(&tx1, &[tx2]);
-        assert!(!conflicts.is_empty(), "Write-write conflicts should be detected");
+        assert!(
+            !conflicts.is_empty(),
+            "Write-write conflicts should be detected"
+        );
         assert!(
             conflicts.iter().any(|c| c.contains("Write-write")),
             "Should specifically identify write-write conflict"
@@ -446,7 +451,8 @@ mod invariant_tests {
         assert!(tx1.is_successful(), "Tx1 should succeed");
         assert!(tx2.is_successful(), "Tx2 should succeed");
         assert_eq!(
-            tx1.operations.len(), tx2.operations.len(),
+            tx1.operations.len(),
+            tx2.operations.len(),
             "Both transactions should have same number of operations"
         );
     }
@@ -493,7 +499,10 @@ mod invariant_tests {
             ConsistencyContract::eventual(),
         );
 
-        assert!(!tx.is_successful(), "Duplicate operation should be rejected");
+        assert!(
+            !tx.is_successful(),
+            "Duplicate operation should be rejected"
+        );
     }
 
     #[test]
@@ -623,8 +632,12 @@ mod invariant_tests {
         to_vc.increment("node1");
         let to_version = StateVersion::new(to_vc, "hash1".to_string());
 
-        let transition =
-            executor.execute_transaction("tx1".to_string(), version, ops.clone(), ConsistencyContract::local());
+        let transition = executor.execute_transaction(
+            "tx1".to_string(),
+            version,
+            ops.clone(),
+            ConsistencyContract::local(),
+        );
 
         assert_eq!(transition.operations.len(), ops.len());
 
@@ -944,6 +957,9 @@ mod invariant_tests {
         );
 
         let conflicts = CommitValidator::detect_conflicts(&tx1, &[tx2]);
-        assert!(!conflicts.is_empty(), "Write-skew scenario should detect potential conflict");
+        assert!(
+            !conflicts.is_empty(),
+            "Write-skew scenario should detect potential conflict"
+        );
     }
 }