@feltdb/core 0.8.3 → 0.8.5

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

@@ -8,9 +8,8 @@
  * - Query routing and distribution
  * - Index merging strategies
  */
-
 use serde::{Deserialize, Serialize};
-use std::collections::{HashMap, HashSet, BTreeMap};
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct PeerId(pub String);
@@ -209,7 +208,9 @@ impl DistributedIndexManager {
     /// Acknowledge sync from peer
     pub fn acknowledge_sync(&mut self, peer_id: &str, index_name: &str) -> Result<(), String> {
         if let Some(replication_state) = self.replication_states.get_mut(index_name) {
-            replication_state.replicated_peers.insert(peer_id.to_string());
+            replication_state
+                .replicated_peers
+                .insert(peer_id.to_string());
             Ok(())
         } else {
             Err(format!("Index {} not found", index_name))
@@ -258,7 +259,8 @@ impl DistributedIndexManager {
             self.peer_states
                 .keys()
                 .filter(|peer_id| {
-                    peer_id != &&self.local_peer_id && !replication_state.replicated_peers.contains(*peer_id)
+                    peer_id != &&self.local_peer_id
+                        && !replication_state.replicated_peers.contains(*peer_id)
                 })
                 .cloned()
                 .collect()
@@ -273,7 +275,10 @@ impl DistributedIndexManager {
 
         if let Some(replication_state) = self.replication_states.get(index_name) {
             for (peer_id, peer_version) in &replication_state.peer_versions {
-                if replication_state.local_version.concurrent_with(peer_version) {
+                if replication_state
+                    .local_version
+                    .concurrent_with(peer_version)
+                {
                     conflicts.push(VersionConflict {
                         index_name: index_name.to_string(),
                         local_version: replication_state.local_version.clone(),
@@ -326,11 +331,7 @@ impl DistributedIndexManager {
             fully_replicated,
             partially_replicated: total_indexes - fully_replicated,
             pending_operations: pending_total,
-            unreachable_peers: self
-                .peer_states
-                .values()
-                .filter(|p| !p.reachable)
-                .count(),
+            unreachable_peers: self.peer_states.values().filter(|p| !p.reachable).count(),
         }
     }
 }
@@ -432,11 +433,13 @@ mod tests {
         let mut manager = DistributedIndexManager::new("node1".to_string());
         manager.register_peer("node2".to_string());
 
-        assert!(manager.create_replicated_index(
-            "status_idx".to_string(),
-            "status".to_string(),
-            "hash".to_string()
-        ).is_ok());
+        assert!(manager
+            .create_replicated_index(
+                "status_idx".to_string(),
+                "status".to_string(),
+                "hash".to_string()
+            )
+            .is_ok());
 
         let status = manager.get_replication_status("status_idx");
         assert!(status.is_some());

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

@@ -7,7 +7,6 @@
 /// - Reconciliation after divergence
 /// - Write authority tracking and conflicts
 /// - Recovery contracts
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -125,7 +124,10 @@ impl DurabilityGuarantees {
         authority_node: String,
     ) -> Result<(), String> {
         if self.write_authorities.contains_key(&resource_id) {
-            return Err(format!("Write authority already established for {}", resource_id));
+            return Err(format!(
+                "Write authority already established for {}",
+                resource_id
+            ));
         }
 
         self.write_authorities.insert(
@@ -160,7 +162,11 @@ impl DurabilityGuarantees {
         }
     }
 
-    pub fn create_recovery_checkpoint(&mut self, operations_count: u64, data_hash: String) -> Result<RecoveryCheckpoint, String> {
+    pub fn create_recovery_checkpoint(
+        &mut self,
+        operations_count: u64,
+        data_hash: String,
+    ) -> Result<RecoveryCheckpoint, String> {
         self.checkpoint_counter += 1;
 
         let checkpoint = RecoveryCheckpoint {
@@ -202,10 +208,7 @@ impl DurabilityGuarantees {
         Ok(checkpoint)
     }
 
-    pub fn detect_crash_consistency(
-        &self,
-        crash_phase: &str,
-    ) -> Result<Vec<CrashPoint>, String> {
+    pub fn detect_crash_consistency(&self, crash_phase: &str) -> Result<Vec<CrashPoint>, String> {
         Ok(self
             .crash_points
             .iter()
@@ -323,7 +326,8 @@ mod tests {
     #[test]
     fn test_restart_recovery() {
         let mut dg = DurabilityGuarantees::new("node-1".to_string());
-        dg.create_recovery_checkpoint(100, "hash1".to_string()).unwrap();
+        dg.create_recovery_checkpoint(100, "hash1".to_string())
+            .unwrap();
 
         let recovered = dg.restart_recovery(None).unwrap();
         assert_eq!(recovered.operations_count, 100);

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

@@ -4,7 +4,6 @@
 /// The dedup set prevents duplicate operations from being applied multiple times.
 ///
 /// Invariant: Every envelope ID persisted survives process restart.
-
 use crate::distributed_transactions::EnvelopeId;
 use std::collections::HashSet;
 use std::fs::{File, OpenOptions};
@@ -28,10 +27,7 @@ impl DeduplicationSet {
         }
 
         // Open dedup file in append mode
-        let file = OpenOptions::new()
-            .create(true)
-            .append(true)
-            .open(&path)?;
+        let file = OpenOptions::new().create(true).append(true).open(&path)?;
 
         Ok(Self {
             path,

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

@@ -83,7 +83,11 @@ mod tests {
     ///
     /// The operation id is taken from the executor's next identity, which is
     /// exactly what the binary does now that the executor owns allocation.
-    fn commit(executor: &mut DistributedTransactionExecutor, node: &str, payload: &str) -> TransactionEnvelope {
+    fn commit(
+        executor: &mut DistributedTransactionExecutor,
+        node: &str,
+        payload: &str,
+    ) -> TransactionEnvelope {
         let sequence = executor.next_origin_sequence();
         let parent = chained_version(executor, node);
         match executor
@@ -103,7 +107,9 @@ mod tests {
     /// The parent version this node would commit on top of.
     fn chained_version(executor: &DistributedTransactionExecutor, node: &str) -> StateVersion {
         match executor.get_replica_state(node) {
-            Some(replica) => StateVersion::new(replica.vector_clock.clone(), replica.state_hash.to_string()),
+            Some(replica) => {
+                StateVersion::new(replica.vector_clock.clone(), replica.state_hash.to_string())
+            }
             None => zero_version(),
         }
     }
@@ -120,7 +126,11 @@ mod tests {
     fn identity_a_fresh_origin_starts_at_one() {
         let dir = tempfile::tempdir().unwrap();
         let mut node = open("A", &dir.path().join("operations.jsonl"));
-        assert_eq!(node.next_origin_sequence(), 1, "a brand-new origin legitimately starts at 1");
+        assert_eq!(
+            node.next_origin_sequence(),
+            1,
+            "a brand-new origin legitimately starts at 1"
+        );
         assert_eq!(commit(&mut node, "A", "first").envelope_id.sequence, 1);
     }
 
@@ -184,7 +194,9 @@ mod tests {
             let mut clock = VectorClock::new();
             clock.clocks.insert("A".to_string(), position);
             envelope.vector_clock = clock;
-            receiver.receive_replicated(message(envelope), zero_version()).expect("receive");
+            receiver
+                .receive_replicated(message(envelope), zero_version())
+                .expect("receive");
         }
 
         assert_eq!(
@@ -192,10 +204,19 @@ mod tests {
             1,
             "nine applied envelopes from A leave this node's own identity space untouched"
         );
-        assert_eq!(commit(&mut receiver, "receiver", "mine").envelope_id.sequence, 1);
+        assert_eq!(
+            commit(&mut receiver, "receiver", "mine")
+                .envelope_id
+                .sequence,
+            1
+        );
 
         let restarted = open("receiver", &path);
-        assert_eq!(restarted.next_origin_sequence(), 2, "and recovery filters by origin too");
+        assert_eq!(
+            restarted.next_origin_sequence(),
+            2,
+            "and recovery filters by origin too"
+        );
     }
 
     // -- crash boundaries --------------------------------------------------
@@ -279,7 +300,11 @@ mod tests {
             )
             .expect("submit");
         assert!(matches!(outcome, SubmitOutcome::CapacityExceeded { .. }));
-        assert_eq!(node.next_origin_sequence(), before, "a refusal consumes no identity");
+        assert_eq!(
+            node.next_origin_sequence(),
+            before,
+            "a refusal consumes no identity"
+        );
     }
 
     #[test]
@@ -290,7 +315,11 @@ mod tests {
         for cycle in 0..25 {
             let mut node = open("A", &path);
             for index in 0..4 {
-                issued.push(commit(&mut node, "A", &format!("c{cycle}_{index}")).envelope_id.sequence);
+                issued.push(
+                    commit(&mut node, "A", &format!("c{cycle}_{index}"))
+                        .envelope_id
+                        .sequence,
+                );
             }
         }
         let mut unique = issued.clone();
@@ -319,7 +348,9 @@ mod tests {
             commit(&mut origin, "A", "before")
         };
         assert!(matches!(
-            receiver.receive_replicated(message(before), zero_version()).expect("receive"),
+            receiver
+                .receive_replicated(message(before), zero_version())
+                .expect("receive"),
             ReceiveOutcome::Applied { .. }
         ));
 
@@ -328,18 +359,31 @@ mod tests {
             let mut origin = open("A", &origin_path);
             commit(&mut origin, "A", "after")
         };
-        assert_eq!(after.envelope_id.sequence, 2, "the identity did not restart");
+        assert_eq!(
+            after.envelope_id.sequence, 2,
+            "the identity did not restart"
+        );
 
-        let outcome = receiver.receive_replicated(message(after), zero_version()).expect("receive");
+        let outcome = receiver
+            .receive_replicated(message(after), zero_version())
+            .expect("receive");
         assert!(
             matches!(outcome, ReceiveOutcome::Applied { .. }),
             "a write from a restarted origin must be applied, not discarded: {outcome:?}"
         );
-        assert_eq!(receiver.causal_frontier().get("A"), 2, "and the frontier advances");
+        assert_eq!(
+            receiver.causal_frontier().get("A"),
+            2,
+            "and the frontier advances"
+        );
 
         let state = receiver.canonical_state().expect("state");
-        assert!(state.records.contains_key(&("items".to_string(), "after".to_string())));
-        assert!(state.records.contains_key(&("items".to_string(), "before".to_string())));
+        assert!(state
+            .records
+            .contains_key(&("items".to_string(), "after".to_string())));
+        assert!(state
+            .records
+            .contains_key(&("items".to_string(), "before".to_string())));
     }
 
     #[test]
@@ -352,9 +396,13 @@ mod tests {
         let mut receiver = open("receiver", &receiver_dir.path().join("operations.jsonl"));
 
         let first = commit(&mut origin, "A", "one");
-        receiver.receive_replicated(message(first.clone()), zero_version()).expect("receive");
+        receiver
+            .receive_replicated(message(first.clone()), zero_version())
+            .expect("receive");
         assert_eq!(
-            receiver.receive_replicated(message(first), zero_version()).expect("receive"),
+            receiver
+                .receive_replicated(message(first), zero_version())
+                .expect("receive"),
             ReceiveOutcome::AlreadyKnown,
             "a retransmission is refused"
         );
@@ -362,7 +410,9 @@ mod tests {
         let second = commit(&mut origin, "A", "two");
         assert!(
             matches!(
-                receiver.receive_replicated(message(second), zero_version()).expect("receive"),
+                receiver
+                    .receive_replicated(message(second), zero_version())
+                    .expect("receive"),
                 ReceiveOutcome::Applied { .. }
             ),
             "and a new operation after a duplicate is still accepted"
@@ -382,12 +432,17 @@ mod tests {
 
         let (first, second) = {
             let mut origin = open("A", &origin_path);
-            (commit(&mut origin, "A", "one"), commit(&mut origin, "A", "two"))
+            (
+                commit(&mut origin, "A", "one"),
+                commit(&mut origin, "A", "two"),
+            )
         };
 
         // Only the second is delivered, so it is held waiting for the first.
         assert!(matches!(
-            receiver.receive_replicated(message(second), zero_version()).expect("receive"),
+            receiver
+                .receive_replicated(message(second), zero_version())
+                .expect("receive"),
             ReceiveOutcome::PendingDependencies { .. }
         ));
         assert_eq!(receiver.pending_causal_count(), 1);
@@ -397,9 +452,14 @@ mod tests {
             let mut origin = open("A", &origin_path);
             commit(&mut origin, "A", "three")
         };
-        assert_eq!(third.envelope_id.sequence, 3, "no collision with the held entry");
+        assert_eq!(
+            third.envelope_id.sequence, 3,
+            "no collision with the held entry"
+        );
 
-        let held = receiver.receive_replicated(message(third), zero_version()).expect("receive");
+        let held = receiver
+            .receive_replicated(message(third), zero_version())
+            .expect("receive");
         assert!(
             matches!(held, ReceiveOutcome::PendingDependencies { .. }),
             "it is held on its own merits, not mistaken for the entry already pending: {held:?}"
@@ -407,12 +467,16 @@ mod tests {
         assert_eq!(receiver.pending_causal_count(), 2);
 
         // The gap closes and everything applies exactly once.
-        receiver.receive_replicated(message(first), zero_version()).expect("receive");
+        receiver
+            .receive_replicated(message(first), zero_version())
+            .expect("receive");
         assert_eq!(receiver.pending_causal_count(), 0);
         assert_eq!(receiver.causal_frontier().get("A"), 3);
         let state = receiver.canonical_state().expect("state");
         for record in ["one", "two", "three"] {
-            assert!(state.records.contains_key(&("items".to_string(), record.to_string())));
+            assert!(state
+                .records
+                .contains_key(&("items".to_string(), record.to_string())));
         }
     }
 }

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

@@ -4,7 +4,6 @@
 /// The log is the source of truth for recovery; replica state and dedup sets are derived from it.
 ///
 /// Invariant: Every successfully persisted operation can be recovered after process restart.
-
 use crate::distributed_transactions::TransactionEnvelope;
 use std::fs::{File, OpenOptions};
 use std::io::{BufRead, BufReader, Write};
@@ -27,10 +26,7 @@ impl OperationLog {
         }
 
         // Open log file in append mode
-        let file = OpenOptions::new()
-            .create(true)
-            .append(true)
-            .open(&path)?;
+        let file = OpenOptions::new().create(true).append(true).open(&path)?;
 
         Ok(Self {
             path,
@@ -119,7 +115,7 @@ impl OperationLog {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::transactions::{ConsistencyLevel, ConsistencyContract};
+    use crate::transactions::{ConsistencyContract, ConsistencyLevel};
     use tempfile::TempDir;
 
     fn create_test_envelope(sequence: u64) -> TransactionEnvelope {
@@ -127,7 +123,7 @@ mod tests {
             "node1".to_string(),
             sequence,
             format!("tx{}", sequence),
-            Vec::new(),  // Empty operations for test
+            Vec::new(), // Empty operations for test
             ConsistencyContract {
                 level: ConsistencyLevel::Causal,
                 timeout_ms: Some(1000),

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

@@ -7,7 +7,6 @@
 /// - Checkpoints and high-water marks for recovery
 /// - Replay and recovery mechanisms
 /// - Backpressure handling for flow control
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -118,7 +117,9 @@ impl DurableSyncManager {
         }
 
         self.sync_state.pending_changes.push(change);
-        self.sync_state.pending_changes.sort_by_key(|c| c.change_id.sequence);
+        self.sync_state
+            .pending_changes
+            .sort_by_key(|c| c.change_id.sequence);
 
         Ok(())
     }
@@ -147,14 +148,13 @@ impl DurableSyncManager {
 
     pub fn create_checkpoint(&mut self) -> Result<Checkpoint, String> {
         let checkpoint = Checkpoint {
-            checkpoint_id: format!("cp-{}-{}", self.node_id, self.sync_state.last_applied_sequence),
+            checkpoint_id: format!(
+                "cp-{}-{}",
+                self.node_id, self.sync_state.last_applied_sequence
+            ),
             node_id: self.node_id.clone(),
             high_water_mark: self.sync_state.last_applied_sequence,
-            applied_changes: self
-                .applied_ids
-                .iter()
-                .cloned()
-                .collect(),
+            applied_changes: self.applied_ids.iter().cloned().collect(),
             timestamp: std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
                 .unwrap_or_default()
@@ -189,7 +189,8 @@ impl DurableSyncManager {
 
     pub fn replay_from_checkpoint(&mut self, checkpoint: &Checkpoint) -> Result<usize, String> {
         let mut replayed = 0;
-        let applied_set: std::collections::HashSet<_> = checkpoint.applied_changes.iter().cloned().collect();
+        let applied_set: std::collections::HashSet<_> =
+            checkpoint.applied_changes.iter().cloned().collect();
 
         for change in self.sync_state.pending_changes.drain(..) {
             if !applied_set.contains(&change.idempotency_key)