create-feltdb 0.7.0 → 0.7.1

package/dist/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.7.0';
+export const FELTDB_PACKAGE_VERSION = '0.7.1';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

package/dist/server-source/crates/feltdb/src/lib.rs

@@ -1175,18 +1175,27 @@ impl FeltDb {
                 }
             }
 
-            // Every precondition held. A write fenced by `expected_version` is a
-            // conditional replacement and behaves as `updateIfVersion` does:
-            // the authority validated version N above and writes N + 1 here,
-            // inside the same lock, so the check and the advance cannot be
-            // separated by another writer.
+            // Every precondition held. The authority owns both ends of the
+            // public document-version lifecycle inside this lock:
             //
-            // Only a version-fenced write advances. An unconditional write
-            // stores the caller's object verbatim, which is what preserves
-            // every existing transaction caller, and a guard-only precondition
-            // writes nothing at all. See
+            // - a create protected by `requireAbsent` writes version 1;
+            // - a write fenced by `expected_version = N` writes N + 1.
+            //
+            // An unconditional write remains verbatim, and a guard-only
+            // precondition writes nothing. See
             // docs/architecture/transaction-version-contract.md.
-            let mut advanced: Vec<AtomicMutation> = Vec::new();
+            let advanced: Vec<AtomicMutation>;
+            let creates: HashSet<(&str, &str)> = preconditions
+                .iter()
+                .filter(|condition| condition.expected_version.is_none())
+                .map(|condition| (condition.capability.as_str(), condition.key.as_str()))
+                .chain(
+                    record_preconditions
+                        .iter()
+                        .filter(|condition| condition.require_absent)
+                        .map(|condition| (condition.capability.as_str(), condition.key.as_str())),
+                )
+                .collect();
             let fenced: HashMap<(&str, &str), u64> = record_preconditions
                 .iter()
                 .filter_map(|condition| {
@@ -1195,15 +1204,19 @@ impl FeltDb {
                         .map(|version| ((condition.capability.as_str(), condition.key.as_str()), version))
                 })
                 .collect();
-            let mutations: &[AtomicMutation] = if fenced.is_empty() {
+            let mutations: &[AtomicMutation] = if fenced.is_empty() && creates.is_empty() {
                 mutations
             } else {
                 advanced = mutations
                     .iter()
                     .map(|mutation| {
-                        let Some(expected) =
-                            fenced.get(&(mutation.capability.as_str(), mutation.key.as_str()))
-                        else {
+                        let record = (mutation.capability.as_str(), mutation.key.as_str());
+                        let version = if creates.contains(&record) {
+                            Some(1)
+                        } else {
+                            fenced.get(&record).map(|expected| expected + 1)
+                        };
+                        let Some(version) = version else {
                             return mutation.clone();
                         };
                         // A delete has no record left to carry a version, so a
@@ -1212,12 +1225,9 @@ impl FeltDb {
                             return mutation.clone();
                         };
                         let mut fields = fields;
-                        // The authority owns the transition. A `__version` the
-                        // caller put in the value is replaced rather than
-                        // honoured, exactly as updateIfVersion strips it,
-                        // because a caller that computes a different next
-                        // version must not be able to install it.
-                        fields.insert("__version".to_string(), Value::from(expected + 1));
+                        // The caller cannot manufacture either the initial or
+                        // next authoritative version.
+                        fields.insert("__version".to_string(), Value::from(version));
                         AtomicMutation {
                             capability: mutation.capability.clone(),
                             key: mutation.key.clone(),

package/dist/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();

package/dist/server-source/crates/feltdb-server/src/main.rs

@@ -41,7 +41,7 @@ use feltdb::{
         Grant, GrantSigner, GrantStore, Subject as GrantSubject,
     },
     cardinality_endpoint::{CardinalityContext, CardinalityDiagnosticResponse},
-    AtomicMutation, AtomicPrecondition,
+    AtomicMutation,
     policy_evaluation::{Actor, PolicyContext, PolicyEvaluator, PolicySubject},
     state_contract::{
         begin_read, compare_schemas, execute_query as execute_state_query, execute_transaction,
@@ -9134,7 +9134,6 @@ async fn commit_transaction(
     // Validate every operation before any of them is turned into a mutation, so
     // a malformed request cannot commit a prefix of the transaction.
     let mut mutations = Vec::with_capacity(request.operations.len());
-    let mut preconditions = Vec::new();
     let mut record_preconditions: Vec<RecordPrecondition> = Vec::new();
     let mut seen = std::collections::HashSet::new();
 
@@ -9173,14 +9172,17 @@ async fn commit_transaction(
             ));
         }
         if operation.require_absent {
-            // The store reads a precondition with no expected version as
-            // "this record must not exist", and evaluates it inside the same
-            // lock as the commit, so there is no window between the check and
-            // the write.
-            preconditions.push(AtomicPrecondition {
+            // Use the public record-precondition path so a lost creation race
+            // is both evaluated under the store lock and returned as a
+            // structured presence conflict. The same condition tells the
+            // authority to assign document version 1 to the created value.
+            record_preconditions.push(RecordPrecondition {
                 capability: operation.collection.clone(),
                 key: key.clone(),
+                require_absent: true,
                 expected_version: None,
+                expected_epoch: None,
+                expected_lease_id: None,
             });
         }
         // A guard attached to a staged write. Previously declared by the
@@ -9216,7 +9218,7 @@ async fn commit_transaction(
             &request.transaction_id,
             None,
             None,
-            &preconditions,
+            &[],
             &record_preconditions,
             &mutations,
             None,

package/package.json

@@ -2,7 +2,7 @@
   "name": "create-feltdb",
   "private": false,
   "description": "Create a new FeltDB application with one command",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "license": "MIT",
   "bin": {
     "create-feltdb": "bin/create-feltdb.js"