@feltdb/core 0.8.4 → 0.8.6

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

@@ -2,7 +2,6 @@
 ///
 /// This module provides tools to understand how collection cardinality is reconstructed
 /// during startup and how it compares to query-time lookups.
-
 use crate::{AtomicMutation, FeltDb};
 use std::collections::HashMap;
 
@@ -61,9 +60,9 @@ pub fn diagnose_cardinality(
 
     CardinalityDiagnostic {
         collection: collection_name.to_string(),
-        persisted_capabilities: vec![],  // Would need access to inner.rows to populate
+        persisted_capabilities: vec![], // Would need access to inner.rows to populate
         persisted_row_counts: HashMap::new(),
-        total_persisted_rows: 0,  // Would need to scan inner.rows
+        total_persisted_rows: 0, // Would need to scan inner.rows
         maintained_count,
         query_capability,
         match_status: if maintained_count == 0 {
@@ -71,7 +70,7 @@ pub fn diagnose_cardinality(
         } else {
             "OK".to_string()
         },
-        delta: 0,  // Can't compute without authoritative row count
+        delta: 0, // Can't compute without authoritative row count
     }
 }
 
@@ -125,7 +124,8 @@ mod tests {
                 },
             ];
 
-            db.apply_atomic_transaction("txn-1", None, &[], &mutations, None).unwrap();
+            db.apply_atomic_transaction("txn-1", None, &[], &mutations, None)
+                .unwrap();
 
             // At this point, cardinality should be 2 for the key "github_webhook_deliveries"
             let count = db.collection_cardinality(capability).unwrap();
