@feltdb/core 0.8.4 → 0.8.6

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

@@ -34,9 +34,7 @@
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        AtomicMutation, FeltDb, FlowError, PreconditionFailure, RecordPrecondition,
-    };
+    use crate::{AtomicMutation, FeltDb, FlowError, PreconditionFailure, RecordPrecondition};
     use serde_json::json;
     use tempfile::TempDir;
 
@@ -60,7 +58,11 @@ mod tests {
     }
 
     fn delete(collection: &str, id: &str) -> AtomicMutation {
-        AtomicMutation { capability: collection.to_string(), key: key(collection, id), value: None }
+        AtomicMutation {
+            capability: collection.to_string(),
+            key: key(collection, id),
+            value: None,
+        }
     }
 
     fn precondition(collection: &str, id: &str) -> RecordPrecondition {
@@ -72,7 +74,10 @@ mod tests {
     }
 
     fn expect_version(collection: &str, id: &str, version: u64) -> RecordPrecondition {
-        RecordPrecondition { expected_version: Some(version), ..precondition(collection, id) }
+        RecordPrecondition {
+            expected_version: Some(version),
+            ..precondition(collection, id)
+        }
     }
 
     fn present(db: &FeltDb, collection: &str, id: &str) -> bool {
@@ -95,7 +100,10 @@ mod tests {
         let mut value = json!({ "id": id, "__version": version });
         if let Some(fields) = extra.as_object() {
             for (name, field) in fields {
-                value.as_object_mut().unwrap().insert(name.clone(), field.clone());
+                value
+                    .as_object_mut()
+                    .unwrap()
+                    .insert(name.clone(), field.clone());
             }
         }
         db.apply_atomic_transaction(
@@ -138,7 +146,11 @@ mod tests {
             "tx-ok",
             &[expect_version("sessions", "s1", 7)],
             &[
-                set("sessions", "s1", json!({ "id": "s1", "__version": 8, "state": "active" })),
+                set(
+                    "sessions",
+                    "s1",
+                    json!({ "id": "s1", "__version": 8, "state": "active" }),
+                ),
                 set("changes", "c1", json!({ "id": "c1" })),
                 delete("outbox", "o1"),
             ],
@@ -148,7 +160,10 @@ mod tests {
         assert_eq!(commit.rows.len(), 3);
         assert_eq!(version_of(&db, "sessions", "s1"), 8);
         assert!(present(&db, "changes", "c1"));
-        assert!(!present(&db, "outbox", "o1"), "the staged delete applied too");
+        assert!(
+            !present(&db, "outbox", "o1"),
+            "the staged delete applied too"
+        );
     }
 
     #[test]
@@ -169,7 +184,11 @@ mod tests {
             "tx-stale",
             &[expect_version("records", "a", 7)],
             &[
-                set("records", "a", json!({ "id": "a", "__version": 8, "written": true })),
+                set(
+                    "records",
+                    "a",
+                    json!({ "id": "a", "__version": 8, "written": true }),
+                ),
                 set("records", "b", json!({ "id": "b", "state": "overwritten" })),
                 set("records", "c", json!({ "id": "c" })),
             ],
@@ -188,13 +207,20 @@ mod tests {
              from a broken deployment"
         );
 
-        assert_eq!(version_of(&db, "records", "a"), 8, "the guarded record is untouched");
+        assert_eq!(
+            version_of(&db, "records", "a"),
+            8,
+            "the guarded record is untouched"
+        );
         assert_eq!(
             field(&db, "records", "b", "state"),
             "original",
             "and so is every other staged record"
         );
-        assert!(!present(&db, "records", "c"), "a staged write to a new record did not appear");
+        assert!(
+            !present(&db, "records", "c"),
+            "a staged write to a new record did not appear"
+        );
     }
 
     #[test]
@@ -213,14 +239,25 @@ mod tests {
             "owner-1-commit",
             &[expect_version("sessions", "session", 12)],
             &[
-                set("sessions", "session", json!({ "id": "session", "__version": 13, "generation": 12 })),
+                set(
+                    "sessions",
+                    "session",
+                    json!({ "id": "session", "__version": 13, "generation": 12 }),
+                ),
                 set("changes", "change-1", json!({ "id": "change-1" })),
                 set("outbox", "outbox-1", json!({ "id": "outbox-1" })),
             ],
         )
         .expect_err("the losing owner must be refused");
 
-        assert!(matches!(failure(error), PreconditionFailure::Version { expected: 12, actual: 13, .. }));
+        assert!(matches!(
+            failure(error),
+            PreconditionFailure::Version {
+                expected: 12,
+                actual: 13,
+                ..
+            }
+        ));
         assert_eq!(
             field(&db, "sessions", "session", "generation"),
             13,
@@ -241,7 +278,10 @@ mod tests {
         guarded(
             &db,
             "tx-epoch-ok",
-            &[RecordPrecondition { expected_epoch: Some(4), ..precondition("cells", "c") }],
+            &[RecordPrecondition {
+                expected_epoch: Some(4),
+                ..precondition("cells", "c")
+            }],
             &[set("cells", "written", json!({ "id": "written" }))],
         )
         .expect("a matching epoch commits");
@@ -250,7 +290,10 @@ mod tests {
         let error = guarded(
             &db,
             "tx-epoch-stale",
-            &[RecordPrecondition { expected_epoch: Some(3), ..precondition("cells", "c") }],
+            &[RecordPrecondition {
+                expected_epoch: Some(3),
+                ..precondition("cells", "c")
+            }],
             &[set("cells", "never", json!({ "id": "never" }))],
         )
         .expect_err("a stale epoch rejects");
@@ -272,15 +315,26 @@ mod tests {
         let dir = TempDir::new().unwrap();
         let db = db(&dir);
         let future = crate::now_ms() as u64 + 600_000;
-        seed(&db, "cells", "c", 1, json!({ "lease": { "leaseId": "lease-a", "expiresAt": future } }));
+        seed(
+            &db,
+            "cells",
+            "c",
+            1,
+            json!({ "lease": { "leaseId": "lease-a", "expiresAt": future } }),
+        );
 
         let hold = |lease: &str| RecordPrecondition {
             expected_lease_id: Some(lease.to_string()),
             ..precondition("cells", "c")
         };
 
-        guarded(&db, "tx-lease-ok", &[hold("lease-a")], &[set("cells", "w1", json!({ "id": "w1" }))])
-            .expect("the held lease commits");
+        guarded(
+            &db,
+            "tx-lease-ok",
+            &[hold("lease-a")],
+            &[set("cells", "w1", json!({ "id": "w1" }))],
+        )
+        .expect("the held lease commits");
         assert!(present(&db, "cells", "w1"));
 
         let error = guarded(
@@ -303,7 +357,13 @@ mod tests {
 
         // An expired lease is not held, so naming it is a conflict: the caller
         // believes it owns something it no longer does.
-        seed(&db, "cells", "expired", 1, json!({ "lease": { "leaseId": "lease-a", "expiresAt": 1u64 } }));
+        seed(
+            &db,
+            "cells",
+            "expired",
+            1,
+            json!({ "lease": { "leaseId": "lease-a", "expiresAt": 1u64 } }),
+        );
         let error = guarded(
             &db,
             "tx-lease-expired",
@@ -336,7 +396,14 @@ mod tests {
             &[set("cells", "w", json!({ "id": "w" }))],
         )
         .expect_err("one failing predicate refuses the whole transaction");
-        assert!(matches!(failure(error), PreconditionFailure::Epoch { expected: 9, actual: 2, .. }));
+        assert!(matches!(
+            failure(error),
+            PreconditionFailure::Epoch {
+                expected: 9,
+                actual: 2,
+                ..
+            }
+        ));
         assert!(!present(&db, "cells", "w"));
 
         // Several records, one of them stale.
@@ -344,11 +411,17 @@ mod tests {
         let error = guarded(
             &db,
             "tx-mixed-2",
-            &[expect_version("cells", "c", 5), expect_version("cells", "d", 99)],
+            &[
+                expect_version("cells", "c", 5),
+                expect_version("cells", "d", 99),
+            ],
             &[set("cells", "w", json!({ "id": "w" }))],
         )
         .expect_err("a failing predicate on any record refuses the transaction");
-        assert!(matches!(failure(error), PreconditionFailure::Version { expected: 99, .. }));
+        assert!(matches!(
+            failure(error),
+            PreconditionFailure::Version { expected: 99, .. }
+        ));
         assert!(!present(&db, "cells", "w"));
     }
 
@@ -367,7 +440,10 @@ mod tests {
         .expect_err("expecting a version of a record that does not exist is a conflict");
         assert_eq!(
             failure(error),
-            PreconditionFailure::Missing { collection: "cells".into(), key: "cells:absent".into() }
+            PreconditionFailure::Missing {
+                collection: "cells".into(),
+                key: "cells:absent".into()
+            }
         );
         assert!(!present(&db, "cells", "w"));
     }
@@ -393,10 +469,18 @@ mod tests {
     fn require_absent_still_means_absent() {
         let dir = TempDir::new().unwrap();
         let db = db(&dir);
-        let absent = |id: &str| RecordPrecondition { require_absent: true, ..precondition("cells", id) };
+        let absent = |id: &str| RecordPrecondition {
+            require_absent: true,
+            ..precondition("cells", id)
+        };
 
-        guarded(&db, "tx-new", &[absent("fresh")], &[set("cells", "fresh", json!({ "id": "fresh" }))])
-            .expect("absent record commits");
+        guarded(
+            &db,
+            "tx-new",
+            &[absent("fresh")],
+            &[set("cells", "fresh", json!({ "id": "fresh" }))],
+        )
+        .expect("absent record commits");
         assert!(present(&db, "cells", "fresh"));
         assert_eq!(version_of(&db, "cells", "fresh"), 1);
 
@@ -409,7 +493,10 @@ mod tests {
         .expect_err("an existing record refuses a require-absent transaction");
         assert_eq!(
             failure(error),
-            PreconditionFailure::Present { collection: "cells".into(), key: "cells:fresh".into() }
+            PreconditionFailure::Present {
+                collection: "cells".into(),
+                key: "cells:fresh".into()
+            }
         );
         assert!(!present(&db, "cells", "other"));
     }
@@ -443,7 +530,10 @@ mod tests {
             &[set("cells", "w", json!({ "id": "w", "n": 2 }))],
         )
         .expect("a committed id replays rather than failing");
-        assert!(retry.duplicate, "the retry is recognised as the same transaction");
+        assert!(
+            retry.duplicate,
+            "the retry is recognised as the same transaction"
+        );
         assert_eq!(
             field(&db, "cells", "w", "n"),
             1,
@@ -498,7 +588,10 @@ mod tests {
             .expect("commits");
         }
         let reopened = FeltDb::open(&path).expect("reopen");
-        assert!(present(&reopened, "cells", "w"), "a guarded commit is as durable as any other");
+        assert!(
+            present(&reopened, "cells", "w"),
+            "a guarded commit is as durable as any other"
+        );
         let retry = reopened
             .apply_atomic_transaction_guarded(
                 "tx-durable",
@@ -547,7 +640,11 @@ mod tests {
                         }
                     }],
                     &[
-                        set("cells", "shared", json!({ "id": "shared", "__version": 2, "by": id })),
+                        set(
+                            "cells",
+                            "shared",
+                            json!({ "id": "shared", "__version": 2, "by": id }),
+                        ),
                         set("cells", second, json!({ "id": second })),
                     ],
                     None,
@@ -556,9 +653,18 @@ mod tests {
             }));
         }
 
-        let outcomes: Vec<_> = handles.into_iter().map(|handle| handle.join().unwrap()).collect();
-        let winners: Vec<_> = outcomes.iter().filter_map(|outcome| outcome.as_ref().ok()).collect();
-        let losers: Vec<_> = outcomes.iter().filter_map(|outcome| outcome.as_ref().err()).collect();
+        let outcomes: Vec<_> = handles
+            .into_iter()
+            .map(|handle| handle.join().unwrap())
+            .collect();
+        let winners: Vec<_> = outcomes
+            .iter()
+            .filter_map(|outcome| outcome.as_ref().ok())
+            .collect();
+        let losers: Vec<_> = outcomes
+            .iter()
+            .filter_map(|outcome| outcome.as_ref().err())
+            .collect();
 
         assert_eq!(winners.len(), 1, "exactly one transaction may commit");
         assert_eq!(losers.len(), 1);
@@ -574,8 +680,14 @@ mod tests {
 
         let loser_record = if winner == "t1" { "c" } else { "b" };
         let winner_record = if winner == "t1" { "b" } else { "c" };
-        assert!(present(&db, "cells", winner_record), "the winner's second write committed");
-        assert!(!present(&db, "cells", loser_record), "the loser wrote neither of its records");
+        assert!(
+            present(&db, "cells", winner_record),
+            "the winner's second write committed"
+        );
+        assert!(
+            !present(&db, "cells", loser_record),
+            "the loser wrote neither of its records"
+        );
     }
 
     // -- the boundary that used to exist ----------------------------------
@@ -638,7 +750,11 @@ mod tests {
         )
         .expect("commits");
 
-        assert_eq!(version_of(&db, "cells", "c"), 2, "validated at 1, written at 2");
+        assert_eq!(
+            version_of(&db, "cells", "c"),
+            2,
+            "validated at 1, written at 2"
+        );
         assert_eq!(field(&db, "cells", "c", "state"), "written");
     }
 
@@ -657,7 +773,11 @@ mod tests {
             &[set("cells", "c", json!({ "id": "c", "__version": 99 }))],
         )
         .expect("commits");
-        assert_eq!(version_of(&db, "cells", "c"), 5, "the authority's transition, not the caller's");
+        assert_eq!(
+            version_of(&db, "cells", "c"),
+            5,
+            "the authority's transition, not the caller's"
+        );
     }
 
     #[test]
@@ -681,10 +801,17 @@ mod tests {
             &[expect_version("cells", "c", 7)],
             &[set("cells", "c", json!({ "id": "c", "by": "second" }))],
         );
-        assert!(second.is_err(), "ifVersion is now a fence: the successor is refused");
+        assert!(
+            second.is_err(),
+            "ifVersion is now a fence: the successor is refused"
+        );
         assert!(matches!(
             failure(second.unwrap_err()),
-            PreconditionFailure::Version { expected: 7, actual: 8, .. }
+            PreconditionFailure::Version {
+                expected: 7,
+                actual: 8,
+                ..
+            }
         ));
         assert_eq!(field(&db, "cells", "c", "by"), "first");
     }
@@ -695,10 +822,20 @@ mod tests {
         let db = db(&dir);
         seed(&db, "cells", "c", 1, json!({}));
 
-        guarded(&db, "s1", &[expect_version("cells", "c", 1)], &[set("cells", "c", json!({ "id": "c" }))])
-            .expect("first");
-        guarded(&db, "s2", &[expect_version("cells", "c", 2)], &[set("cells", "c", json!({ "id": "c" }))])
-            .expect("second, on the advanced version");
+        guarded(
+            &db,
+            "s1",
+            &[expect_version("cells", "c", 1)],
+            &[set("cells", "c", json!({ "id": "c" }))],
+        )
+        .expect("first");
+        guarded(
+            &db,
+            "s2",
+            &[expect_version("cells", "c", 2)],
+            &[set("cells", "c", json!({ "id": "c" }))],
+        )
+        .expect("second, on the advanced version");
         assert_eq!(version_of(&db, "cells", "c"), 3);
     }
 
@@ -712,7 +849,10 @@ mod tests {
         guarded(
             &db,
             "tx-multi",
-            &[expect_version("cells", "a", 1), expect_version("cells", "b", 5)],
+            &[
+                expect_version("cells", "a", 1),
+                expect_version("cells", "b", 5),
+            ],
             &[
                 set("cells", "a", json!({ "id": "a" })),
                 set("cells", "b", json!({ "id": "b" })),
@@ -763,11 +903,19 @@ mod tests {
             "tx-plain",
             None,
             &[],
-            &[set("cells", "c", json!({ "id": "c", "__version": 4, "state": "same" }))],
+            &[set(
+                "cells",
+                "c",
+                json!({ "id": "c", "__version": 4, "state": "same" }),
+            )],
             None,
         )
         .expect("commits");
-        assert_eq!(version_of(&db, "cells", "c"), 4, "unchanged, because nothing fenced it");
+        assert_eq!(
+            version_of(&db, "cells", "c"),
+            4,
+            "unchanged, because nothing fenced it"
+        );
 
         db.apply_atomic_transaction(
             "tx-plain-2",
@@ -799,9 +947,17 @@ mod tests {
         assert!(stale.is_err(), "a stale fence refuses the delete");
         assert!(present(&db, "cells", "c"));
 
-        guarded(&db, "tx-del", &[expect_version("cells", "c", 2)], &[delete("cells", "c")])
-            .expect("the current fence permits it");
-        assert!(!present(&db, "cells", "c"), "fence, then delete; there is no record left to version");
+        guarded(
+            &db,
+            "tx-del",
+            &[expect_version("cells", "c", 2)],
+            &[delete("cells", "c")],
+        )
+        .expect("the current fence permits it");
+        assert!(
+            !present(&db, "cells", "c"),
+            "fence, then delete; there is no record left to version"
+        );
     }
 
     #[test]
@@ -812,17 +968,32 @@ mod tests {
         guarded(
             &db,
             "tx-insert",
-            &[RecordPrecondition { require_absent: true, ..precondition("cells", "new") }],
-            &[set("cells", "new", json!({ "id": "new", "__version": 999, "state": "created" }))],
+            &[RecordPrecondition {
+                require_absent: true,
+                ..precondition("cells", "new")
+            }],
+            &[set(
+                "cells",
+                "new",
+                json!({ "id": "new", "__version": 999, "state": "created" }),
+            )],
         )
         .expect("commits");
-        assert_eq!(version_of(&db, "cells", "new"), 1, "the authority owns the initial version");
+        assert_eq!(
+            version_of(&db, "cells", "new"),
+            1,
+            "the authority owns the initial version"
+        );
 
         guarded(
             &db,
             "tx-update-new",
             &[expect_version("cells", "new", 1)],
-            &[set("cells", "new", json!({ "id": "new", "state": "updated" }))],
+            &[set(
+                "cells",
+                "new",
+                json!({ "id": "new", "state": "updated" }),
+            )],
         )
         .expect("the newly created version can be fenced immediately");
         assert_eq!(version_of(&db, "cells", "new"), 2);
@@ -834,7 +1005,10 @@ mod tests {
             &[set("cells", "absent", json!({ "id": "absent" }))],
         );
         assert!(
-            matches!(failure(missing.unwrap_err()), PreconditionFailure::Missing { .. }),
+            matches!(
+                failure(missing.unwrap_err()),
+                PreconditionFailure::Missing { .. }
+            ),
             "a version-fenced write against an absent record is a conflict, not an insert"
         );
     }
@@ -843,7 +1017,10 @@ mod tests {
     fn replayed_conditional_create_does_not_create_or_advance_twice() {
         let dir = TempDir::new().unwrap();
         let db = db(&dir);
-        let absent = RecordPrecondition { require_absent: true, ..precondition("cells", "new") };
+        let absent = RecordPrecondition {
+            require_absent: true,
+            ..precondition("cells", "new")
+        };
 
         let first = guarded(
             &db,
@@ -872,8 +1049,13 @@ mod tests {
         let db = db(&dir);
         seed(&db, "cells", "c", 1, json!({}));
 
-        guarded(&db, "tx-once", &[expect_version("cells", "c", 1)], &[set("cells", "c", json!({ "id": "c" }))])
-            .expect("commits");
+        guarded(
+            &db,
+            "tx-once",
+            &[expect_version("cells", "c", 1)],
+            &[set("cells", "c", json!({ "id": "c" }))],
+        )
+        .expect("commits");
         assert_eq!(version_of(&db, "cells", "c"), 2);
 
         let replay = guarded(
@@ -884,7 +1066,11 @@ mod tests {
         )
         .expect("a committed id replays");
         assert!(replay.duplicate);
-        assert_eq!(version_of(&db, "cells", "c"), 2, "a replay cannot advance the version again");
+        assert_eq!(
+            version_of(&db, "cells", "c"),
+            2,
+            "a replay cannot advance the version again"
+        );
     }
 
     #[test]
@@ -920,7 +1106,10 @@ mod tests {
                 .map(|_| id)
             }));
         }
-        let outcomes: Vec<_> = handles.into_iter().map(|handle| handle.join().unwrap()).collect();
+        let outcomes: Vec<_> = handles
+            .into_iter()
+            .map(|handle| handle.join().unwrap())
+            .collect();
         assert_eq!(outcomes.iter().filter(|outcome| outcome.is_ok()).count(), 1);
         assert_eq!(
             version_of(&db, "cells", "race"),

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

@@ -1,3 +1,5 @@
+use crate::convergence::VectorClock;
+use serde::{Deserialize, Serialize};
 /// Transaction system - Verified state transitions with atomicity guarantees
 ///
 /// Implements the STATE_MODEL.md specification:
@@ -6,10 +8,7 @@
 /// - Read/write dependency tracking
 /// - Configurable consistency contracts
 /// - Authoritative operation log with derived indexes
-
 use std::collections::{HashMap, HashSet};
-use crate::convergence::VectorClock;
-use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct OperationId {
@@ -316,12 +315,7 @@ impl TransactionExecutor {
             to_version.state_hash = format!("{:x}", hasher.finish());
         }
 
-        StateTransition::new(
-            parent_version,
-            operations,
-            to_version,
-            consistency_contract,
-        )
+        StateTransition::new(parent_version, operations, to_version, consistency_contract)
     }
 
     pub fn mark_applied(&mut self, operation_id: &OperationId) {
@@ -357,8 +351,12 @@ impl CommitValidator {
                     ))
                 }
             }
-            TransitionResult::Aborted { ref reason } => Err(format!("Transaction aborted: {}", reason)),
-            TransitionResult::Failed { ref reason } => Err(format!("Transaction failed: {}", reason)),
+            TransitionResult::Aborted { ref reason } => {
+                Err(format!("Transaction aborted: {}", reason))
+            }
+            TransitionResult::Failed { ref reason } => {
+                Err(format!("Transaction failed: {}", reason))
+            }
         }
     }
 
@@ -376,10 +374,7 @@ impl CommitValidator {
             for op in &transition.operations {
                 for other_op in &other.operations {
                     if op.operation_id == other_op.operation_id {
-                        conflicts.push(format!(
-                            "Duplicate operation: {:?}",
-                            op.operation_id
-                        ));
+                        conflicts.push(format!("Duplicate operation: {:?}", op.operation_id));
                         continue;
                     }
 
@@ -503,8 +498,12 @@ mod tests {
             "system".to_string(),
         );
 
-        let transition1 =
-            executor.execute_transaction("tx1".to_string(), version.clone(), vec![op.clone()], ConsistencyContract::local());
+        let transition1 = executor.execute_transaction(
+            "tx1".to_string(),
+            version.clone(),
+            vec![op.clone()],
+            ConsistencyContract::local(),
+        );
 
         assert!(transition1.is_successful());
         assert_eq!(transition1.operations.len(), 1);
@@ -589,9 +588,7 @@ mod tests {
 
         let conflicts = CommitValidator::detect_conflicts(&transition1, &[transition2]);
         assert!(!conflicts.is_empty());
-        assert!(conflicts
-            .iter()
-            .any(|c| c.contains("Write-write conflict")));
+        assert!(conflicts.iter().any(|c| c.contains("Write-write conflict")));
     }
 
     #[test]