@feltdb/core 0.8.3 → 0.8.5

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

@@ -14,9 +14,8 @@
 //! - Explicit reconciliation (no automatic merge)
 
 use crate::state_model::{
-    StateId, StateRevision, StateStore, StateTopology, Relationship,
-    SemanticDiff, ConflictClassification, ReconciliationPlan,
-    StateReconciliationResult, STATE_MODEL_VERSION,
+    ConflictClassification, ReconciliationPlan, Relationship, SemanticDiff, StateId,
+    StateReconciliationResult, StateRevision, StateStore, StateTopology, STATE_MODEL_VERSION,
 };
 use crate::FeltDb;
 use std::sync::Arc;
@@ -47,8 +46,8 @@ impl FeltDBStateSystem {
     /// ```ignore
     /// let db = FeltDb::open("./data")?;
     /// let store = FeltDBStateSystem::create_store(&Arc::new(db))?;
-    /// let initial = store.create(json_string, "app-authority")?;
-    /// let current = store.current()?;
+    /// let initial = store.create("docs:1", json_string, "app-authority")?;
+    /// let same = store.get(&initial.id).expect("retrieved by identity");
     /// ```
     pub fn create_store(db: &Arc<FeltDb>) -> Result<StateStore, String> {
         StateStore::with_feltdb(db.clone())
@@ -81,7 +80,9 @@ impl FeltDBStateSystem {
         2. Use FeltDBStateSystem::create_store(&Arc::new(db)) to initialize state
         3. Call store.create() for initial state
         4. Call store.commit() for transitions
-        5. Call store.current() to retrieve the working state
+        5. Call store.get(&id) to retrieve a revision by identity
+           (the store does not track which revision is "current" — see
+            StateStore's own documentation for why that is a separate concern)
         6. Use StateTopology to inspect causal relationships
         7. Use SemanticDiff to compute changes between states
         8. Use ConflictClassification to analyze divergence
@@ -104,7 +105,10 @@ impl FeltDBStateSystem {
 #[cfg(test)]
 mod facade_tests {
     use super::*;
-    use crate::{ConflictClass, SemanticDiff, StateTopology, Relationship, ConflictClassification, state_model::StateStore};
+    use crate::{
+        state_model::StateStore, ConflictClass, ConflictClassification, Relationship, SemanticDiff,
+        StateTopology,
+    };
     use serde_json::json;
 
     #[test]
@@ -112,11 +116,17 @@ mod facade_tests {
         // For testing, use new_volatile() - production must use create_store(&db)
         let store = StateStore::new_volatile();
         let initial = store
-            .create(r#"{"data":"test"}"#.to_string(), "test-auth".to_string())
+            .create(
+                "docs:1",
+                r#"{"data":"test"}"#.to_string(),
+                "test-auth".to_string(),
+            )
             .expect("Failed to create initial state");
-        
-        let current = store.current().expect("Failed to get current state");
-        assert_eq!(current.id, initial.id);
+
+        let stored = store
+            .get(&initial.id)
+            .expect("the revision is retrievable by identity");
+        assert_eq!(stored.id, initial.id);
     }
 
     #[test]
@@ -128,19 +138,21 @@ mod facade_tests {
     fn test_facade_comprehensive_workflow() {
         // Initialize - for testing, use new_volatile()
         let store = StateStore::new_volatile();
-        
+
         // Create initial state
         let initial = store
             .create(
+                "docs:1",
                 r#"{"users":{"alice":100}}"#.to_string(),
                 "app-auth".to_string(),
             )
             .expect("Failed to create");
 
-        // Verify current
-        assert_eq!(store.current().unwrap().id, initial.id);
+        // Verify the revision is retrievable by identity. The store tracks no
+        // "current" pointer; the caller holds the ids it cares about.
+        assert_eq!(store.get(&initial.id).unwrap().id, initial.id);
 
-        // Branch 1: alice updates
+        // Divergence 1: alice updates
         let branch1 = store
             .commit(
                 r#"{"users":{"alice":150}}"#.to_string(),
@@ -149,11 +161,7 @@ mod facade_tests {
             )
             .expect("Failed branch 1");
 
-        store
-            .create_branch("alice-branch".to_string(), branch1.id.clone())
-            .expect("Failed to create alice-branch");
-
-        // Branch 2: create from initial
+        // Divergence 2: from the same parent
         let branch2 = store
             .commit(
                 r#"{"users":{"alice":100,"bob":50}}"#.to_string(),
@@ -162,10 +170,6 @@ mod facade_tests {
             )
             .expect("Failed branch 2");
 
-        store
-            .create_branch("bob-branch".to_string(), branch2.id.clone())
-            .expect("Failed to create bob-branch");
-
         // Inspect topology
         let mut topology = StateTopology::new();
         topology.add_revision(initial.clone());
@@ -181,12 +185,10 @@ mod facade_tests {
         }
 
         // Compute diff using JSON values
-        let initial_json: serde_json::Value = serde_json::from_str(
-            r#"{"users":{"alice":100}}"#,
-        ).unwrap();
-        let branch1_json: serde_json::Value = serde_json::from_str(
-            r#"{"users":{"alice":150}}"#,
-        ).unwrap();
+        let initial_json: serde_json::Value =
+            serde_json::from_str(r#"{"users":{"alice":100}}"#).unwrap();
+        let branch1_json: serde_json::Value =
+            serde_json::from_str(r#"{"users":{"alice":150}}"#).unwrap();
         let diff = SemanticDiff::compute(&initial_json, &branch1_json);
         assert!(!diff.changes.is_empty());
 
@@ -199,16 +201,16 @@ mod facade_tests {
     fn test_facade_immutability() {
         let store = StateStore::new_volatile();
         let initial = store
-            .create(r#"{"v":1}"#.to_string(), "auth".to_string())
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
             .unwrap();
-        
+
         let initial_id = initial.id.clone();
-        
+
         // Create another state
         let second = store
             .commit(r#"{"v":2}"#.to_string(), &initial, "auth".to_string())
             .unwrap();
-        
+
         // Verify first state is unchanged
         assert_eq!(store.get(&initial_id).unwrap().content, r#"{"v":1}"#);
         assert_eq!(initial_id, initial.id);
@@ -218,12 +220,16 @@ mod facade_tests {
     fn test_facade_restart_recovery() {
         let store1 = StateStore::new_volatile();
         let initial = store1
-            .create(r#"{"data":"test"}"#.to_string(), "auth".to_string())
+            .create(
+                "docs:1",
+                r#"{"data":"test"}"#.to_string(),
+                "auth".to_string(),
+            )
             .unwrap();
-        
+
         // Simulate restart: new store instance
         let _store2 = StateStore::new_volatile();
-        
+
         // Note: In real scenario, store would load from persistent storage
         // Here we demonstrate the API contract: states retrieved by id are valid
         assert!(store1.exists(&initial.id));
@@ -233,44 +239,62 @@ mod facade_tests {
     fn test_facade_authority_neutrality() {
         let store = StateStore::new_volatile();
         let initial = store
-            .create(r#"{"balance":100}"#.to_string(), "alice".to_string())
+            .create(
+                "docs:1",
+                r#"{"balance":100}"#.to_string(),
+                "alice".to_string(),
+            )
             .unwrap();
-        
+
         let update1 = store
-            .commit(r#"{"balance":150}"#.to_string(), &initial, "alice".to_string())
+            .commit(
+                r#"{"balance":150}"#.to_string(),
+                &initial,
+                "alice".to_string(),
+            )
             .unwrap();
-        
+
         let update2 = store
-            .commit(r#"{"balance":150}"#.to_string(), &initial, "bob".to_string())
+            .commit(
+                r#"{"balance":150}"#.to_string(),
+                &initial,
+                "bob".to_string(),
+            )
             .unwrap();
-        
-        // Same content, different authorities produce same id
+
+        // The same state, from the same parent, is the same historical fact —
+        // so it is one revision, whoever committed it. Authority is recorded
+        // but takes no part in identity.
         assert_eq!(update1.id, update2.id);
-        
-        // But authorities are recorded for audit
+        assert_eq!(update1.content_id, update2.content_id);
+
+        // And because authority takes no part in identity, the second commit
+        // is a no-op that returns what was already recorded. The authority on a
+        // revision is whoever first committed that historical fact, not
+        // whoever last asked for it.
         assert_eq!(update1.authority, "alice");
-        assert_eq!(update2.authority, "bob");
+        assert_eq!(update2.authority, "alice");
     }
 
     #[test]
     fn test_facade_read_only_operations() {
         let store = StateStore::new_volatile();
         let initial = store
-            .create(r#"{"v":1}"#.to_string(), "auth".to_string())
+            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
             .unwrap();
-        
+
         let update = store
             .commit(r#"{"v":2}"#.to_string(), &initial, "auth".to_string())
             .unwrap();
-        
+
         // Topology operations should not mutate
         let mut topology = StateTopology::new();
         topology.add_revision(initial.clone());
         topology.add_revision(update.clone());
-        
+
         let rel = topology.relationship(&initial.id, &update.id);
         assert!(matches!(rel, Relationship::Ancestor));
-        
+
         // Verify both states still exist unchanged
         assert_eq!(store.get(&initial.id).unwrap().id, initial.id);
         assert_eq!(store.get(&update.id).unwrap().id, update.id);
@@ -281,9 +305,13 @@ mod facade_tests {
         // This test verifies we can use the state system without any .git access
         let store = StateStore::new_volatile();
         let state = store
-            .create(r#"{"test":"no-git"}"#.to_string(), "auth".to_string())
+            .create(
+                "docs:1",
+                r#"{"test":"no-git"}"#.to_string(),
+                "auth".to_string(),
+            )
             .expect("State creation should work without .git");
-        
+
         // Topology and diff operations should work without git
         let mut topology = StateTopology::new();
         topology.add_revision(state.clone());

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

@@ -2,7 +2,6 @@
 ///
 /// Produces SHA-256 hashes of canonical state serializations.
 /// Invariant: same state → same hash, different state → different hash (except negligible crypto collision)
-
 use serde_json::{json, Value};
 use std::collections::BTreeMap;
 
@@ -27,7 +26,8 @@ impl CanonicalState {
 
     /// Get a record
     pub fn get_record(&self, collection: &str, record_id: &str) -> Option<&Value> {
-        self.records.get(&(collection.to_string(), record_id.to_string()))
+        self.records
+            .get(&(collection.to_string(), record_id.to_string()))
     }
 
     /// Canonical serialization for hashing (deterministic ordering)