@@ -140,14 +140,13 @@ mod tests {
 
         // But if query looks for a DIFFERENT capability:
         let namespaced_capability = "default:github_webhook_deliveries";
-        let count_namespaced = reopened.collection_cardinality(namespaced_capability).unwrap();
+        let count_namespaced = reopened
+            .collection_cardinality(namespaced_capability)
+            .unwrap();
 
         // If the persisted rows were stored under the non-namespaced key,
         // this will return 0 - demonstrating the mismatch
-        println!(
-            "Rows under '{}': {}",
-            capability, count_after
-        );
+        println!("Rows under '{}': {}", capability, count_after);
         println!(
             "Rows under '{}': {}",
             namespaced_capability, count_namespaced
@@ -218,12 +217,15 @@ mod tests {
                 .unwrap();
 
             // Before restart, both formats should be queryable
-            assert_eq!(db.collection_cardinality(&old_format_capability).unwrap(), 2);
-            assert_eq!(db.collection_cardinality(&new_format_capability).unwrap(), 2);
-            println!(
-                "Before restart: old_format={}, new_format={}",
-                2, 2
+            assert_eq!(
+                db.collection_cardinality(&old_format_capability).unwrap(),
+                2
+            );
+            assert_eq!(
+                db.collection_cardinality(&new_format_capability).unwrap(),
+                2
             );
+            println!("Before restart: old_format={}, new_format={}", 2, 2);
         }
 
         // After restart, cardinality is recomputed from persisted log

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

@@ -2,7 +2,6 @@
 ///
 /// This module provides a debug/diagnostic HTTP endpoint that exposes cardinality
 /// reconstruction state without returning actual row data.
-
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

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

@@ -162,11 +162,13 @@ mod tests {
         let probe = envelope_at("A", 2, "r2");
         let probe_bytes = serde_json::to_string(&probe).expect("serialize").len();
 
-        let (mut executor, _dir) =
-            receiver(CausalCapacity::new(usize::MAX, probe_bytes * 2 - 1));
+        let (mut executor, _dir) = receiver(CausalCapacity::new(usize::MAX, probe_bytes * 2 - 1));
         let outcomes = fill_with_blocked(&mut executor, "A", 3);
 
-        assert!(matches!(outcomes[0], ReceiveOutcome::PendingDependencies { .. }));
+        assert!(matches!(
+            outcomes[0],
+            ReceiveOutcome::PendingDependencies { .. }
+        ));
         assert!(
             matches!(outcomes[1], ReceiveOutcome::CapacityDeferred { .. }),
             "the second envelope breaches a bound one byte short of two, got {:?}",
@@ -185,7 +187,10 @@ mod tests {
         let large = envelope_at("A", 3, &"L".repeat(4096));
         let small_bytes = serde_json::to_string(&small).expect("serialize").len();
         let large_bytes = serde_json::to_string(&large).expect("serialize").len();
-        assert!(large_bytes > small_bytes * 2, "the fixture must actually differ in size");
+        assert!(
+            large_bytes > small_bytes * 2,
+            "the fixture must actually differ in size"
+        );
 
         let (mut executor, _dir) = receiver(CausalCapacity::new(usize::MAX, small_bytes + 16));
 
@@ -240,7 +245,11 @@ mod tests {
             .expect("submit");
 
         match outcome {
-            SubmitOutcome::CapacityExceeded { limit_entries, pending_entries, .. } => {
+            SubmitOutcome::CapacityExceeded {
+                limit_entries,
+                pending_entries,
+                ..
+            } => {
                 assert_eq!(limit_entries, 4);
                 assert_eq!(pending_entries, 4);
             }
@@ -271,7 +280,10 @@ mod tests {
         let (mut executor, _dir) = receiver(CausalCapacity::new(2, usize::MAX));
 
         let outcomes = fill_with_blocked(&mut executor, "A", 3);
-        assert!(matches!(outcomes[2], ReceiveOutcome::CapacityDeferred { .. }));
+        assert!(matches!(
+            outcomes[2],
+            ReceiveOutcome::CapacityDeferred { .. }
+        ));
         assert_eq!(executor.deferred_causal_count(), 1);
 
         // Deliver the missing dependency A:1, which releases the whole chain.
@@ -280,8 +292,16 @@ mod tests {
             .expect("receive");
         assert!(matches!(released, ReceiveOutcome::Applied { .. }));
 
-        assert_eq!(executor.pending_causal_count(), 0, "nothing is left waiting");
-        assert_eq!(executor.deferred_causal_count(), 0, "nothing is left deferred");
+        assert_eq!(
+            executor.pending_causal_count(),
+            0,
+            "nothing is left waiting"
+        );
+        assert_eq!(
+            executor.deferred_causal_count(),
+            0,
+            "nothing is left deferred"
+        );
         let applied = executor
             .get_replica_state("receiver")
             .map(|replica| replica.operations_applied)
@@ -300,7 +320,10 @@ mod tests {
             .get_replica_state("receiver")
             .map(|replica| replica.operations_applied)
             .unwrap_or(0);
-        assert_eq!(applied, 0, "nothing may be applied while its dependency is missing");
+        assert_eq!(
+            applied, 0,
+            "nothing may be applied while its dependency is missing"
+        );
         assert_eq!(executor.causal_frontier().get("A"), 0);
     }
 
@@ -327,13 +350,20 @@ mod tests {
         // log a second time.
         let (mut executor, _dir) = receiver(CausalCapacity::new(1, usize::MAX));
         let outcomes = fill_with_blocked(&mut executor, "A", 2);
-        assert!(matches!(outcomes[1], ReceiveOutcome::CapacityDeferred { .. }));
+        assert!(matches!(
+            outcomes[1],
+            ReceiveOutcome::CapacityDeferred { .. }
+        ));
 
         let again = executor
             .receive_replicated(message(envelope_at("A", 3, "r3")), zero_version())
             .expect("receive");
         assert_eq!(again, ReceiveOutcome::AlreadyKnown);
-        assert_eq!(executor.deferred_causal_count(), 1, "still one deferred entry");
+        assert_eq!(
+            executor.deferred_causal_count(),
+            1,
+            "still one deferred entry"
+        );
     }
 
     #[test]
@@ -377,7 +407,10 @@ mod tests {
             .expect("executor");
             executor.set_causal_capacity(CausalCapacity::new(2, usize::MAX));
             let outcomes = fill_with_blocked(&mut executor, "A", 3);
-            assert!(matches!(outcomes[2], ReceiveOutcome::CapacityDeferred { .. }));
+            assert!(matches!(
+                outcomes[2],
+                ReceiveOutcome::CapacityDeferred { .. }
+            ));
             assert_eq!(executor.pending_causal_count(), 2);
             assert_eq!(executor.deferred_causal_count(), 1);
         }
@@ -392,13 +425,20 @@ mod tests {
         recovered.set_causal_capacity(CausalCapacity::new(2, usize::MAX));
         let replayed = recovered.load_from_disk(log_path).expect("recover");
 
-        assert_eq!(replayed, 3, "all three envelopes were durable before the restart");
+        assert_eq!(
+            replayed, 3,
+            "all three envelopes were durable before the restart"
+        );
         assert_eq!(
             recovered.pending_causal_count(),
             2,
             "recovery honours the same bound the live path does"
         );
-        assert_eq!(recovered.deferred_causal_count(), 1, "the excess is deferred, not lost");
+        assert_eq!(
+            recovered.deferred_causal_count(),
+            1,
+            "the excess is deferred, not lost"
+        );
 
         // And the dependency still releases everything after the restart.
         recovered
@@ -446,7 +486,11 @@ mod tests {
             executor.causal_barrier.pending_keys()
         };
 
-        assert_eq!(split(3), split(3), "the same log and bound recover identically");
+        assert_eq!(
+            split(3),
+            split(3),
+            "the same log and bound recover identically"
+        );
         assert_eq!(split(3).len(), 3);
     }
 }