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

package/dist-engine-src/src/test_support.rs

@@ -1,11 +1,24 @@
 use std::sync::Arc;
 
-use crate::json_store::JsonStoreContext;
+use crate::commit_store::{Change, CommitDraftRef, CommitStoreContext};
+use crate::json_store::{
+    JsonStoreContext, JsonWritePlacementRef, NormalizedJson, NormalizedJsonRef,
+};
 use crate::storage::StorageContext;
 use crate::storage::StorageWriteSet;
-use crate::tracked_state::{TrackedStateContext, TrackedStateRow};
-use crate::untracked_state::UntrackedStateContext;
+use crate::storage::StorageWriteTransaction;
+use crate::tracked_state::{
+    MaterializedTrackedStateRow, TrackedStateContext, TrackedStateDeltaRef,
+};
+use crate::transaction::prepare_version_ref_row;
+use crate::untracked_state::{
+    MaterializedUntrackedStateRow, UntrackedStateContext, UntrackedStateRow,
+};
 use crate::version::VersionContext;
+
+fn prepare_json_ref(value: &str) -> crate::json_store::JsonRef {
+    crate::json_store::JsonRef::for_content(value.as_bytes())
+}
 use crate::GLOBAL_VERSION_ID;
 
 pub(crate) const TEST_EMPTY_ROOT_COMMIT_ID: &str = "test-empty-root";
