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

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

@@ -0,0 +1,228 @@
+use std::sync::Arc;
+
+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::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";
+const TEST_TIMESTAMP: &str = "1970-01-01T00:00:00.000Z";
+
+/// Seeds a version head and matching tracked root for unit tests.
+///
+/// A version ref that points at a commit without a tracked root is invalid for
+/// the serving projection. This helper keeps that invariant in one place while
+/// still letting low-level tests use synthetic commit ids.
+pub(crate) async fn seed_version_head(storage: StorageContext, version_id: &str, commit_id: &str) {
+    seed_version_head_with_rows(storage, version_id, commit_id, &[]).await;
+}
+
+/// Seeds the global version head to an empty tracked root for unit tests.
+pub(crate) async fn seed_global_version_head(storage: StorageContext) {
+    seed_version_head(storage, GLOBAL_VERSION_ID, TEST_EMPTY_ROOT_COMMIT_ID).await;
+}
+
+/// Seeds a version head and writes the tracked root contents for its commit.
+pub(crate) async fn seed_version_head_with_rows(
+    storage: StorageContext,
+    version_id: &str,
+    commit_id: &str,
+    rows: &[MaterializedTrackedStateRow],
+) {
+    let mut transaction = storage
+        .begin_write_transaction()
+        .await
+        .expect("seed transaction should open");
+    let version_ctx = VersionContext::new(Arc::new(UntrackedStateContext::new()));
+    let mut writes = StorageWriteSet::new();
+    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.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 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());
+        }
+    }
+    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

@@ -0,0 +1,98 @@
+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::types::{
+    TrackedStateIndexValueRef, TrackedStateKey, TrackedStateKeyRef, TrackedStateTreeScanRequest,
+};
+use crate::tracked_state::TrackedStateScanRequest;
+use crate::NullableKeyFilter;
+
+const NULL_COMPONENT: &str = "\0";
+const VALUE_PREFIX: &str = "\u{1}";
+
+pub(crate) struct ByFileIndex;
+
+impl ByFileIndex {
+    pub(crate) fn should_use(request: &TrackedStateScanRequest) -> bool {
+        !request.filter.file_ids.is_empty()
+            && request
+                .filter
+                .file_ids
+                .iter()
+                .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 | NullableKeyFilter::Null => None,
+                NullableKeyFilter::Value(file_id) => Some(value_component(file_id)),
+            })
+            .collect();
+        let file_ids = request
+            .filter
+            .schema_keys
+            .iter()
+            .cloned()
+            .map(NullableKeyFilter::Value)
+            .collect();
+        TrackedStateTreeScanRequest {
+            schema_keys,
+            entity_ids: request.filter.entity_ids.clone(),
+            file_ids,
+            include_tombstones: request.filter.include_tombstones,
+            limit: None,
+        }
+    }
+
+    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(
+        index_key: TrackedStateKey,
+    ) -> Option<TrackedStateKey> {
+        let schema_key = index_key.file_id?;
+        Some(TrackedStateKey {
+            schema_key,
+            file_id: file_id_from_component(&index_key.schema_key)?,
+            entity_id: index_key.entity_id,
+        })
+    }
+
+    pub(crate) fn encode_header_value_ref(value: TrackedStateIndexValueRef<'_>) -> Vec<u8> {
+        encode_tracked_value_ref(value)
+    }
+}
+
+fn component(file_id: Option<&str>) -> String {
+    match file_id {
+        Some(file_id) => value_component(file_id),
+        None => NULL_COMPONENT.to_string(),
+    }
+}
+
+fn value_component(file_id: &str) -> String {
+    format!("{VALUE_PREFIX}{file_id}")
+}
+
+fn file_id_from_component(component: &str) -> Option<Option<String>> {
+    if component == NULL_COMPONENT {
+        return Some(None);
+    }
+    component
+        .strip_prefix(VALUE_PREFIX)
+        .map(|file_id| Some(file_id.to_string()))
+}