@lix-js/sdk 0.6.0-preview.3 → 0.6.0-preview.5

package/dist-engine-src/src/functions/state.rs

@@ -1,14 +1,14 @@
 use serde_json::Value as JsonValue;
 use std::sync::Arc;
 
-use crate::entity_identity::EntityIdentity;
+use crate::entity_pk::EntityPk;
 use crate::functions::{DeterministicMode, DeterministicSequence};
 use crate::json_store::NormalizedJson;
 use crate::live_state::{LiveStateReader, LiveStateRowRequest, MaterializedLiveStateRow};
 use crate::storage::StorageWriteSet;
 use crate::untracked_state::UntrackedStateContext;
 use crate::untracked_state::UntrackedStateRow;
-use crate::GLOBAL_VERSION_ID;
+use crate::GLOBAL_BRANCH_ID;
 use crate::{LixError, NullableKeyFilter};
 
 pub(crate) const DETERMINISTIC_MODE_KEY: &str = "lix_deterministic_mode";
@@ -78,8 +78,8 @@ async fn load_key_value_row(
     live_state
         .load_row(&LiveStateRowRequest {
             schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
-            version_id: GLOBAL_VERSION_ID.to_string(),
-            entity_id: EntityIdentity::single(key),
+            branch_id: GLOBAL_BRANCH_ID.to_string(),
+            entity_pk: EntityPk::single(key),
             file_id: NullableKeyFilter::Null,
         })
         .await
@@ -154,7 +154,7 @@ fn deterministic_key_value_row(
     timestamp: &str,
 ) -> Result<UntrackedStateRow, LixError> {
     Ok(UntrackedStateRow {
-        entity_id: crate::entity_identity::EntityIdentity::single(key),
+        entity_pk: crate::entity_pk::EntityPk::single(key),
         schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
         file_id: None,
         snapshot_content: Some(snapshot_content.to_string()),
@@ -162,17 +162,15 @@ fn deterministic_key_value_row(
         created_at: timestamp.to_string(),
         updated_at: timestamp.to_string(),
         global: true,
-        version_id: GLOBAL_VERSION_ID.to_string(),
+        branch_id: GLOBAL_BRANCH_ID.to_string(),
     })
 }
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
-    use crate::backend::testing::UnitTestBackend;
     use crate::live_state::{LiveStateContext, LiveStateRowRequest};
     use crate::storage::StorageContext;
+    use crate::storage::{InMemoryStorageBackend, StorageReadOptions, StorageWriteOptions};
 
     use super::*;
 
@@ -186,10 +184,13 @@ mod tests {
 
     #[tokio::test]
     async fn missing_mode_is_disabled() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
 
         let mode = load_mode(&reader)
             .await
@@ -200,10 +201,9 @@ mod tests {
 
     #[tokio::test]
     async fn valid_mode_decodes_flags() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        crate::test_support::seed_global_version_head(storage.clone()).await;
+        crate::test_support::seed_global_branch_head(storage.clone()).await;
         write_test_key_value(
             storage.clone(),
             DETERMINISTIC_MODE_KEY,
@@ -214,7 +214,11 @@ mod tests {
         )
         .await;
 
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let mode = load_mode(&reader).await.expect("valid mode should decode");
 
         assert_eq!(
@@ -228,10 +232,13 @@ mod tests {
 
     #[tokio::test]
     async fn missing_sequence_is_uninitialized() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
 
         let sequence = load_sequence(&reader)
             .await
@@ -242,10 +249,9 @@ mod tests {
 
     #[tokio::test]
     async fn valid_sequence_decodes_highest_seen() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        crate::test_support::seed_global_version_head(storage.clone()).await;
+        crate::test_support::seed_global_branch_head(storage.clone()).await;
         write_test_key_value(
             storage.clone(),
             DETERMINISTIC_SEQUENCE_KEY,
@@ -253,7 +259,11 @@ mod tests {
         )
         .await;
 
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let sequence = load_sequence(&reader)
             .await
             .expect("valid sequence should decode");
@@ -264,16 +274,11 @@ mod tests {
 
     #[tokio::test]
     async fn write_sequence_persists_untracked_global_key_value() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        crate::test_support::seed_global_version_head(storage.clone()).await;
-        let mut tx = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
+        crate::test_support::seed_global_branch_head(storage.clone()).await;
 
-        let mut writes = StorageWriteSet::new();
+        let mut writes = storage.new_write_set();
         stage_sequence(
             &mut writes,
             DeterministicSequence { highest_seen: 7 },
@@ -281,20 +286,20 @@ mod tests {
         )
         .await
         .expect("sequence should stage");
-        writes
-            .apply(&mut tx.as_mut())
-            .await
-            .expect("sequence should apply");
-        tx.commit().await.expect("transaction should commit");
-
-        let reader = live_state.reader(storage.clone());
+        storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .expect("sequence should commit");
+
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let row = reader
             .load_row(&LiveStateRowRequest {
                 schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
-                version_id: GLOBAL_VERSION_ID.to_string(),
-                entity_id: crate::entity_identity::EntityIdentity::single(
-                    DETERMINISTIC_SEQUENCE_KEY,
-                ),
+                branch_id: GLOBAL_BRANCH_ID.to_string(),
+                entity_pk: crate::entity_pk::EntityPk::single(DETERMINISTIC_SEQUENCE_KEY),
                 file_id: NullableKeyFilter::Null,
             })
             .await
@@ -311,26 +316,20 @@ mod tests {
     }
 
     async fn write_test_key_value(storage: StorageContext, key: &str, value: JsonValue) {
-        let mut tx = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let snapshot_content = serde_json::to_string(&serde_json::json!({
             "key": key,
             "value": value,
         }))
         .expect("snapshot should serialize");
-        let mut writes = StorageWriteSet::new();
+        let mut writes = storage.new_write_set();
         let row = deterministic_key_value_row(key, &snapshot_content, "1970-01-01T00:00:00.000Z")
             .expect("test key-value should canonicalize");
         UntrackedStateContext::new()
             .writer(&mut writes)
             .stage_rows(std::iter::once(row.as_ref()))
             .expect("test key-value should stage");
-        writes
-            .apply(&mut tx.as_mut())
-            .await
-            .expect("test key-value should apply");
-        tx.commit().await.expect("transaction should commit");
+        storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .expect("test key-value should commit");
     }
 }