@feltdb/core 0.8.4 → 0.8.6

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)

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

@@ -10,7 +10,6 @@
 /// - Connection lifecycle tracking
 ///
 /// Deduplication/idempotency is the protocol's responsibility via DistributedTransactionExecutor.
-
 use crate::distributed_transactions::ReplicationMessage;
 use crate::replication_protocol::{ProtocolError, ProtocolMetrics, ProtocolTransport};
 use std::sync::Arc;
@@ -59,10 +58,7 @@ impl InProcessTransport {
     }
 
     /// Create a bidirectional pair of transports
-    pub fn create_bidirectional_pair(
-        local_id: String,
-        peer_id: String,
-    ) -> (Self, Self) {
+    pub fn create_bidirectional_pair(local_id: String, peer_id: String) -> (Self, Self) {
         let (local_tx, local_rx) = mpsc::unbounded_channel();
         let (peer_tx, peer_rx) = mpsc::unbounded_channel();
 
@@ -90,7 +86,6 @@ impl InProcessTransport {
     pub fn metrics(&self) -> &ProtocolMetrics {
         &self.metrics
     }
-
 }
 
 #[async_trait::async_trait]

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

@@ -372,9 +372,7 @@ impl IndexManager {
                             let values: Vec<&str> = idx
                                 .fields
                                 .iter()
-                                .filter_map(|field| {
-                                    obj.get(field).and_then(|v| v.as_str())
-                                })
+                                .filter_map(|field| obj.get(field).and_then(|v| v.as_str()))
                                 .collect();
                             if values.len() == idx.fields.len() {
                                 idx.remove(record_id, values);
@@ -393,9 +391,7 @@ impl IndexManager {
                         let values: Vec<&str> = idx
                             .fields
                             .iter()
-                            .filter_map(|field| {
-                                obj.get(field).and_then(|v| v.as_str())
-                            })
+                            .filter_map(|field| obj.get(field).and_then(|v| v.as_str()))
                             .collect();
                         if values.len() == idx.fields.len() {
                             idx.add(record_id, values);
@@ -452,7 +448,12 @@ impl IndexManager {
                             _ => unreachable!(),
                         }
                     }
-                    _ => return Err(format!("Sorted index does not support {} operator", operator)),
+                    _ => {
+                        return Err(format!(
+                            "Sorted index does not support {} operator",
+                            operator
+                        ))
+                    }
                 }
             }
             IndexInner::Compound(_) => {
@@ -510,7 +511,7 @@ impl IndexManager {
                 IndexInner::Compound(idx) => idx.size(),
                 IndexInner::Text(idx) => idx.size(),
             },
-            size: 0, // TODO: implement size calculation
+            size: 0,         // TODO: implement size calculation
             last_updated: 0, // TODO: track timestamp
             reads: e.reads,
             writes: e.writes,
@@ -545,11 +546,7 @@ impl IndexManager {
         })
     }
 
-    pub fn plan_query(
-        &self,
-        index_name: &str,
-        operator: &str,
-    ) -> Result<QueryPlan, String> {
+    pub fn plan_query(&self, index_name: &str, operator: &str) -> Result<QueryPlan, String> {
         let entry = self
             .indexes
             .get(index_name)
@@ -582,12 +579,22 @@ impl IndexManager {
         })
     }
 
-    pub fn count_indexed(&mut self, index_name: &str, operator: &str, value: &str) -> Result<usize, String> {
+    pub fn count_indexed(
+        &mut self,
+        index_name: &str,
+        operator: &str,
+        value: &str,
+    ) -> Result<usize, String> {
         let results = self.query_index(index_name, operator, value)?;
         Ok(results.len())
     }
 
-    pub fn exists_indexed(&mut self, index_name: &str, operator: &str, value: &str) -> Result<bool, String> {
+    pub fn exists_indexed(
+        &mut self,
+        index_name: &str,
+        operator: &str,
+        value: &str,
+    ) -> Result<bool, String> {
         let count = self.count_indexed(index_name, operator, value)?;
         Ok(count > 0)
     }
@@ -619,19 +626,11 @@ mod tests {
             })
             .unwrap();
 
-        manager
-            .update_record("1", None, "active")
-            .unwrap();
-        manager
-            .update_record("2", None, "inactive")
-            .unwrap();
-        manager
-            .update_record("3", None, "active")
-            .unwrap();
+        manager.update_record("1", None, "active").unwrap();
+        manager.update_record("2", None, "inactive").unwrap();
+        manager.update_record("3", None, "active").unwrap();
 
-        let results = manager
-            .query_index("status_idx", "eq", "active")
-            .unwrap();
+        let results = manager.query_index("status_idx", "eq", "active").unwrap();
         assert_eq!(results.len(), 2);
     }
 
@@ -651,15 +650,9 @@ mod tests {
             })
             .unwrap();
 
-        manager
-            .update_record("1", None, "2024-01-01")
-            .unwrap();
-        manager
-            .update_record("2", None, "2024-02-01")
-            .unwrap();
-        manager
-            .update_record("3", None, "2024-03-01")
-            .unwrap();
+        manager.update_record("1", None, "2024-01-01").unwrap();
+        manager.update_record("2", None, "2024-02-01").unwrap();
+        manager.update_record("3", None, "2024-03-01").unwrap();
 
         let results = manager
             .query_index("created_idx", "range", "2024-01-01,2024-02-01")
@@ -750,8 +743,12 @@ mod tests {
 
         manager.update_record("1", None, "active").unwrap();
 
-        assert!(manager.exists_indexed("status_idx", "eq", "active").unwrap());
-        assert!(!manager.exists_indexed("status_idx", "eq", "inactive").unwrap());
+        assert!(manager
+            .exists_indexed("status_idx", "eq", "active")
+            .unwrap());
+        assert!(!manager
+            .exists_indexed("status_idx", "eq", "inactive")
+            .unwrap());
     }
 
     #[test]