@feltdb/core 0.7.0 → 0.7.2

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

@@ -28,12 +28,9 @@
 //! different numbers that happen to share a name, and fencing on the wrong one
 //! would compare a caller's value against something the caller never sees.
 //!
-//! `__version` is owned by the writer: the client sets it to 1 on insert and
-//! single-record CAS increments it. A transaction `set` writes the value it is
-//! given, so a caller that wants successive fenced transactions to exclude each
-//! other must advance `__version` in the value it writes. That is asserted
-//! below rather than assumed, because a fence that silently stops fencing is
-//! worse than no fence.
+//! The authority owns conditional transaction versions: `requireAbsent`
+//! creates version 1 and a version-fenced write of N stores N + 1. Both happen
+//! inside the same lock as validation. Unconditional writes remain verbatim.
 
 #[cfg(test)]
 mod tests {
@@ -401,6 +398,7 @@ mod tests {
         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);
 
         let error = guarded(
             &db,
@@ -807,9 +805,7 @@ mod tests {
     }
 
     #[test]
-    fn a_transaction_insert_keeps_the_callers_value_and_the_authority_assigns_nothing() {
-        // Insert remains the client's: Collection.insert supplies __version 1,
-        // which is where record versioning begins.
+    fn a_transaction_create_gets_authority_version_one_and_can_be_fenced_immediately() {
         let dir = TempDir::new().unwrap();
         let db = db(&dir);
 
@@ -817,10 +813,19 @@ mod tests {
             &db,
             "tx-insert",
             &[RecordPrecondition { require_absent: true, ..precondition("cells", "new") }],
-            &[set("cells", "new", json!({ "id": "new", "__version": 1 }))],
+            &[set("cells", "new", json!({ "id": "new", "__version": 999, "state": "created" }))],
         )
         .expect("commits");
-        assert_eq!(version_of(&db, "cells", "new"), 1, "the caller's value, stored as given");
+        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" }))],
+        )
+        .expect("the newly created version can be fenced immediately");
+        assert_eq!(version_of(&db, "cells", "new"), 2);
 
         let missing = guarded(
             &db,
@@ -834,6 +839,33 @@ mod tests {
         );
     }
 
+    #[test]
+    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 first = guarded(
+            &db,
+            "tx-create-once",
+            &[absent.clone()],
+            &[set("cells", "new", json!({ "id": "new", "delivery": 1 }))],
+        )
+        .expect("first delivery commits");
+        assert!(!first.duplicate);
+
+        let replay = guarded(
+            &db,
+            "tx-create-once",
+            &[absent],
+            &[set("cells", "new", json!({ "id": "new", "delivery": 2 }))],
+        )
+        .expect("replay returns the original transaction result");
+        assert!(replay.duplicate);
+        assert_eq!(version_of(&db, "cells", "new"), 1);
+        assert_eq!(field(&db, "cells", "new", "delivery"), 1);
+    }
+
     #[test]
     fn replay_of_a_fenced_transaction_does_not_advance_twice() {
         let dir = TempDir::new().unwrap();