@feltdb/core 0.9.1 → 0.10.0

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

@@ -2191,7 +2191,7 @@ fn execute_transaction_with_policies(
             != Some(payload_hash.as_str())
         {
             return Err(StateFailure::new(
-                "CONFLICT",
+                "IDEMPOTENCY_CONFLICT",
                 "transaction ID was already committed with a different canonical payload",
             ));
         }
@@ -2227,12 +2227,14 @@ fn execute_transaction_with_policies(
             audit,
         });
     }
-    let snapshot = db.state_rows().map_err(StateFailure::storage)?;
     let namespace = request
         .state_namespace
         .as_deref()
         .unwrap_or(&request.application_id)
         .to_string();
+    let snapshot = db
+        .state_rows_for_namespace(&namespace)
+        .map_err(StateFailure::storage)?;
     // Record preconditions are collected here and evaluated by the store,
     // inside the same lock as the writes. Evaluating them against `snapshot`
     // alongside the counters below would reintroduce exactly the gap they
@@ -2592,6 +2594,16 @@ fn execute_transaction_with_policies(
                 }
                 return failure;
             }
+            if let FlowError::RevisionConflict { expected, actual } = &error {
+                let mut failure =
+                    StateFailure::new("PRECONDITION_FAILED", &error.to_string());
+                failure.transaction = Some(transaction_id.clone());
+                failure.causal_position = db.sequence().ok();
+                failure.resource = Some("authority_revision".into());
+                failure.expected = Some(Value::from(*expected));
+                failure.actual = Some(Value::from(*actual));
+                return failure;
+            }
             let text = error.to_string();
             if text.contains("PRECONDITION_FAILED") {
                 let mut failure = StateFailure::new("PRECONDITION_FAILED", &text);
@@ -3270,6 +3282,39 @@ mod tests {
         assert_eq!(failure.actual, Some(Value::from(1)));
     }
     #[test]
+    fn stale_authority_revision_is_a_structured_precondition_failure() {
+        let db = db("authority-revision-precondition");
+        let schema = schema();
+        let mut request = TransactionRequest {
+            transaction_id: Some("initial".into()),
+            tenant_id: "tenant".into(),
+            application_id: "app".into(),
+            revision_id: "rev".into(),
+            schema_version: 1,
+            state_namespace: None,
+            causal_parent: None,
+            authorization: auth(),
+            preconditions: vec![],
+            operations: vec![TransactionOperation {
+                kind: TransactionOperationKind::Insert,
+                collection: "incidents".into(),
+                id: "one".into(),
+                value: serde_json::json!({"title":"First"}),
+                if_version: None,
+            }],
+        };
+        execute_transaction(&db, &schema, &request, None).unwrap();
+        request.transaction_id = Some("stale-parent".into());
+        request.causal_parent = Some(0);
+        request.operations[0].id = "two".into();
+
+        let failure = execute_transaction(&db, &schema, &request, None).unwrap_err();
+        assert_eq!(failure.code, "PRECONDITION_FAILED");
+        assert_eq!(failure.resource.as_deref(), Some("authority_revision"));
+        assert_eq!(failure.expected, Some(Value::from(0)));
+        assert_eq!(failure.actual, Some(Value::from(1)));
+    }
+    #[test]
     fn explicit_transaction_id_is_bound_to_canonical_payload_across_restart() {
         let path = std::env::temp_dir().join(format!(
             "feltdb-content-id-{}-{}.log",
@@ -3317,7 +3362,7 @@ mod tests {
         let mut changed = request.clone();
         changed.operations[0].value = serde_json::json!({"title":"Changed"});
         let failure = execute_transaction(&reopened, &schema, &changed, None).unwrap_err();
-        assert_eq!(failure.code, "CONFLICT");
+        assert_eq!(failure.code, "IDEMPOTENCY_CONFLICT");
         assert!(failure.message.contains("different canonical payload"));
         std::fs::remove_file(path).ok();
     }