@lix-js/sdk 0.6.0-preview.2 → 0.6.0-preview.4

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

@@ -1,4 +1,4 @@
-//! Engine2 runtime function boundary.
+//! Engine runtime function boundary.
 //!
 //! Sessions prepare one function context per execution. SQL, providers, and
 //! transaction staging receive only a function provider; deterministic mode is

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

@@ -2,7 +2,7 @@ use std::sync::{Arc, Mutex};
 
 use crate::cel::CelFunctionProvider;
 
-/// Engine2-owned runtime function provider trait.
+/// Engine-owned runtime function provider trait.
 pub(crate) trait FunctionProvider: Send {
     fn uuid_v7(&mut self) -> String;
     fn timestamp(&mut self) -> String;
@@ -38,7 +38,7 @@ impl<P> SharedFunctionProvider<P> {
         let guard = self
             .inner
             .lock()
-            .expect("engine2 function provider mutex poisoned");
+            .expect("engine function provider mutex poisoned");
         f(&guard)
     }
 
@@ -46,7 +46,7 @@ impl<P> SharedFunctionProvider<P> {
         let mut guard = self
             .inner
             .lock()
-            .expect("engine2 function provider mutex poisoned");
+            .expect("engine function provider mutex poisoned");
         f(&mut guard)
     }
 }
@@ -115,7 +115,7 @@ where
     }
 }
 
-/// System-backed engine2 function provider.
+/// System-backed engine function provider.
 #[derive(Debug, Default, Clone, Copy)]
 pub(crate) struct SystemFunctionProvider;
 

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

@@ -1,10 +1,13 @@
 use serde_json::Value as JsonValue;
+use std::sync::Arc;
 
 use crate::entity_identity::EntityIdentity;
 use crate::functions::{DeterministicMode, DeterministicSequence};
-use crate::json_store::JsonStoreWriter;
-use crate::live_state::{LiveStateReader, LiveStateRow, LiveStateRowRequest, LiveStateWriter};
-use crate::storage::{StorageReader, StorageWriteSet};
+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::{LixError, NullableKeyFilter};
 
@@ -12,7 +15,6 @@ pub(crate) const DETERMINISTIC_MODE_KEY: &str = "lix_deterministic_mode";
 pub(crate) const DETERMINISTIC_SEQUENCE_KEY: &str = "lix_deterministic_sequence_number";
 
 const KEY_VALUE_SCHEMA_KEY: &str = "lix_key_value";
-const KEY_VALUE_SCHEMA_VERSION: &str = "1";
 
 /// Loads deterministic-mode settings from visible live state.
 ///
