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

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

@@ -2,10 +2,8 @@ mod context;
 mod types;
 mod walker;
 
-#[allow(unused_imports)]
 pub(crate) use context::{CommitGraphContext, CommitGraphStoreReader};
-#[allow(unused_imports)]
 pub(crate) use types::{
-    CommitGraphChangeHistoryEntry, CommitGraphChangeHistoryRequest, CommitGraphCommit,
-    CommitGraphEdge, CommitGraphReader, ReachableCommitGraphCommit,
+    CommitGraphChange, CommitGraphChangeHistoryEntry, CommitGraphChangeHistoryRequest,
+    CommitGraphCommit, CommitGraphEdge, CommitGraphReader, ReachableCommitGraphCommit,
 };

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

@@ -1,18 +1,28 @@
-use crate::commit_store::{Change, LocatedChange};
-use crate::entity_identity::EntityIdentity;
+use crate::entity_pk::EntityPk;
+use crate::json_store::JsonRef;
 use crate::LixError;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CommitGraphChange {
+    pub(crate) id: String,
+    pub(crate) entity_pk: EntityPk,
+    pub(crate) schema_key: String,
+    pub(crate) file_id: Option<String>,
+    pub(crate) snapshot_ref: Option<JsonRef>,
+    pub(crate) metadata_ref: Option<JsonRef>,
+    pub(crate) created_at: String,
+}
+
 /// Parsed `lix_commit` entity from the changelog.
 ///
-/// Commits are stored as ordinary canonical changes. The graph reader parses
-/// their snapshot so traversal code can work with explicit parent ids and the
-/// ordered canonical changes introduced relative to the first parent. A merge
-/// commit may reference existing changes from another parent instead of owning
-/// newly minted copies.
+/// The graph reader projects direct changelog commit records into explicit
+/// parent ids plus the commit's referenced canonical changes. A merge commit
+/// points at selected existing change ids; it does not mint row/entity changes
+/// for the merge itself.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct CommitGraphCommit {
-    pub(crate) canonical_change: Change,
-    pub(crate) change: Change,
+    pub(crate) canonical_change: CommitGraphChange,
+    pub(crate) change: CommitGraphChange,
     pub(crate) commit_id: String,
     pub(crate) change_ids: Vec<String>,
     pub(crate) author_account_ids: Vec<String>,
