@feltdb/core 0.8.4 → 0.8.5

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

@@ -7,7 +7,6 @@
 /// - Relationship access patterns
 /// - Materialized views and projections
 /// - Multi-key operations
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -142,7 +141,11 @@ impl ProductionAPI {
             .ok_or_else(|| format!("Resource not found: {}", id))
     }
 
-    pub fn read_many(&self, ids: &[&str], _options: ReadOptions) -> Result<Vec<StateValue>, String> {
+    pub fn read_many(
+        &self,
+        ids: &[&str],
+        _options: ReadOptions,
+    ) -> Result<Vec<StateValue>, String> {
         let mut results = Vec::new();
         for id in ids {
             if let Some(value) = self.state_store.get(*id) {
@@ -152,7 +155,11 @@ impl ProductionAPI {
         Ok(results)
     }
 
-    pub fn write(&mut self, mutation: Mutation, options: WriteOptions) -> Result<MutationResult, String> {
+    pub fn write(
+        &mut self,
+        mutation: Mutation,
+        options: WriteOptions,
+    ) -> Result<MutationResult, String> {
         if let Some(ref key) = options.idempotency_key {
             if let Some(existing) = self.state_store.get(&mutation.resource_id) {
                 return Ok(MutationResult {
@@ -177,7 +184,8 @@ impl ProductionAPI {
             updated_at: now,
         };
 
-        self.state_store.insert(mutation.resource_id.clone(), value.clone());
+        self.state_store
+            .insert(mutation.resource_id.clone(), value.clone());
 
         Ok(MutationResult {
             success: true,
@@ -209,7 +217,10 @@ impl ProductionAPI {
         Ok(results)
     }
 
-    pub fn transaction(&mut self, request: TransactionRequest) -> Result<TransactionResult, String> {
+    pub fn transaction(
+        &mut self,
+        request: TransactionRequest,
+    ) -> Result<TransactionResult, String> {
         self.transaction_id_counter += 1;
         let transaction_id = format!("tx-{}", self.transaction_id_counter);
 
@@ -246,13 +257,12 @@ impl ProductionAPI {
             .push(target);
     }
 
-    pub fn get_relationships(&self, query: RelationshipQuery) -> Result<RelationshipResult, String> {
+    pub fn get_relationships(
+        &self,
+        query: RelationshipQuery,
+    ) -> Result<RelationshipResult, String> {
         let key = format!("{}:{}", query.source_id, query.relationship);
-        let targets = self
-            .relationships
-            .get(&key)
-            .cloned()
-            .unwrap_or_default();
+        let targets = self.relationships.get(&key).cloned().unwrap_or_default();
 
         Ok(RelationshipResult {
             source_id: query.source_id,
@@ -359,8 +369,16 @@ mod tests {
     #[test]
     fn test_relationships() {
         let mut api = ProductionAPI::new();
-        api.add_relationship("user-1".to_string(), "follows".to_string(), "user-2".to_string());
-        api.add_relationship("user-1".to_string(), "follows".to_string(), "user-3".to_string());
+        api.add_relationship(
+            "user-1".to_string(),
+            "follows".to_string(),
+            "user-2".to_string(),
+        );
+        api.add_relationship(
+            "user-1".to_string(),
+            "follows".to_string(),
+            "user-3".to_string(),
+        );
 
         let result = api
             .get_relationships(RelationshipQuery {

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

@@ -5,7 +5,6 @@
 /// - Latency contract enforcement
 /// - Performance degradation detection
 /// - Query optimization recommendations
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::{Duration, Instant};
@@ -156,7 +155,11 @@ impl QueryPerformanceTracker {
         for metric in &self.metrics {
             csv.push_str(&format!(
                 "{},{},{},{},{}\n",
-                metric.timestamp, metric.query_type, metric.duration_us, metric.index_name, metric.result_count
+                metric.timestamp,
+                metric.query_type,
+                metric.duration_us,
+                metric.index_name,
+                metric.result_count
             ));
         }
         csv
@@ -187,12 +190,7 @@ mod tests {
         std::thread::sleep(Duration::from_micros(50));
         let elapsed = timer.elapsed_us();
 
-        tracker.record_query(
-            "index_lookup".to_string(),
-            "idx_1".to_string(),
-            10,
-            elapsed,
-        );
+        tracker.record_query("index_lookup".to_string(), "idx_1".to_string(), 10, elapsed);
 
         let stats = tracker.get_stats("index_lookup").unwrap();
         assert_eq!(stats.count, 1);

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

@@ -8,7 +8,6 @@
 /// - After index deletion (rebuild index from scratch)
 ///
 /// All paths must converge to identical state_hash.
-
 use crate::operation_log::{MemoryOperationLog, OperationLogEntry};
 use crate::state_hash::{CanonicalState, StateHash};
 use crate::state_transition_store::MemoryStateTransitionStore;
@@ -46,7 +45,10 @@ pub struct ReplayFuzzer {
 }
 
 impl ReplayFuzzer {
-    pub fn new(operation_log: MemoryOperationLog, transition_store: MemoryStateTransitionStore) -> Self {
+    pub fn new(
+        operation_log: MemoryOperationLog,
+        transition_store: MemoryStateTransitionStore,
+    ) -> Self {
         Self {
             operation_log,
             transition_store,
@@ -99,9 +101,7 @@ impl ReplayFuzzer {
         let log_size = self.operation_log.size();
         if snapshot_at >= log_size {
             return ReplayPath {
-                scenario: ReplayScenario::AfterSnapshot {
-                    snapshot_at,
-                },
+                scenario: ReplayScenario::AfterSnapshot { snapshot_at },
                 final_state_hash: StateHash::from_hex("snapshot_beyond_log".to_string()),
                 operations_replayed: 0,
                 transitions_created: 0,

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

@@ -137,12 +137,16 @@ impl AcknowledgementStore {
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, AcknowledgementError> {
         let path = path.as_ref().to_path_buf();
         let acknowledgements = if path.exists() {
-            let bytes = std::fs::read(&path).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            let bytes =
+                std::fs::read(&path).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
             serde_json::from_slice(&bytes).map_err(|e| AcknowledgementError::Io(e.to_string()))?
         } else {
             BTreeMap::new()
         };
-        Ok(Self { path, acknowledgements })
+        Ok(Self {
+            path,
+            acknowledgements,
+        })
     }
 
     fn persist(&self) -> Result<(), AcknowledgementError> {
@@ -154,10 +158,12 @@ impl AcknowledgementStore {
             .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
         {
             use std::io::Write;
-            let mut file =
-                std::fs::File::create(&temp).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
-            file.write_all(&bytes).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
-            file.sync_all().map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            let mut file = std::fs::File::create(&temp)
+                .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            file.write_all(&bytes)
+                .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            file.sync_all()
+                .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
         }
         std::fs::rename(&temp, &self.path).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
         if let Some(parent) = self.path.parent() {
@@ -227,7 +233,9 @@ impl AcknowledgementStore {
             // No required replicas at all. Still not a licence: a node with no
             // membership has not established that it is alone, it has
             // established nothing.
-            return ReclamationEvidence::Blocked { waiting_on: Vec::new() };
+            return ReclamationEvidence::Blocked {
+                waiting_on: Vec::new(),
+            };
         }
 
         let missing: Vec<String> = required
@@ -236,7 +244,9 @@ impl AcknowledgementStore {
             .cloned()
             .collect();
         if !missing.is_empty() {
-            return ReclamationEvidence::Blocked { waiting_on: missing };
+            return ReclamationEvidence::Blocked {
+                waiting_on: missing,
+            };
         }
 
         // The minimum over every required replica, component-wise. A frontier
@@ -259,7 +269,10 @@ impl AcknowledgementStore {
                 frontier.clocks.insert(origin, lowest);
             }
         }
-        ReclamationEvidence::SafeThrough { frontier, covered: required }
+        ReclamationEvidence::SafeThrough {
+            frontier,
+            covered: required,
+        }
     }
 }
 
@@ -328,12 +341,17 @@ mod tests {
     fn a_required_replica_with_no_acknowledgement_blocks() {
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
-        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"])).unwrap();
+        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"]))
+            .unwrap();
 
         let evidence = acks.evidence(&["ra".into(), "rb".into(), "rc".into()]);
         match evidence {
             ReclamationEvidence::Blocked { waiting_on } => {
-                assert_eq!(waiting_on, vec!["ra", "rc"], "and it names who it waits for");
+                assert_eq!(
+                    waiting_on,
+                    vec!["ra", "rc"],
+                    "and it names who it waits for"
+                );
             }
             other => panic!("missing acknowledgement must block, got {other:?}"),
         }
@@ -347,7 +365,8 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
         acks.record(ack("ra", &[("A", 3)], &["ra", "rb"])).unwrap();
-        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"])).unwrap();
+        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"]))
+            .unwrap();
 
         let local = vec!["ra".to_string(), "rb".to_string()];
         assert_eq!(acks.required_union(&local), vec!["ra", "rb", "rc"]);
@@ -363,7 +382,10 @@ mod tests {
         // alone. It has established nothing, and nothing is what it may act on.
         let dir = tempfile::tempdir().unwrap();
         let acks = store(&dir);
-        assert!(matches!(acks.evidence(&[]), ReclamationEvidence::Blocked { .. }));
+        assert!(matches!(
+            acks.evidence(&[]),
+            ReclamationEvidence::Blocked { .. }
+        ));
     }
 
     #[test]
@@ -395,8 +417,10 @@ mod tests {
     fn the_safe_frontier_is_the_minimum_over_every_required_replica() {
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
-        acks.record(ack("ra", &[("A", 9), ("B", 4)], &["ra", "rb"])).unwrap();
-        acks.record(ack("rb", &[("A", 5), ("B", 6)], &["ra", "rb"])).unwrap();
+        acks.record(ack("ra", &[("A", 9), ("B", 4)], &["ra", "rb"]))
+            .unwrap();
+        acks.record(ack("rb", &[("A", 5), ("B", 6)], &["ra", "rb"]))
+            .unwrap();
 
         match acks.evidence(&["ra".into(), "rb".into()]) {
             ReclamationEvidence::SafeThrough { frontier, covered } => {
@@ -415,7 +439,8 @@ mod tests {
         // anything is safe through.
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
-        acks.record(ack("ra", &[("A", 4), ("C", 9)], &["ra", "rb"])).unwrap();
+        acks.record(ack("ra", &[("A", 4), ("C", 9)], &["ra", "rb"]))
+            .unwrap();
         acks.record(ack("rb", &[("A", 4)], &["ra", "rb"])).unwrap();
 
         match acks.evidence(&["ra".into(), "rb".into()]) {
@@ -437,7 +462,8 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         {
             let mut acks = store(&dir);
-            acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"])).unwrap();
+            acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"]))
+                .unwrap();
         }
         let recovered = store(&dir);
         match recovered.evidence(&["ra".into(), "rb".into()]) {
@@ -464,7 +490,11 @@ mod tests {
 
         let recovered = store(&dir);
         assert_eq!(
-            recovered.get("rb").unwrap().origin_sequence_high_water.get("A"),
+            recovered
+                .get("rb")
+                .unwrap()
+                .origin_sequence_high_water
+                .get("A"),
             Some(&7),
         );
     }

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

@@ -146,19 +146,23 @@ impl MembershipStore {
     /// directory. Membership is what will later authorise deleting history, so
     /// it is written with the same care as the log it will authorise deleting.
     fn persist(&self) -> Result<(), MembershipError> {
-        let Some(cluster) = &self.cluster else { return Ok(()) };
+        let Some(cluster) = &self.cluster else {
+            return Ok(());
+        };
         if let Some(parent) = self.path.parent() {
             std::fs::create_dir_all(parent).map_err(|e| MembershipError::Io(e.to_string()))?;
         }
         let temp = self.path.with_extension("tmp");
-        let bytes = serde_json::to_vec_pretty(cluster)
-            .map_err(|e| MembershipError::Io(e.to_string()))?;
+        let bytes =
+            serde_json::to_vec_pretty(cluster).map_err(|e| MembershipError::Io(e.to_string()))?;
         {
             use std::io::Write;
-            let mut file = std::fs::File::create(&temp)
+            let mut file =
+                std::fs::File::create(&temp).map_err(|e| MembershipError::Io(e.to_string()))?;
+            file.write_all(&bytes)
+                .map_err(|e| MembershipError::Io(e.to_string()))?;
+            file.sync_all()
                 .map_err(|e| MembershipError::Io(e.to_string()))?;
-            file.write_all(&bytes).map_err(|e| MembershipError::Io(e.to_string()))?;
-            file.sync_all().map_err(|e| MembershipError::Io(e.to_string()))?;
         }
         std::fs::rename(&temp, &self.path).map_err(|e| MembershipError::Io(e.to_string()))?;
         if let Some(parent) = self.path.parent() {
@@ -435,7 +439,11 @@ mod tests {
         cluster.suspect_replica("rc").unwrap();
         cluster.mark_seen("rc").unwrap();
         let seen = cluster.get_members().into_iter().next().unwrap();
-        assert_eq!(seen.status, ReplicaStatus::Active, "contact reinstates a suspected replica");
+        assert_eq!(
+            seen.status,
+            ReplicaStatus::Active,
+            "contact reinstates a suspected replica"
+        );
         assert!(seen.last_seen_at_ms.is_some());
 
         cluster.remove_replica("rc").unwrap();
@@ -503,7 +511,10 @@ mod tests {
     fn membership_operations_need_a_cluster() {
         let dir = tempfile::tempdir().unwrap();
         let mut cluster = store(&dir);
-        assert!(matches!(cluster.join_replica("ra", "A"), Err(MembershipError::NoCluster)));
+        assert!(matches!(
+            cluster.join_replica("ra", "A"),
+            Err(MembershipError::NoCluster)
+        ));
         cluster.create_cluster("c1").unwrap();
         assert!(matches!(
             cluster.create_cluster("c2"),
@@ -523,7 +534,10 @@ mod tests {
         cluster.join_replica("ra", "A").unwrap();
         cluster.approve_replica("ra").unwrap();
         assert!(
-            matches!(cluster.approve_replica("ra"), Err(MembershipError::NotJoining(_))),
+            matches!(
+                cluster.approve_replica("ra"),
+                Err(MembershipError::NotJoining(_))
+            ),
             "approving twice is not a silent no-op"
         );
     }
@@ -648,7 +662,9 @@ mod tests {
         let mut cluster = MembershipStore::open(&path).unwrap();
         cluster.create_cluster("c1").unwrap();
         for index in 0..20 {
-            cluster.join_replica(&format!("r{index}"), &format!("N{index}")).unwrap();
+            cluster
+                .join_replica(&format!("r{index}"), &format!("N{index}"))
+                .unwrap();
             let observed = MembershipStore::open(&path).unwrap();
             assert_eq!(
                 observed.get_members().len(),
@@ -656,6 +672,9 @@ mod tests {
                 "every observation is of a complete cluster"
             );
         }
-        assert!(!path.with_extension("tmp").exists(), "no temp file is left at rest");
+        assert!(
+            !path.with_extension("tmp").exists(),
+            "no temp file is left at rest"
+        );
     }
 }

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

@@ -6,7 +6,6 @@
 /// - Routing messages from leader to followers
 /// - Acknowledgment tracking
 /// - Retry logic for lost messages
-
 use crate::distributed_transactions::ReplicationMessage;
 use std::collections::{HashMap, VecDeque};
 use std::sync::atomic::{AtomicU64, Ordering};
@@ -67,7 +66,10 @@ impl PeerReplicationQueue {
     }
 
     pub fn pending_count(&self) -> usize {
-        self.messages.iter().filter(|m| m.status == DeliveryStatus::Pending).count()
+        self.messages
+            .iter()
+            .filter(|m| m.status == DeliveryStatus::Pending)
+            .count()
     }
 
     pub fn next_pending(&mut self) -> Option<TrackedMessage> {
@@ -103,7 +105,8 @@ impl ReplicationManager {
 
     /// Register a peer to receive replication messages
     pub fn register_peer(&mut self, peer_id: String) {
-        self.peer_queues.insert(peer_id.clone(), PeerReplicationQueue::new(peer_id));
+        self.peer_queues
+            .insert(peer_id.clone(), PeerReplicationQueue::new(peer_id));
     }
 
     /// Enqueue a message for replication to all peers

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

@@ -2,7 +2,6 @@
 ///
 /// Decouples ReplicationMessage handling from transport details.
 /// Works with typed messages (ReplicationMessage) rather than raw bytes.
-
 use crate::distributed_transactions::ReplicationMessage;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
@@ -71,7 +70,8 @@ impl ProtocolMetrics {
 
     pub fn record_receive(&self, bytes: usize) {
         self.messages_received.fetch_add(1, Ordering::Relaxed);
-        self.bytes_received.fetch_add(bytes as u64, Ordering::Relaxed);
+        self.bytes_received
+            .fetch_add(bytes as u64, Ordering::Relaxed);
     }
 
     pub fn record_error(&self) {
@@ -79,7 +79,8 @@ impl ProtocolMetrics {
     }
 
     pub fn record_connection_state_change(&self) {
-        self.connection_state_changes.fetch_add(1, Ordering::Relaxed);
+        self.connection_state_changes
+            .fetch_add(1, Ordering::Relaxed);
     }
 
     pub fn get_messages_sent(&self) -> u64 {

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

@@ -8,7 +8,6 @@
  * - Query routing to appropriate shards
  * - Data migration between shards
  */
-
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap, HashSet};
 
@@ -189,7 +188,9 @@ impl ShardManager {
                 }
                 "delete" => {
                     metrics.entry_count = metrics.entry_count.saturating_sub(records_affected);
-                    metrics.size_bytes = metrics.size_bytes.saturating_sub(size_bytes.min(metrics.size_bytes));
+                    metrics.size_bytes = metrics
+                        .size_bytes
+                        .saturating_sub(size_bytes.min(metrics.size_bytes));
                 }
                 _ => {}
             }
@@ -253,7 +254,9 @@ impl ShardManager {
             }
 
             // High write load
-            if write_std_dev > 0.0 && (metrics.writes as f64 - avg_writes).abs() > write_std_dev * 2.0 {
+            if write_std_dev > 0.0
+                && (metrics.writes as f64 - avg_writes).abs() > write_std_dev * 2.0
+            {
                 alerts.push(HotspotAlert {
                     shard_id: metrics.shard_id.clone(),
                     reason: "High write load".to_string(),
@@ -269,7 +272,9 @@ impl ShardManager {
             }
 
             // Data imbalance
-            if entry_std_dev > 0.0 && (metrics.entry_count as f64 - avg_entries).abs() > entry_std_dev * 3.0 {
+            if entry_std_dev > 0.0
+                && (metrics.entry_count as f64 - avg_entries).abs() > entry_std_dev * 3.0
+            {
                 alerts.push(HotspotAlert {
                     shard_id: metrics.shard_id.clone(),
                     reason: "Data imbalance".to_string(),
@@ -297,13 +302,22 @@ impl ShardManager {
         for hotspot in hotspots {
             if hotspot.severity == "high" {
                 // Find the overloaded shard
-                if let Some(shard_range) = self.shard_ranges.iter().find(|r| r.shard_id == hotspot.shard_id) {
+                if let Some(shard_range) = self
+                    .shard_ranges
+                    .iter()
+                    .find(|r| r.shard_id == hotspot.shard_id)
+                {
                     // Split the hash range in half
-                    let mid_hash = (shard_range.start_hash as u128 + shard_range.end_hash as u128) / 2;
+                    let mid_hash =
+                        (shard_range.start_hash as u128 + shard_range.end_hash as u128) / 2;
                     let mid_hash = mid_hash as u64;
 
                     // Create a new shard ID for the split
-                    let new_shard_id = ShardId(format!("{}-split-{}", hotspot.shard_id.0, current_time_ms()));
+                    let new_shard_id = ShardId(format!(
+                        "{}-split-{}",
+                        hotspot.shard_id.0,
+                        current_time_ms()
+                    ));
 
                     operations.push(RebalanceOperation {
                         source_shard: hotspot.shard_id.clone(),
@@ -415,7 +429,10 @@ mod tests {
             ShardingStrategy::ConsistentHash,
         );
 
-        let shards = vec![ShardId("shard-0".to_string()), ShardId("shard-1".to_string())];
+        let shards = vec![
+            ShardId("shard-0".to_string()),
+            ShardId("shard-1".to_string()),
+        ];
         let mut replicas = HashMap::new();
         replicas.insert("shard-0".to_string(), vec!["node-1".to_string()]);
         replicas.insert("shard-1".to_string(), vec!["node-2".to_string()]);
@@ -435,7 +452,10 @@ mod tests {
             ShardingStrategy::ConsistentHash,
         );
 
-        let shards = vec![ShardId("shard-0".to_string()), ShardId("shard-1".to_string())];
+        let shards = vec![
+            ShardId("shard-0".to_string()),
+            ShardId("shard-1".to_string()),
+        ];
         manager.initialize_shards(shards, HashMap::new());
 
         let shard = manager.get_shard_for_key("user123");
@@ -510,7 +530,13 @@ mod tests {
         manager.initialize_shards(shards, HashMap::new());
 
         // Create severe imbalanced load across 3 shards
-        manager.record_shard_operation(&ShardId("shard-0".to_string()), "write", 5.0, 100000, 50000000);
+        manager.record_shard_operation(
+            &ShardId("shard-0".to_string()),
+            "write",
+            5.0,
+            100000,
+            50000000,
+        );
         manager.record_shard_operation(&ShardId("shard-1".to_string()), "write", 5.0, 1000, 500000);
         manager.record_shard_operation(&ShardId("shard-2".to_string()), "write", 5.0, 100, 50000);