@@ -46,16 +48,11 @@ pub(crate) async fn load_sequence(
 ///
 /// The row is untracked global `lix_key_value` state: it is durable local
 /// runtime state, not a changelog fact.
-pub(crate) async fn stage_sequence<S>(
-    writer: &mut LiveStateWriter<S>,
+pub(crate) async fn stage_sequence(
     writes: &mut StorageWriteSet,
-    json_writer: &mut JsonStoreWriter,
     sequence: DeterministicSequence,
     timestamp: &str,
-) -> Result<(), LixError>
-where
-    S: StorageReader,
-{
+) -> Result<(), LixError> {
     let snapshot_content = serde_json::to_string(&serde_json::json!({
         "key": DETERMINISTIC_SEQUENCE_KEY,
         "value": sequence.highest_seen,
@@ -66,18 +63,18 @@ where
             format!("deterministic sequence snapshot serialization failed: {error}"),
         )
     })?;
-    let row = deterministic_key_value_row(
-        DETERMINISTIC_SEQUENCE_KEY,
-        snapshot_content,
-        timestamp.to_string(),
-    );
-    writer.stage_rows(writes, json_writer, &[row]).await
+    let snapshot = NormalizedJson::from_arc_unchecked(Arc::from(snapshot_content.as_str()));
+    let row =
+        deterministic_key_value_row(DETERMINISTIC_SEQUENCE_KEY, snapshot.as_str(), timestamp)?;
+    UntrackedStateContext::new()
+        .writer(writes)
+        .stage_rows(std::iter::once(row.as_ref()))
 }
 
 async fn load_key_value_row(
     live_state: &dyn LiveStateReader,
     key: &str,
-) -> Result<Option<LiveStateRow>, LixError> {
+) -> Result<Option<MaterializedLiveStateRow>, LixError> {
     live_state
         .load_row(&LiveStateRowRequest {
             schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
@@ -88,7 +85,7 @@ async fn load_key_value_row(
         .await
 }
 
-fn key_value_payload(row: &LiveStateRow, key: &str) -> Result<JsonValue, LixError> {
+fn key_value_payload(row: &MaterializedLiveStateRow, key: &str) -> Result<JsonValue, LixError> {
     let snapshot_content = row.snapshot_content.as_deref().ok_or_else(|| {
         LixError::new(
             "LIX_ERROR_UNKNOWN",
@@ -153,24 +150,20 @@ fn parse_sequence_value(value: JsonValue) -> Result<DeterministicSequence, LixEr
 
 fn deterministic_key_value_row(
     key: &str,
-    snapshot_content: String,
-    timestamp: String,
-) -> LiveStateRow {
-    LiveStateRow {
+    snapshot_content: &str,
+    timestamp: &str,
+) -> Result<UntrackedStateRow, LixError> {
+    Ok(UntrackedStateRow {
         entity_id: crate::entity_identity::EntityIdentity::single(key),
         schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
         file_id: None,
-        snapshot_content: Some(snapshot_content),
+        snapshot_content: Some(snapshot_content.to_string()),
         metadata: None,
-        schema_version: KEY_VALUE_SCHEMA_VERSION.to_string(),
-        created_at: timestamp.clone(),
-        updated_at: timestamp,
+        created_at: timestamp.to_string(),
+        updated_at: timestamp.to_string(),
         global: true,
-        change_id: None,
-        commit_id: None,
-        untracked: true,
         version_id: GLOBAL_VERSION_ID.to_string(),
-    }
+    })
 }
 
 #[cfg(test)]
@@ -187,7 +180,7 @@ mod tests {
         LiveStateContext::new(
             crate::tracked_state::TrackedStateContext::new(),
             crate::untracked_state::UntrackedStateContext::new(),
-            crate::commit_graph::CommitGraphContext::new(crate::changelog::ChangelogContext::new()),
+            crate::commit_graph::CommitGraphContext::new(),
         )
     }
 
@@ -213,7 +206,6 @@ mod tests {
         crate::test_support::seed_global_version_head(storage.clone()).await;
         write_test_key_value(
             storage.clone(),
-            &live_state,
             DETERMINISTIC_MODE_KEY,
             serde_json::json!({
                 "enabled": true,
@@ -256,7 +248,6 @@ mod tests {
         crate::test_support::seed_global_version_head(storage.clone()).await;
         write_test_key_value(
             storage.clone(),
-            &live_state,
             DETERMINISTIC_SEQUENCE_KEY,
             serde_json::json!(41),
         )
@@ -283,19 +274,13 @@ mod tests {
             .expect("transaction should open");
 
         let mut writes = StorageWriteSet::new();
-        let mut json_writer = crate::json_store::JsonStoreContext::new().writer();
-        {
-            let mut writer = live_state.writer(tx.as_mut());
-            stage_sequence(
-                &mut writer,
-                &mut writes,
-                &mut json_writer,
-                DeterministicSequence { highest_seen: 7 },
-                "1970-01-01T00:00:00.000Z",
-            )
-            .await
-            .expect("sequence should stage");
-        }
+        stage_sequence(
+            &mut writes,
+            DeterministicSequence { highest_seen: 7 },
+            "1970-01-01T00:00:00.000Z",
+        )
+        .await
+        .expect("sequence should stage");
         writes
             .apply(&mut tx.as_mut())
             .await
@@ -325,12 +310,7 @@ mod tests {
         );
     }
 
-    async fn write_test_key_value(
-        storage: StorageContext,
-        live_state: &LiveStateContext,
-        key: &str,
-        value: JsonValue,
-    ) {
+    async fn write_test_key_value(storage: StorageContext, key: &str, value: JsonValue) {
         let mut tx = storage
             .begin_write_transaction()
             .await
@@ -340,20 +320,13 @@ mod tests {
             "value": value,
         }))
         .expect("snapshot should serialize");
-        let row = deterministic_key_value_row(
-            key,
-            snapshot_content,
-            "1970-01-01T00:00:00.000Z".to_string(),
-        );
         let mut writes = StorageWriteSet::new();
-        let mut json_writer = crate::json_store::JsonStoreContext::new().writer();
-        {
-            let mut writer = live_state.writer(tx.as_mut());
-            writer
-                .stage_rows(&mut writes, &mut json_writer, &[row])
-                .await
-                .expect("test key-value should stage");
-        }
+        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

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

@@ -1,7 +1,7 @@
 /// Decoded deterministic-mode setting.
 ///
 /// Storage can decide where this setting lives. The type only describes the
-/// behavior engine2 should apply while preparing runtime functions.
+/// behavior engine should apply while preparing runtime functions.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct DeterministicMode {
     pub(crate) enabled: bool,