@@ -37,7 +47,7 @@ pub(crate) struct CommitGraphEdge {
 /// Filter for canonical change history from a chosen traversal start commit.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub(crate) struct CommitGraphChangeHistoryRequest {
-    pub(crate) entity_ids: Vec<EntityIdentity>,
+    pub(crate) entity_pks: Vec<EntityPk>,
     pub(crate) schema_keys: Vec<String>,
     pub(crate) file_ids: Vec<String>,
     pub(crate) min_depth: Option<u32>,
@@ -48,10 +58,10 @@ pub(crate) struct CommitGraphChangeHistoryRequest {
 /// Canonical change observed while walking commit history from a start commit.
 ///
 /// `start_commit_id` is the traversal anchor requested by the caller. It is not
-/// necessarily a graph root or a version head.
+/// necessarily a graph root or a branch head.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct CommitGraphChangeHistoryEntry {
-    pub(crate) located_change: LocatedChange,
+    pub(crate) change: CommitGraphChange,
     pub(crate) observed_commit_id: String,
     pub(crate) start_commit_id: String,
     pub(crate) depth: u32,
@@ -61,46 +71,16 @@ pub(crate) struct CommitGraphChangeHistoryEntry {
 ///
 /// SQL surfaces consume this trait so they depend on graph semantics, not on
 /// changelog storage or traversal details.
-#[allow(dead_code)]
 #[async_trait::async_trait]
 pub(crate) trait CommitGraphReader: Send + Sync {
-    #[allow(dead_code)]
     async fn load_commit(&mut self, commit_id: &str)
         -> Result<Option<CommitGraphCommit>, LixError>;
 
-    async fn all_commits(&mut self) -> Result<Vec<CommitGraphCommit>, LixError>;
-
     async fn reachable_commits(
         &mut self,
         head_commit_id: &str,
     ) -> Result<Vec<ReachableCommitGraphCommit>, LixError>;
 
-    /// Returns the best common ancestors shared by two commit heads.
-    ///
-    /// This is intentionally not called "lowest common ancestor": commit
-    /// history is a DAG, not a tree, and some histories have multiple equally
-    /// good common ancestors. Merge policy can require exactly one base later.
-    #[allow(dead_code)]
-    async fn best_common_ancestors(
-        &mut self,
-        left_commit_id: &str,
-        right_commit_id: &str,
-    ) -> Result<Vec<CommitGraphCommit>, LixError>;
-
-    /// Resolves the single commit base to use for a three-way merge.
-    ///
-    /// This is merge policy, not raw graph math: no common history and multiple
-    /// best common ancestors are both errors until merge has explicit support
-    /// for those cases.
-    #[allow(dead_code)]
-    async fn merge_base(
-        &mut self,
-        left_commit_id: &str,
-        right_commit_id: &str,
-    ) -> Result<CommitGraphCommit, LixError>;
-
-    fn commit_edges(&self, commits: &[CommitGraphCommit]) -> Vec<CommitGraphEdge>;
-
     async fn change_history_from_commit(
         &mut self,
         start_commit_id: &str,

package/dist-engine-src/src/commit_graph/walker.rs

@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use crate::commit_graph::{CommitGraphCommit, CommitGraphStoreReader, ReachableCommitGraphCommit};
-use crate::storage::StorageReader;
+use crate::storage::StorageRead;
 use crate::LixError;
 
 /// Walks parent links from `head_commit_id` and returns reachable commits
@@ -15,7 +15,7 @@ pub(crate) async fn walk_reachable_commits<S>(
     head_commit_id: &str,
 ) -> Result<Vec<ReachableCommitGraphCommit>, LixError>
 where
-    S: StorageReader,
+    S: StorageRead + Send + Sync,
 {
     let mut loader = CommitTraversalLoader::new(reader);
     let mut visiting = BTreeSet::new();
@@ -67,7 +67,7 @@ pub(crate) async fn best_common_ancestors<S>(
     right_commit_id: &str,
 ) -> Result<Vec<CommitGraphCommit>, LixError>
 where
-    S: StorageReader,
+    S: StorageRead + Send + Sync,
 {
     let left_reachable = walk_reachable_commits(reader, left_commit_id).await?;
     let right_reachable = walk_reachable_commits(reader, right_commit_id).await?;
@@ -104,7 +104,7 @@ async fn has_descendant_in_set<S>(
     candidate_descendant_ids: &BTreeSet<String>,
 ) -> Result<bool, LixError>
 where
-    S: StorageReader,
+    S: StorageRead + Send + Sync,
 {
     for candidate_descendant_id in candidate_descendant_ids {
         if candidate_descendant_id == commit_id {
@@ -123,7 +123,7 @@ where
 
 struct CommitTraversalLoader<'a, S>
 where
-    S: StorageReader,
+    S: StorageRead + Send + Sync,
 {
     reader: &'a mut CommitGraphStoreReader<S>,
     loaded: BTreeMap<String, CommitGraphCommit>,
@@ -131,7 +131,7 @@ where
 
 impl<'a, S> CommitTraversalLoader<'a, S>
 where
-    S: StorageReader,
+    S: StorageRead + Send + Sync,
 {
     fn new(reader: &'a mut CommitGraphStoreReader<S>) -> Self {
         Self {
@@ -218,22 +218,22 @@ struct TraversalFrame {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
     use serde_json::json;
 
-    use crate::backend::testing::UnitTestBackend;
+    use crate::changelog::{
+        ChangelogAppend, ChangelogContext, ChangelogWriter, CommitChangeRefSet, CommitRecord,
+    };
+    use crate::commit_graph::CommitGraphChange;
     use crate::commit_graph::CommitGraphContext;
-    use crate::commit_store::{Change, CommitDraftRef, CommitStoreContext};
-    use crate::storage::{StorageContext, StorageWriteSet};
+    use crate::storage::StorageContext;
+    use crate::storage::{InMemoryStorageBackend, StorageReadOptions, StorageWriteOptions};
     use crate::LixError;
 
     #[tokio::test]
     async fn reachable_commits_returns_commits_nearest_first() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-root-change", "commit-root", &[], &[]),
                 commit_change(
@@ -248,7 +248,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let commits = reader
             .reachable_commits("commit-head")
             .await
@@ -265,10 +268,9 @@ mod tests {
 
     #[tokio::test]
     async fn reachable_commits_errors_on_missing_parent_commit() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
-        append_changes(
-            storage.clone(),
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
+        let error = append_changes_result(
+            &storage,
             &[commit_change(
                 "commit-head-change",
                 "commit-head",
@@ -276,24 +278,17 @@ mod tests {
                 &["missing-parent"],
             )],
         )
-        .await;
-
-        let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
-        let error = reader
-            .reachable_commits("commit-head")
-            .await
-            .expect_err("missing parent should fail");
+        .await
+        .expect_err("changelog should reject missing parent");
 
         assert!(error.message.contains("missing-parent"));
     }
 
     #[tokio::test]
     async fn reachable_commits_errors_on_cycle() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-a-change", "commit-a", &[], &["commit-b"]),
                 commit_change("commit-b-change", "commit-b", &[], &["commit-a"]),
@@ -302,21 +297,23 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let error = reader
             .reachable_commits("commit-a")
             .await
-            .expect_err("cycle should fail");
+            .expect_err("walker should reject parent cycles");
 
         assert!(error.message.contains("cycle"));
     }
 
     #[tokio::test]
     async fn reachable_commits_dedupes_shared_ancestors_in_diamond() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-root-change", "commit-root", &[], &[]),
                 commit_change("commit-left-change", "commit-left", &[], &["commit-root"]),
@@ -332,7 +329,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let commits = reader
             .reachable_commits("commit-head")
             .await
@@ -354,10 +354,9 @@ mod tests {
 
     #[tokio::test]
     async fn reachable_commits_keeps_nearest_depth_for_multiple_paths() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-root-change", "commit-root", &[], &[]),
                 commit_change(
@@ -377,7 +376,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let commits = reader
             .reachable_commits("commit-head")
             .await
@@ -394,10 +396,9 @@ mod tests {
 
     #[tokio::test]
     async fn reachable_commits_orders_same_depth_commits_by_id() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-z-change", "commit-z", &[], &[]),
                 commit_change("commit-a-change", "commit-a", &[], &[]),
@@ -412,7 +413,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let commits = reader
             .reachable_commits("commit-head")
             .await
@@ -429,10 +433,12 @@ mod tests {
 
     #[tokio::test]
     async fn reachable_commits_errors_on_missing_head_commit() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
 
         let error = reader
             .reachable_commits("missing-head")
@@ -444,10 +450,9 @@ mod tests {
 
     #[tokio::test]
     async fn best_common_ancestors_returns_nearest_common_commit_in_simple_graph() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-a-change", "commit-a", &[], &[]),
                 commit_change("commit-b-change", "commit-b", &[], &["commit-a"]),
@@ -458,7 +463,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let ancestors = reader
             .best_common_ancestors("commit-c", "commit-d")
             .await
@@ -475,10 +483,9 @@ mod tests {
 
     #[tokio::test]
     async fn best_common_ancestors_returns_shared_fork_in_diamond_graph() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-root-change", "commit-root", &[], &[]),
                 commit_change("commit-left-change", "commit-left", &[], &["commit-root"]),
@@ -500,7 +507,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let ancestors = reader
             .best_common_ancestors("commit-left-head", "commit-right-head")
             .await
@@ -517,10 +527,9 @@ mod tests {
 
     #[tokio::test]
     async fn best_common_ancestors_returns_parent_when_one_side_is_ancestor() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-a-change", "commit-a", &[], &[]),
                 commit_change("commit-b-change", "commit-b", &[], &["commit-a"]),
@@ -530,7 +539,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let ancestors = reader
             .best_common_ancestors("commit-b", "commit-c")
             .await
@@ -547,10 +559,9 @@ mod tests {
 
     #[tokio::test]
     async fn best_common_ancestors_returns_multiple_bases_for_criss_cross_graph() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-root-change", "commit-root", &[], &[]),
                 commit_change("commit-left-change", "commit-left", &[], &["commit-root"]),
@@ -572,7 +583,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let ancestors = reader
             .best_common_ancestors("commit-head-left", "commit-head-right")
             .await
@@ -589,10 +603,9 @@ mod tests {
 
     #[tokio::test]
     async fn merge_base_returns_single_best_common_ancestor() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-a-change", "commit-a", &[], &[]),
                 commit_change("commit-b-change", "commit-b", &[], &["commit-a"]),
@@ -603,7 +616,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let base = reader
             .merge_base("commit-c", "commit-d")
             .await
@@ -614,10 +630,9 @@ mod tests {
 
     #[tokio::test]
     async fn merge_base_errors_when_histories_have_no_common_commit() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-left-change", "commit-left", &[], &[]),
                 commit_change("commit-right-change", "commit-right", &[], &[]),
@@ -626,7 +641,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let error = reader
             .merge_base("commit-left", "commit-right")
             .await
@@ -637,10 +655,9 @@ mod tests {
 
     #[tokio::test]
     async fn merge_base_errors_when_best_common_ancestor_is_ambiguous() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         append_changes(
-            storage.clone(),
+            &storage,
             &[
                 commit_change("commit-root-change", "commit-root", &[], &[]),
                 commit_change("commit-left-change", "commit-left", &[], &["commit-root"]),
@@ -662,7 +679,10 @@ mod tests {
         .await;
 
         let graph = CommitGraphContext::new();
-        let mut reader = graph.reader(storage);
+        let read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut reader = graph.reader(read);
         let error = reader
             .merge_base("commit-head-left", "commit-head-right")
             .await
@@ -694,43 +714,53 @@ mod tests {
 
     #[derive(Clone)]
     struct TestCommitChange {
-        change: Change,
+        change: CommitGraphChange,
         parent_commit_ids: Vec<String>,
     }
 
-    async fn append_changes(storage: StorageContext, changes: &[TestCommitChange]) {
-        let mut tx = storage
-            .begin_write_transaction()
+    async fn append_changes(storage: &StorageContext, changes: &[TestCommitChange]) {
+        append_changes_result(storage, changes)
             .await
-            .expect("transaction should open");
-        let mut writes = StorageWriteSet::new();
-        let commit_store = CommitStoreContext::new();
+            .expect("changelog fixture should append");
+    }
+
+    async fn append_changes_result(
+        storage: &StorageContext,
+        changes: &[TestCommitChange],
+    ) -> Result<(), LixError> {
+        let mut read = storage
+            .begin_read(StorageReadOptions::default())
+            .expect("read should open");
+        let mut writes = storage.new_write_set();
+        let mut append = ChangelogAppend::default();
         for change in changes {
             let commit_id = change
                 .change
-                .entity_id
+                .entity_pk
                 .as_single_string()
                 .expect("commit fixture should have single id")
                 .to_string();
-            let author_account_ids = Vec::new();
-            let commit = CommitDraftRef {
-                id: &commit_id,
-                change_id: &change.change.id,
-                parent_ids: &change.parent_commit_ids,
-                author_account_ids: &author_account_ids,
-                created_at: &change.change.created_at,
-            };
-            commit_store
-                .writer(tx.as_mut(), &mut writes)
-                .stage_commit_draft(commit, Vec::new(), Vec::new())
-                .await
-                .expect("commit-store fixture should append");
+            append.commits.push(CommitRecord {
+                format_version: 1,
+                commit_id: commit_id.clone(),
+                parent_commit_ids: change.parent_commit_ids.clone(),
+                change_id: change.change.id.clone(),
+                author_account_ids: Vec::new(),
+                created_at: change.change.created_at.clone(),
+            });
+            append.commit_change_refs.push(CommitChangeRefSet {
+                commit_id: commit_id.clone(),
+                entries: Vec::new(),
+            });
         }
-        writes
-            .apply(&mut tx.as_mut())
-            .await
-            .expect("writes should apply");
-        tx.commit().await.expect("commit should succeed");
+        ChangelogContext::new()
+            .writer(&mut read, &mut writes)
+            .stage_append(append)
+            .await?;
+        storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .expect("commit should succeed");
+        Ok(())
     }
 
     fn commit_change(
@@ -741,9 +771,9 @@ mod tests {
     ) -> TestCommitChange {
         let _ = change_ids;
         TestCommitChange {
-            change: Change {
+            change: CommitGraphChange {
                 id: change_id.to_string(),
-                entity_id: crate::entity_identity::EntityIdentity::single(commit_id),
+                entity_pk: crate::entity_pk::EntityPk::single(commit_id),
                 schema_key: "lix_commit".to_string(),
                 file_id: None,
                 snapshot_ref: None,