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

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

@@ -1,6 +1,8 @@
 use crate::entity_identity::EntityIdentity;
-use crate::tracked_state::tree_types::TrackedStateTreeScanRequest;
-use crate::tracked_state::{TrackedStateFilter, TrackedStateRow, TrackedStateStoreReader};
+use crate::tracked_state::types::TrackedStateTreeScanRequest;
+use crate::tracked_state::{
+    MaterializedTrackedStateRow, TrackedStateFilter, TrackedStateStoreReader,
+};
 use crate::LixError;
 
 /// Filter for comparing two tracked-state commit roots.
@@ -24,12 +26,12 @@ pub(crate) struct TrackedStateDiffEntry {
     ///
     /// This can be a tombstone. Callers that need user-visible semantics
     /// should use `visible_before()` instead of inspecting this directly.
-    pub(crate) before: Option<TrackedStateRow>,
+    pub(crate) before: Option<MaterializedTrackedStateRow>,
     /// Raw row in the right root.
     ///
     /// This can be a tombstone. Keeping the raw tombstone is what lets merge
     /// apply deletes without reloading the source root.
-    pub(crate) after: Option<TrackedStateRow>,
+    pub(crate) after: Option<MaterializedTrackedStateRow>,
 }
 
 /// Root-local tracked-state identity.
