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

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

@@ -0,0 +1,81 @@
+use std::sync::Arc;
+
+use crate::json_store::JsonStoreContext;
+use crate::storage::StorageContext;
+use crate::storage::StorageWriteSet;
+use crate::tracked_state::{TrackedStateContext, TrackedStateRow};
+use crate::untracked_state::UntrackedStateContext;
+use crate::version::VersionContext;
+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: &[TrackedStateRow],
+) {
+    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 = {
+        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")
+    };
+    version_ctx
+        .stage_canonical_ref_rows(&mut writes, &[canonical_row])
+        .expect("version ref should stage");
+    writes
+        .apply(&mut transaction.as_mut())
+        .await
+        .expect("version ref should write");
+    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");
+    }
+    writes
+        .apply(&mut transaction.as_mut())
+        .await
+        .expect("tracked root should write");
+    transaction.commit().await.expect("seed should commit");
+}

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

@@ -0,0 +1,102 @@
+use crate::tracked_state::tree_types::{
+    TrackedStateKey, TrackedStateTreeScanRequest, TrackedStateValue,
+};
+use crate::tracked_state::{TrackedStateRow, 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::Any))
+    }
+
+    pub(crate) fn scan_request_from_tracked(
+        request: &TrackedStateScanRequest,
+    ) -> TrackedStateTreeScanRequest {
+        let schema_keys = request
+            .filter
+            .file_ids
+            .iter()
+            .filter_map(|filter| match filter {
+                NullableKeyFilter::Any => None,
+                NullableKeyFilter::Null => Some(NULL_COMPONENT.to_string()),
+                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: true,
+            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 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 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,
+        }
+    }
+}
+
+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()))
+}