@@ -30,7 +43,7 @@ pub(crate) async fn seed_version_head_with_rows(
     storage: StorageContext,
     version_id: &str,
     commit_id: &str,
-    rows: &[TrackedStateRow],
+    rows: &[MaterializedTrackedStateRow],
 ) {
     let mut transaction = storage
         .begin_write_transaction()
@@ -38,44 +51,178 @@ pub(crate) async fn seed_version_head_with_rows(
         .expect("seed transaction should open");
     let version_ctx = VersionContext::new(Arc::new(UntrackedStateContext::new()));
     let mut writes = StorageWriteSet::new();
-    let canonical_row = {
-        let mut json_writer = JsonStoreContext::new().writer();
-        version_ctx
-            .canonical_ref_row(
-                &mut writes,
-                &mut json_writer,
-                version_id,
-                commit_id,
-                TEST_TIMESTAMP,
-            )
-            .expect("version ref should canonicalize")
-    };
+    let canonical_row = prepare_version_ref_row(version_id, commit_id, TEST_TIMESTAMP)
+        .expect("version ref should canonicalize");
     version_ctx
-        .stage_canonical_ref_rows(&mut writes, &[canonical_row])
+        .stage_canonical_ref_rows(&mut writes, &[canonical_row.row])
         .expect("version ref should stage");
     writes
         .apply(&mut transaction.as_mut())
         .await
         .expect("version ref should write");
+    stage_tracked_root_from_materialized(
+        transaction.as_mut(),
+        &TrackedStateContext::new(),
+        commit_id,
+        None,
+        rows,
+    )
+    .await
+    .expect("tracked root should write");
+    transaction.commit().await.expect("seed should commit");
+}
+
+pub(crate) async fn stage_tracked_root_from_materialized(
+    transaction: &mut dyn StorageWriteTransaction,
+    tracked_state: &TrackedStateContext,
+    commit_id: &str,
+    parent_commit_id: Option<&str>,
+    rows: &[MaterializedTrackedStateRow],
+) -> Result<(), crate::LixError> {
     let mut writes = StorageWriteSet::new();
-    {
-        let mut json_writer = JsonStoreContext::new().writer();
-        TrackedStateContext::new()
-            .writer()
-            .stage_root(
-                &mut transaction.as_mut(),
-                &mut writes,
-                &mut json_writer,
-                commit_id,
-                None,
-                rows,
-            )
-            .await
-            .expect("tracked root should write");
+    let changes = rows
+        .iter()
+        .map(tracked_change_from_materialized)
+        .collect::<Result<Vec<_>, _>>()?;
+    let json_payloads = materialized_tracked_json_payloads(rows);
+    JsonStoreContext::new().writer().stage_batch(
+        &mut writes,
+        JsonWritePlacementRef::CommitPack {
+            commit_id,
+            pack_id: 0,
+        },
+        json_payloads
+            .iter()
+            .map(|json| NormalizedJsonRef::from(json)),
+    )?;
+
+    let parent_ids = parent_commit_id
+        .map(|parent| vec![parent.to_string()])
+        .unwrap_or_default();
+    let commit_change_id = format!("{commit_id}:commit");
+    let commit = CommitDraftRef {
+        id: commit_id,
+        change_id: &commit_change_id,
+        parent_ids: &parent_ids,
+        author_account_ids: &[],
+        created_at: rows
+            .first()
+            .map(|row| row.updated_at.as_str())
+            .unwrap_or(TEST_TIMESTAMP),
+    };
+    let commit_store = CommitStoreContext::new();
+    let change_ids = changes
+        .iter()
+        .map(|change| change.id.clone())
+        .collect::<Vec<_>>();
+    let existing_changes = commit_store
+        .reader(&mut *transaction)
+        .load_change_index_entries(&change_ids)
+        .await?;
+    let mut authored_changes = Vec::new();
+    let mut authored_created_at = Vec::new();
+    let mut authored_updated_at = Vec::new();
+    let mut adopted_changes = Vec::new();
+    let mut adopted_created_at = Vec::new();
+    let mut adopted_updated_at = Vec::new();
+    for ((change, row), existing) in changes.iter().zip(rows).zip(existing_changes) {
+        if existing.is_some() {
+            adopted_changes.push(change.as_ref());
+            adopted_created_at.push(row.created_at.as_str());
+            adopted_updated_at.push(row.updated_at.as_str());
+        } else {
+            authored_changes.push(change.as_ref());
+            authored_created_at.push(row.created_at.as_str());
+            authored_updated_at.push(row.updated_at.as_str());
+        }
     }
-    writes
-        .apply(&mut transaction.as_mut())
-        .await
-        .expect("tracked root should write");
-    transaction.commit().await.expect("seed should commit");
+    let staged = commit_store
+        .writer(&mut *transaction, &mut writes)
+        .stage_tracked_commit_draft(commit, authored_changes.clone(), adopted_changes.clone())
+        .await?;
+    let mut deltas = Vec::with_capacity(changes.len());
+    deltas.extend(
+        authored_changes
+            .iter()
+            .zip(&staged.authored_locators)
+            .zip(authored_created_at)
+            .zip(authored_updated_at)
+            .map(
+                |(((change, locator), created_at), updated_at)| TrackedStateDeltaRef {
+                    change: *change,
+                    locator: locator.as_ref(),
+                    created_at,
+                    updated_at,
+                },
+            ),
+    );
+    deltas.extend(
+        adopted_changes
+            .iter()
+            .zip(&staged.adopted_locators)
+            .zip(adopted_created_at)
+            .zip(adopted_updated_at)
+            .map(
+                |(((change, locator), created_at), updated_at)| TrackedStateDeltaRef {
+                    change: *change,
+                    locator: locator.as_ref(),
+                    created_at,
+                    updated_at,
+                },
+            ),
+    );
+    tracked_state
+        .writer(&mut *transaction, &mut writes)
+        .stage_delta(commit_id, parent_commit_id, &deltas)
+        .await?;
+    writes.apply(&mut *transaction).await.map(|_| ())
+}
+
+pub(crate) fn tracked_change_from_materialized(
+    row: &MaterializedTrackedStateRow,
+) -> Result<Change, crate::LixError> {
+    Ok(Change {
+        id: row.change_id.clone(),
+        entity_id: row.entity_id.clone(),
+        schema_key: row.schema_key.clone(),
+        file_id: row.file_id.clone(),
+        snapshot_ref: row.snapshot_content.as_deref().map(prepare_json_ref),
+        metadata_ref: row.metadata.as_ref().map(|value| {
+            let serialized = crate::serialize_row_metadata(value);
+            prepare_json_ref(&serialized)
+        }),
+        created_at: row.created_at.clone(),
+    })
+}
+
+fn materialized_tracked_json_payloads(rows: &[MaterializedTrackedStateRow]) -> Vec<NormalizedJson> {
+    let mut payloads = Vec::new();
+    for row in rows {
+        if let Some(snapshot) = row.snapshot_content.as_deref() {
+            payloads.push(NormalizedJson::from_arc_unchecked(Arc::from(snapshot)));
+        }
+        if let Some(metadata) = row.metadata.as_ref() {
+            payloads.push(NormalizedJson::from_arc_unchecked(Arc::from(
+                crate::serialize_row_metadata(metadata),
+            )));
+        }
+    }
+    payloads
+}
+
+pub(crate) fn untracked_state_row_from_materialized(
+    _writes: &mut StorageWriteSet,
+    row: &MaterializedUntrackedStateRow,
+) -> Result<UntrackedStateRow, crate::LixError> {
+    Ok(UntrackedStateRow {
+        entity_id: row.entity_id.clone(),
+        schema_key: row.schema_key.clone(),
+        file_id: row.file_id.clone(),
+        snapshot_content: row.snapshot_content.clone(),
+        metadata: row.metadata.as_ref().map(crate::serialize_row_metadata),
+        created_at: row.created_at.clone(),
+        updated_at: row.updated_at.clone(),
+        global: row.global,
+        version_id: row.version_id.clone(),
+    })
 }

package/dist-engine-src/src/tracked_state/by_file_index.rs

@@ -1,7 +1,10 @@
-use crate::tracked_state::tree_types::{
-    TrackedStateKey, TrackedStateTreeScanRequest, TrackedStateValue,
+use crate::tracked_state::codec::{
+    encode_key_ref as encode_tracked_key_ref, encode_value_ref as encode_tracked_value_ref,
 };
-use crate::tracked_state::{TrackedStateRow, TrackedStateScanRequest};
+use crate::tracked_state::types::{
+    TrackedStateIndexValueRef, TrackedStateKey, TrackedStateKeyRef, TrackedStateTreeScanRequest,
+};
+use crate::tracked_state::TrackedStateScanRequest;
 use crate::NullableKeyFilter;
 
 const NULL_COMPONENT: &str = "\0";
@@ -16,19 +19,19 @@ impl ByFileIndex {
                 .filter
                 .file_ids
                 .iter()
-                .all(|filter| !matches!(filter, NullableKeyFilter::Any))
+                .all(|filter| matches!(filter, NullableKeyFilter::Value(_)))
     }
 
     pub(crate) fn scan_request_from_tracked(
         request: &TrackedStateScanRequest,
     ) -> TrackedStateTreeScanRequest {
+        debug_assert!(Self::should_use(request));
         let schema_keys = request
             .filter
             .file_ids
             .iter()
             .filter_map(|filter| match filter {
-                NullableKeyFilter::Any => None,
-                NullableKeyFilter::Null => Some(NULL_COMPONENT.to_string()),
+                NullableKeyFilter::Any | NullableKeyFilter::Null => None,
                 NullableKeyFilter::Value(file_id) => Some(value_component(file_id)),
             })
             .collect();
@@ -43,17 +46,19 @@ impl ByFileIndex {
             schema_keys,
             entity_ids: request.filter.entity_ids.clone(),
             file_ids,
-            include_tombstones: true,
+            include_tombstones: request.filter.include_tombstones,
             limit: None,
         }
     }
 
-    pub(crate) fn key_from_row(row: &TrackedStateRow) -> TrackedStateKey {
-        TrackedStateKey {
-            schema_key: component(row.file_id.as_deref()),
-            file_id: Some(row.schema_key.clone()),
-            entity_id: row.entity_id.clone(),
-        }
+    pub(crate) fn encode_key_ref(row: TrackedStateKeyRef<'_>) -> Vec<u8> {
+        debug_assert!(row.file_id.is_some());
+        let schema_key = component(row.file_id);
+        encode_tracked_key_ref(TrackedStateKeyRef {
+            schema_key: &schema_key,
+            file_id: Some(row.schema_key),
+            entity_id: row.entity_id,
+        })
     }
 
     pub(crate) fn primary_key_from_index_key(
@@ -67,17 +72,8 @@ impl ByFileIndex {
         })
     }
 
-    pub(crate) fn header_value_from_primary(value: &TrackedStateValue) -> TrackedStateValue {
-        TrackedStateValue {
-            snapshot_ref: None,
-            metadata_ref: None,
-            schema_version: value.schema_version.clone(),
-            created_at: value.created_at.clone(),
-            updated_at: value.updated_at.clone(),
-            change_id: value.change_id.clone(),
-            commit_id: value.commit_id.clone(),
-            deleted: value.deleted,
-        }
+    pub(crate) fn encode_header_value_ref(value: TrackedStateIndexValueRef<'_>) -> Vec<u8> {
+        encode_tracked_value_ref(value)
     }
 }