@@ -61,19 +63,35 @@ where
     S: crate::storage::StorageReader,
 {
     let scan_request = scan_request_for_diff(request);
-    let mut entries = Vec::new();
-    for tree_entry in reader
+    let tree_entries = reader
         .diff_tree_entries_at_commits(left_commit_id, right_commit_id, &scan_request)
-        .await?
-    {
-        let before = match tree_entry.before {
-            Some((key, value)) => Some(reader.materialize_tree_value(key, value).await?),
-            None => None,
-        };
-        let after = match tree_entry.after {
-            Some((key, value)) => Some(reader.materialize_tree_value(key, value).await?),
-            None => None,
-        };
+        .await?;
+    let mut before_entries = Vec::new();
+    let mut after_entries = Vec::new();
+    let mut pending_entries = Vec::with_capacity(tree_entries.len());
+    for tree_entry in tree_entries {
+        let before_index = tree_entry.before.map(|entry| {
+            let index = before_entries.len();
+            before_entries.push(entry);
+            index
+        });
+        let after_index = tree_entry.after.map(|entry| {
+            let index = after_entries.len();
+            after_entries.push(entry);
+            index
+        });
+        pending_entries.push(PendingDiffEntry {
+            before_index,
+            after_index,
+        });
+    }
+
+    let before_rows = reader.materialize_tree_values(before_entries).await?;
+    let after_rows = reader.materialize_tree_values(after_entries).await?;
+    let mut entries = Vec::new();
+    for pending_entry in pending_entries {
+        let before = materialized_row_at(pending_entry.before_index, &before_rows)?;
+        let after = materialized_row_at(pending_entry.after_index, &after_rows)?;
         let identity = match before.as_ref().or(after.as_ref()) {
             Some(row) => TrackedStateDiffIdentity::from_row(row)?,
             None => continue,
@@ -87,6 +105,26 @@ where
     Ok(TrackedStateDiff { entries })
 }
 
+fn materialized_row_at(
+    index: Option<usize>,
+    rows: &[MaterializedTrackedStateRow],
+) -> Result<Option<MaterializedTrackedStateRow>, LixError> {
+    let Some(index) = index else {
+        return Ok(None);
+    };
+    rows.get(index).cloned().map(Some).ok_or_else(|| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            "tracked_state diff materialization returned fewer rows than planned",
+        )
+    })
+}
+
+struct PendingDiffEntry {
+    before_index: Option<usize>,
+    after_index: Option<usize>,
+}
+
 fn scan_request_for_diff(request: &TrackedStateDiffRequest) -> TrackedStateTreeScanRequest {
     let mut filter = request.filter.clone();
     filter.include_tombstones = true;
@@ -94,15 +132,15 @@ fn scan_request_for_diff(request: &TrackedStateDiffRequest) -> TrackedStateTreeS
         schema_keys: filter.schema_keys,
         entity_ids: filter.entity_ids,
         file_ids: filter.file_ids,
-        include_tombstones: filter.include_tombstones,
+        include_tombstones: true,
         limit: None,
     }
 }
 
 fn classify_diff(
     identity: TrackedStateDiffIdentity,
-    before: Option<TrackedStateRow>,
-    after: Option<TrackedStateRow>,
+    before: Option<MaterializedTrackedStateRow>,
+    after: Option<MaterializedTrackedStateRow>,
 ) -> Option<TrackedStateDiffEntry> {
     match (is_live_row(before.as_ref()), is_live_row(after.as_ref())) {
         (None, None) => None,
@@ -128,18 +166,19 @@ fn classify_diff(
     }
 }
 
-fn is_live_row(row: Option<&TrackedStateRow>) -> Option<&TrackedStateRow> {
+fn is_live_row(row: Option<&MaterializedTrackedStateRow>) -> Option<&MaterializedTrackedStateRow> {
     row.filter(|row| row.snapshot_content.is_some())
 }
 
-fn tracked_row_payload_eq(left: &TrackedStateRow, right: &TrackedStateRow) -> bool {
-    left.snapshot_content == right.snapshot_content
-        && left.metadata == right.metadata
-        && left.schema_version == right.schema_version
+fn tracked_row_payload_eq(
+    left: &MaterializedTrackedStateRow,
+    right: &MaterializedTrackedStateRow,
+) -> bool {
+    left.snapshot_content == right.snapshot_content && left.metadata == right.metadata
 }
 
 impl TrackedStateDiffIdentity {
-    fn from_row(row: &TrackedStateRow) -> Result<Self, LixError> {
+    fn from_row(row: &MaterializedTrackedStateRow) -> Result<Self, LixError> {
         Ok(Self {
             schema_key: row.schema_key.clone(),
             entity_id: row.entity_id.clone(),
@@ -160,14 +199,14 @@ impl TrackedStateDiffEntry {
     }
 
     #[cfg(test)]
-    pub(crate) fn visible_before(&self) -> Option<&TrackedStateRow> {
+    pub(crate) fn visible_before(&self) -> Option<&MaterializedTrackedStateRow> {
         self.before
             .as_ref()
             .filter(|row| row.snapshot_content.is_some())
     }
 
     #[cfg(test)]
-    pub(crate) fn visible_after(&self) -> Option<&TrackedStateRow> {
+    pub(crate) fn visible_after(&self) -> Option<&MaterializedTrackedStateRow> {
         self.after
             .as_ref()
             .filter(|row| row.snapshot_content.is_some())
@@ -180,8 +219,7 @@ mod tests {
 
     use super::*;
     use crate::backend::testing::UnitTestBackend;
-    use crate::json_store::JsonStoreContext;
-    use crate::storage::{StorageContext, StorageWriteSet, StorageWriteTransaction};
+    use crate::storage::{StorageContext, StorageWriteTransaction};
     use crate::tracked_state::TrackedStateContext;
     use crate::NullableKeyFilter;
 
@@ -373,6 +411,133 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn diff_commits_between_delta_parent_and_child_reports_suffix_rows() {
+        let backend = Arc::new(UnitTestBackend::new());
+        let storage = StorageContext::new(backend.clone());
+        let tracked_state = TrackedStateContext::new();
+        let mut tx = storage
+            .begin_write_transaction()
+            .await
+            .expect("transaction should open");
+        write_root_for_test(
+            tx.as_mut(),
+            &tracked_state,
+            "parent",
+            None,
+            &[
+                row_with_value("entity-a", None, "parent-a", "before"),
+                row_with_value("entity-b", None, "parent-b", "same"),
+            ],
+        )
+        .await
+        .expect("parent should write");
+        write_root_for_test(
+            tx.as_mut(),
+            &tracked_state,
+            "child",
+            Some("parent"),
+            &[row_with_value("entity-a", None, "child-a", "after")],
+        )
+        .await
+        .expect("child should write");
+        tx.commit().await.expect("transaction should commit");
+
+        let diff = tracked_state
+            .reader(storage)
+            .diff_commits("parent", "child", &TrackedStateDiffRequest::default())
+            .await
+            .expect("diff should load");
+
+        assert_eq!(
+            kinds(&diff),
+            vec![("entity-a".to_string(), TrackedStateDiffKind::Modified)]
+        );
+        assert_eq!(
+            diff.entries[0]
+                .before
+                .as_ref()
+                .and_then(|row| row.snapshot_content.as_deref()),
+            Some("{\"value\":\"before\"}")
+        );
+        assert_eq!(
+            diff.entries[0]
+                .after
+                .as_ref()
+                .and_then(|row| row.snapshot_content.as_deref()),
+            Some("{\"value\":\"after\"}")
+        );
+    }
+
+    #[tokio::test]
+    async fn diff_commits_between_delta_child_and_parent_reports_reverse_suffix_rows() {
+        let (storage, tracked_state) = seed_parent_child_delta(
+            &[
+                row_with_value("entity-a", None, "parent-a", "before"),
+                row_with_value("entity-b", None, "parent-b", "same"),
+            ],
+            &[row_with_value("entity-a", None, "child-a", "after")],
+        )
+        .await;
+
+        let diff = tracked_state
+            .reader(storage)
+            .diff_commits("child", "parent", &TrackedStateDiffRequest::default())
+            .await
+            .expect("diff should load");
+
+        assert_eq!(
+            kinds(&diff),
+            vec![("entity-a".to_string(), TrackedStateDiffKind::Modified)]
+        );
+        assert_eq!(
+            diff.entries[0]
+                .before
+                .as_ref()
+                .and_then(|row| row.snapshot_content.as_deref()),
+            Some("{\"value\":\"after\"}")
+        );
+        assert_eq!(
+            diff.entries[0]
+                .after
+                .as_ref()
+                .and_then(|row| row.snapshot_content.as_deref()),
+            Some("{\"value\":\"before\"}")
+        );
+    }
+
+    #[tokio::test]
+    async fn diff_commits_between_delta_parent_and_child_preserves_suffix_tombstones() {
+        let (storage, tracked_state) = seed_parent_child_delta(
+            &[
+                row_with_value("entity-a", None, "parent-a", "before"),
+                row_with_value("entity-b", None, "parent-b", "same"),
+            ],
+            &[tombstone("entity-a", None, "child-delete")],
+        )
+        .await;
+
+        let diff = tracked_state
+            .reader(storage)
+            .diff_commits("parent", "child", &TrackedStateDiffRequest::default())
+            .await
+            .expect("diff should load");
+
+        assert_eq!(
+            kinds(&diff),
+            vec![("entity-a".to_string(), TrackedStateDiffKind::Removed)]
+        );
+        assert!(diff.entries[0].before_is_live());
+        assert!(!diff.entries[0].after_is_live());
+        assert_eq!(
+            diff.entries[0]
+                .after
+                .as_ref()
+                .map(|row| row.change_id.as_str()),
+            Some("child-delete")
+        );
+    }
+
     async fn diff(
         storage: StorageContext,
         tracked_state: &TrackedStateContext,
@@ -385,8 +550,8 @@ mod tests {
     }
 
     async fn seed_roots(
-        left_rows: &[TrackedStateRow],
-        right_rows: &[TrackedStateRow],
+        left_rows: &[MaterializedTrackedStateRow],
+        right_rows: &[MaterializedTrackedStateRow],
     ) -> (StorageContext, TrackedStateContext) {
         let backend = Arc::new(UnitTestBackend::new());
         let storage = StorageContext::new(backend.clone());
@@ -405,30 +570,48 @@ mod tests {
         (storage, tracked_state)
     }
 
+    async fn seed_parent_child_delta(
+        parent_rows: &[MaterializedTrackedStateRow],
+        child_rows: &[MaterializedTrackedStateRow],
+    ) -> (StorageContext, TrackedStateContext) {
+        let backend = Arc::new(UnitTestBackend::new());
+        let storage = StorageContext::new(backend.clone());
+        let tracked_state = TrackedStateContext::new();
+        let mut tx = storage
+            .begin_write_transaction()
+            .await
+            .expect("transaction should open");
+        write_root_for_test(tx.as_mut(), &tracked_state, "parent", None, parent_rows)
+            .await
+            .expect("parent should write");
+        write_root_for_test(
+            tx.as_mut(),
+            &tracked_state,
+            "child",
+            Some("parent"),
+            child_rows,
+        )
+        .await
+        .expect("child should write");
+        tx.commit().await.expect("transaction should commit");
+        (storage, tracked_state)
+    }
+
     async fn write_root_for_test(
         tx: &mut dyn StorageWriteTransaction,
         tracked_state: &TrackedStateContext,
         commit_id: &str,
         parent_commit_id: Option<&str>,
-        rows: &[TrackedStateRow],
+        rows: &[MaterializedTrackedStateRow],
     ) -> Result<(), LixError> {
-        let mut writes = StorageWriteSet::new();
-        {
-            let mut json_writer = JsonStoreContext::new().writer();
-            tracked_state
-                .writer()
-                .stage_root(
-                    tx,
-                    &mut writes,
-                    &mut json_writer,
-                    commit_id,
-                    parent_commit_id,
-                    rows,
-                )
-                .await?;
-        }
-        writes.apply(tx).await?;
-        Ok(())
+        crate::test_support::stage_tracked_root_from_materialized(
+            tx,
+            tracked_state,
+            commit_id,
+            parent_commit_id,
+            rows,
+        )
+        .await
     }
 
     fn kinds(diff: &TrackedStateDiff) -> Vec<(String, TrackedStateDiffKind)> {
@@ -436,20 +619,29 @@ mod tests {
             .iter()
             .map(|entry| {
                 (
-                    entry.identity.entity_id.as_string().expect("identity"),
+                    entry
+                        .identity
+                        .entity_id
+                        .as_single_string_owned()
+                        .expect("identity"),
                     entry.kind,
                 )
             })
             .collect()
     }
 
-    fn tombstone(entity_id: &str, file_id: Option<&str>, change_id: &str) -> TrackedStateRow {
+    fn tombstone(
+        entity_id: &str,
+        file_id: Option<&str>,
+        change_id: &str,
+    ) -> MaterializedTrackedStateRow {
         let mut row = row(entity_id, file_id, change_id);
         row.snapshot_content = None;
+        row.deleted = true;
         row
     }
 
-    fn row(entity_id: &str, file_id: Option<&str>, change_id: &str) -> TrackedStateRow {
+    fn row(entity_id: &str, file_id: Option<&str>, change_id: &str) -> MaterializedTrackedStateRow {
         row_with_schema(entity_id, file_id, "test_schema", change_id)
     }
 
@@ -458,7 +650,7 @@ mod tests {
         file_id: Option<&str>,
         schema_key: &str,
         change_id: &str,
-    ) -> TrackedStateRow {
+    ) -> MaterializedTrackedStateRow {
         row_with_schema_and_value(entity_id, file_id, schema_key, change_id, "value")
     }
 
@@ -467,7 +659,7 @@ mod tests {
         file_id: Option<&str>,
         change_id: &str,
         value: &str,
-    ) -> TrackedStateRow {
+    ) -> MaterializedTrackedStateRow {
         row_with_schema_and_value(entity_id, file_id, "test_schema", change_id, value)
     }
 
@@ -477,14 +669,14 @@ mod tests {
         schema_key: &str,
         change_id: &str,
         value: &str,
-    ) -> TrackedStateRow {
-        TrackedStateRow {
+    ) -> MaterializedTrackedStateRow {
+        MaterializedTrackedStateRow {
             entity_id: EntityIdentity::single(entity_id),
             schema_key: schema_key.to_string(),
             file_id: file_id.map(str::to_string),
             snapshot_content: Some(format!("{{\"value\":\"{value}\"}}")),
             metadata: None,
-            schema_version: "1".to_string(),
+            deleted: false,
             created_at: "2026-01-01T00:00:00Z".to_string(),
             updated_at: "2026-01-01T00:00:00Z".to_string(),
             change_id: change_id.to_string(),