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

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

@@ -1,45 +1,68 @@
-use crate::changelog::{
-    canonicalize_materialized_change, ChangelogContext, MaterializedCanonicalChange,
-};
+use crate::commit_store::{Change, CommitDraftRef, CommitStoreContext};
 use crate::entity_identity::EntityIdentity;
 use crate::functions::{
     FunctionProvider, FunctionProviderHandle, SharedFunctionProvider, SystemFunctionProvider,
 };
-use crate::json_store::JsonStoreContext;
-use crate::live_state::{LiveStateContext, LiveStateRow};
+use crate::json_store::{JsonRef, JsonStoreContext, JsonWritePlacementRef, NormalizedJsonRef};
 use crate::schema::{
     registered_schema_entity_id, schema_key_from_definition, seed_schema_definitions,
 };
 use crate::storage::{StorageContext, StorageWriteSet};
-use crate::untracked_state::MaterializedUntrackedStateRow;
-use crate::version::{
-    VERSION_DESCRIPTOR_SCHEMA_KEY, VERSION_DESCRIPTOR_SCHEMA_VERSION, VERSION_REF_SCHEMA_KEY,
-    VERSION_REF_SCHEMA_VERSION,
-};
+use crate::tracked_state::{TrackedStateContext, TrackedStateDeltaRef};
+use crate::untracked_state::{UntrackedStateContext, UntrackedStateRow};
+use crate::version::{VERSION_DESCRIPTOR_SCHEMA_KEY, VERSION_REF_SCHEMA_KEY};
 use crate::LixError;
 use crate::GLOBAL_VERSION_ID;
 use serde_json::json;
+#[cfg(test)]
+use std::sync::Arc;
 
 const KEY_VALUE_SCHEMA_KEY: &str = "lix_key_value";
-const KEY_VALUE_SCHEMA_VERSION: &str = "1";
 const LIX_ID_KEY: &str = "lix_id";
 const WORKSPACE_VERSION_KEY: &str = "lix_workspace_version_id";
-const COMMIT_SCHEMA_KEY: &str = "lix_commit";
-const COMMIT_SCHEMA_VERSION: &str = "1";
 const REGISTERED_SCHEMA_KEY: &str = "lix_registered_schema";
-const REGISTERED_SCHEMA_VERSION: &str = "1";
 
-/// Pure seed plan for initializing an engine2 repository.
+/// Pure seed plan for initializing an engine repository.
 ///
-/// Tracked bootstrap facts go to the changelog. Moving refs such as
-/// `lix_version_ref` are seeded as untracked local state so repository heads can
-/// advance without becoming commit members.
+/// Tracked bootstrap facts go to the commit store. Moving refs such as
+/// `lix_version_ref` are seeded as untracked local state so repository heads
+/// can advance without becoming commit members.
 pub(crate) struct InitSeedPlan {
-    pub(crate) changes: Vec<MaterializedCanonicalChange>,
-    pub(crate) untracked_rows: Vec<MaterializedUntrackedStateRow>,
+    commit: InitSeedCommit,
+    changes: Vec<InitSeedChange>,
+    untracked_rows: Vec<InitSeedLiveRow>,
     pub(crate) receipt: InitReceipt,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct InitSeedCommit {
+    id: String,
+    change_id: String,
+    parent_ids: Vec<String>,
+    author_account_ids: Vec<String>,
+    created_at: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct InitSeedChange {
+    id: String,
+    entity_id: EntityIdentity,
+    schema_key: String,
+    snapshot_content: String,
+    created_at: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct InitSeedLiveRow {
+    entity_id: EntityIdentity,
+    schema_key: String,
+    snapshot_content: String,
+    created_at: String,
+    updated_at: String,
+    global: bool,
+    version_id: String,
+}
+
 /// Values generated while planning the initial repository seed.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InitReceipt {
@@ -49,15 +72,14 @@ pub struct InitReceipt {
     pub initial_commit_id: String,
 }
 
-/// Builds the canonical bootstrap changes for a new engine2 repository.
+/// Builds the canonical bootstrap changes for a new engine repository.
 ///
 /// The initial commit tracks durable content rows. Version refs are moving
-/// pointers and therefore live in untracked local state instead of changelog.
+/// pointers and therefore live in untracked local state instead of the commit.
 pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSeedPlan, LixError> {
     let main_version_id = functions.call_uuid_v7();
     let lix_id = functions.call_uuid_v7();
     let initial_commit_id = functions.call_uuid_v7();
-    let initial_change_set_id = functions.call_uuid_v7();
     let timestamp = functions.call_timestamp();
 
     let mut registered_schema_changes = Vec::new();
@@ -65,9 +87,8 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         let key = schema_key_from_definition(schema)?;
         registered_schema_changes.push(canonical_change(
             functions.call_uuid_v7(),
-            registered_schema_entity_id(&key.schema_key, &key.schema_version)?,
+            registered_schema_entity_id(&key.schema_key)?,
             REGISTERED_SCHEMA_KEY,
-            REGISTERED_SCHEMA_VERSION,
             registered_schema_snapshot(schema)?,
             &timestamp,
         ));
@@ -77,7 +98,6 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         GLOBAL_VERSION_ID.to_string(),
         EntityIdentity::single(GLOBAL_VERSION_ID),
         VERSION_DESCRIPTOR_SCHEMA_KEY,
-        VERSION_DESCRIPTOR_SCHEMA_VERSION,
         version_descriptor_snapshot(GLOBAL_VERSION_ID, "global", true)?,
         &timestamp,
     );
@@ -85,7 +105,6 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         functions.call_uuid_v7(),
         EntityIdentity::single(&main_version_id),
         VERSION_DESCRIPTOR_SCHEMA_KEY,
-        VERSION_DESCRIPTOR_SCHEMA_VERSION,
         version_descriptor_snapshot(&main_version_id, "main", false)?,
         &timestamp,
     );
@@ -93,63 +112,44 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
         functions.call_uuid_v7(),
         EntityIdentity::single(LIX_ID_KEY),
         KEY_VALUE_SCHEMA_KEY,
-        KEY_VALUE_SCHEMA_VERSION,
         key_value_snapshot(LIX_ID_KEY, &lix_id)?,
         &timestamp,
     );
 
-    let initial_commit_change_ids = registered_schema_changes
-        .iter()
-        .map(|change| change.id.clone())
-        .chain([
-            global_version_descriptor_change.id.clone(),
-            main_version_descriptor_change.id.clone(),
-            kv_lix_id_change.id.clone(),
-        ])
-        .collect::<Vec<_>>();
-
-    let initial_commit_change = canonical_change(
-        functions.call_uuid_v7(),
-        EntityIdentity::single(&initial_commit_id),
-        COMMIT_SCHEMA_KEY,
-        COMMIT_SCHEMA_VERSION,
-        commit_snapshot(
-            &initial_commit_id,
-            &initial_change_set_id,
-            &initial_commit_change_ids,
-        )?,
-        &timestamp,
-    );
+    let initial_commit = InitSeedCommit {
+        id: initial_commit_id.clone(),
+        change_id: functions.call_uuid_v7(),
+        parent_ids: Vec::new(),
+        author_account_ids: Vec::new(),
+        created_at: timestamp.clone(),
+    };
     let global_version_ref_row = untracked_row(
         EntityIdentity::single(GLOBAL_VERSION_ID),
         VERSION_REF_SCHEMA_KEY,
-        VERSION_REF_SCHEMA_VERSION,
         version_ref_snapshot(GLOBAL_VERSION_ID, &initial_commit_id)?,
         &timestamp,
     );
     let main_version_ref_row = untracked_row(
         EntityIdentity::single(&main_version_id),
         VERSION_REF_SCHEMA_KEY,
-        VERSION_REF_SCHEMA_VERSION,
         version_ref_snapshot(&main_version_id, &initial_commit_id)?,
         &timestamp,
     );
     let workspace_version_row = untracked_row(
         EntityIdentity::single(WORKSPACE_VERSION_KEY),
         KEY_VALUE_SCHEMA_KEY,
-        KEY_VALUE_SCHEMA_VERSION,
         key_value_snapshot(WORKSPACE_VERSION_KEY, &main_version_id)?,
         &timestamp,
     );
 
     Ok(InitSeedPlan {
+        commit: initial_commit,
         changes: registered_schema_changes
             .into_iter()
             .chain([
                 global_version_descriptor_change,
                 main_version_descriptor_change,
                 kv_lix_id_change,
-                initial_commit_change,
             ])
             .collect(),
         untracked_rows: vec![
@@ -166,16 +166,17 @@ pub(crate) fn plan_init_seed(functions: FunctionProviderHandle) -> Result<InitSe
     })
 }
 
-/// Initializes an empty engine2 repository in one backend transaction.
+/// Initializes an empty engine repository in one backend transaction.
 ///
 /// The pure seed planner decides which bootstrap facts exist. This function is
 /// only responsible for durably writing those facts to their owning stores:
-/// changelog for tracked changes, and live_state for the serving projection plus
-/// untracked moving refs.
+/// commit_store for tracked changes, and live_state for the serving projection
+/// plus untracked moving refs.
 pub(crate) async fn initialize(
     storage: StorageContext,
-    changelog: &ChangelogContext,
-    live_state: &LiveStateContext,
+    commit_store: &CommitStoreContext,
+    tracked_state: &TrackedStateContext,
+    untracked_state: &UntrackedStateContext,
 ) -> Result<InitReceipt, LixError> {
     let functions = SharedFunctionProvider::new(
         Box::new(SystemFunctionProvider) as Box<dyn FunctionProvider + Send>
@@ -185,29 +186,64 @@ pub(crate) async fn initialize(
 
     let mut transaction = storage.begin_write_transaction().await?;
     let mut writes = StorageWriteSet::new();
-    let mut json_writer = JsonStoreContext::new().writer();
-
-    {
-        let canonical_changes = plan
-            .changes
-            .iter()
-            .map(|change| canonicalize_materialized_change(&mut writes, &mut json_writer, change))
-            .collect::<Result<Vec<_>, _>>()?;
-        let mut writer = changelog.writer(&mut writes);
-        writer.stage_changes(&canonical_changes)?;
-    }
 
-    let mut live_rows = plan
+    let authored_changes = plan
         .changes
         .iter()
-        .map(|change| live_state_row_from_initial_change(change, &receipt.initial_commit_id))
-        .collect::<Vec<_>>();
-    live_rows.extend(plan.untracked_rows.into_iter().map(LiveStateRow::from));
+        .map(seed_change_to_commit_store_change)
+        .collect::<Result<Vec<_>, _>>()?;
+    JsonStoreContext::new().writer().stage_batch(
+        &mut writes,
+        JsonWritePlacementRef::CommitPack {
+            commit_id: &plan.commit.id,
+            pack_id: 0,
+        },
+        plan.changes
+            .iter()
+            .map(|change| NormalizedJsonRef::new(change.snapshot_content.as_str())),
+    )?;
+
+    let staged_commit = {
+        let commit = CommitDraftRef {
+            id: &plan.commit.id,
+            change_id: &plan.commit.change_id,
+            parent_ids: &plan.commit.parent_ids,
+            author_account_ids: &plan.commit.author_account_ids,
+            created_at: &plan.commit.created_at,
+        };
+        let mut writer = commit_store.writer(transaction.as_mut(), &mut writes);
+        writer
+            .stage_tracked_commit_draft(
+                commit,
+                authored_changes.iter().map(Change::as_ref).collect(),
+                Vec::new(),
+            )
+            .await?
+    };
+
+    let untracked_rows = plan
+        .untracked_rows
+        .iter()
+        .map(untracked_state_row_from_seed)
+        .collect::<Result<Vec<_>, _>>()?;
 
     {
-        let mut writer = live_state.writer(transaction.as_mut());
+        untracked_state
+            .writer(&mut writes)
+            .stage_rows(untracked_rows.iter().map(|row| row.as_ref()))?;
+        let deltas = authored_changes
+            .iter()
+            .zip(&staged_commit.authored_locators)
+            .map(|(change, locator)| TrackedStateDeltaRef {
+                change: change.as_ref(),
+                locator: locator.as_ref(),
+                created_at: &change.created_at,
+                updated_at: &change.created_at,
+            })
+            .collect::<Vec<_>>();
+        let mut writer = tracked_state.writer(transaction.as_mut(), &mut writes);
         writer
-            .stage_rows(&mut writes, &mut json_writer, &live_rows)
+            .stage_delta(&receipt.initial_commit_id, None, &deltas)
             .await?;
     }
 
@@ -216,41 +252,42 @@ pub(crate) async fn initialize(
     Ok(receipt)
 }
 
-fn live_state_row_from_initial_change(
-    change: &MaterializedCanonicalChange,
-    initial_commit_id: &str,
-) -> LiveStateRow {
-    LiveStateRow {
+fn seed_change_to_commit_store_change(change: &InitSeedChange) -> Result<Change, LixError> {
+    Ok(Change {
+        id: change.id.clone(),
         entity_id: change.entity_id.clone(),
         schema_key: change.schema_key.clone(),
-        file_id: change.file_id.clone(),
-        snapshot_content: change.snapshot_content.clone(),
-        metadata: change.metadata.clone(),
-        schema_version: change.schema_version.clone(),
+        file_id: None,
+        snapshot_ref: Some(JsonRef::for_content(change.snapshot_content.as_bytes())),
+        metadata_ref: None,
         created_at: change.created_at.clone(),
-        updated_at: change.created_at.clone(),
-        global: true,
-        change_id: Some(change.id.clone()),
-        commit_id: Some(initial_commit_id.to_string()),
-        untracked: false,
-        version_id: GLOBAL_VERSION_ID.to_string(),
-    }
+    })
+}
+
+fn untracked_state_row_from_seed(row: &InitSeedLiveRow) -> Result<UntrackedStateRow, LixError> {
+    Ok(UntrackedStateRow {
+        entity_id: row.entity_id.clone(),
+        schema_key: row.schema_key.clone(),
+        file_id: None,
+        snapshot_content: Some(row.snapshot_content.clone()),
+        metadata: None,
+        created_at: row.created_at.clone(),
+        updated_at: row.updated_at.clone(),
+        global: row.global,
+        version_id: row.version_id.clone(),
+    })
 }
 
 fn untracked_row(
     entity_id: EntityIdentity,
     schema_key: &str,
-    schema_version: &str,
     snapshot_content: String,
     timestamp: &str,
-) -> MaterializedUntrackedStateRow {
-    MaterializedUntrackedStateRow {
+) -> InitSeedLiveRow {
+    InitSeedLiveRow {
         entity_id,
         schema_key: schema_key.to_string(),
-        file_id: None,
-        snapshot_content: Some(snapshot_content),
-        metadata: None,
-        schema_version: schema_version.to_string(),
+        snapshot_content,
         created_at: timestamp.to_string(),
         updated_at: timestamp.to_string(),
         global: true,
@@ -262,18 +299,14 @@ fn canonical_change(
     id: String,
     entity_id: EntityIdentity,
     schema_key: &str,
-    schema_version: &str,
     snapshot_content: String,
     created_at: &str,
-) -> MaterializedCanonicalChange {
-    MaterializedCanonicalChange {
+) -> InitSeedChange {
+    InitSeedChange {
         id,
         entity_id,
         schema_key: schema_key.to_string(),
-        schema_version: schema_version.to_string(),
-        file_id: None,
-        snapshot_content: Some(snapshot_content),
-        metadata: None,
+        snapshot_content,
         created_at: created_at.to_string(),
     }
 }
@@ -299,19 +332,6 @@ fn registered_schema_snapshot(schema: &serde_json::Value) -> Result<String, LixE
     }))
 }
 
-fn commit_snapshot(
-    id: &str,
-    change_set_id: &str,
-    change_ids: &[String],
-) -> Result<String, LixError> {
-    encode_snapshot(json!({
-        "id": id,
-        "change_set_id": change_set_id,
-        "change_ids": change_ids,
-        "parent_commit_ids": [],
-    }))
-}
-
 fn version_ref_snapshot(id: &str, commit_id: &str) -> Result<String, LixError> {
     encode_snapshot(json!({
         "id": id,
@@ -323,7 +343,7 @@ fn encode_snapshot(value: serde_json::Value) -> Result<String, LixError> {
     serde_json::to_string(&value).map_err(|error| {
         LixError::new(
             "LIX_ERROR_UNKNOWN",
-            format!("engine2 init seed snapshot serialization failed: {error}"),
+            format!("engine init seed snapshot serialization failed: {error}"),
         )
     })
 }
@@ -333,13 +353,17 @@ mod tests {
     use serde_json::Value as JsonValue;
 
     use super::*;
+    use crate::backend::{testing::UnitTestBackend, Backend};
     use crate::functions::{FunctionProvider, SharedFunctionProvider};
+    use crate::storage::StorageContext;
+    use crate::tracked_state::TrackedStateContext;
+    use crate::untracked_state::UntrackedStateContext;
 
     #[test]
     fn plan_init_seed_returns_tracked_changes_and_untracked_workspace_state() {
         let plan = plan_init_seed(test_functions()).expect("init seed should plan");
 
-        assert_eq!(plan.changes.len(), seed_schema_definitions().len() + 4);
+        assert_eq!(plan.changes.len(), seed_schema_definitions().len() + 3);
         assert_eq!(plan.untracked_rows.len(), 3);
         assert_eq!(plan.receipt.global_version_id, GLOBAL_VERSION_ID);
         assert_eq!(plan.receipt.main_version_id, "test-uuid-1");
@@ -348,28 +372,23 @@ mod tests {
     }
 
     #[test]
-    fn plan_init_seed_commit_tracks_schema_registrations_descriptor_and_lix_id_changes() {
+    fn plan_init_seed_commit_header_tracks_schema_registrations_descriptor_and_lix_id_changes() {
         let plan = plan_init_seed(test_functions()).expect("init seed should plan");
-        let commit_change = plan
-            .changes
-            .iter()
-            .find(|change| change.schema_key == COMMIT_SCHEMA_KEY)
-            .expect("initial commit change should exist");
-        let commit_snapshot = snapshot(commit_change);
 
-        assert_eq!(
-            commit_snapshot.get("id").and_then(JsonValue::as_str),
-            Some(plan.receipt.initial_commit_id.as_str())
-        );
-        let change_ids = commit_snapshot
-            .get("change_ids")
-            .and_then(JsonValue::as_array)
-            .expect("change_ids should be an array")
+        assert_eq!(plan.commit.id, plan.receipt.initial_commit_id);
+        assert_eq!(plan.commit.change_id, "test-uuid-21");
+        assert!(plan.commit.parent_ids.is_empty());
+        assert!(plan.commit.author_account_ids.is_empty());
+        assert_eq!(plan.commit.created_at, "test-timestamp-1");
+
+        let change_ids = plan
+            .changes
             .iter()
-            .map(|value| value.as_str().expect("change id should be text"))
+            .map(|change| change.id.as_str())
             .collect::<Vec<_>>();
         assert_eq!(change_ids.len(), seed_schema_definitions().len() + 3);
         assert!(change_ids.contains(&"global"));
+        assert!(!change_ids.contains(&plan.commit.change_id.as_str()));
 
         let registered_schema_change_ids = plan
             .changes
@@ -460,23 +479,57 @@ mod tests {
         );
     }
 
-    fn snapshot(change: &MaterializedCanonicalChange) -> JsonValue {
-        serde_json::from_str(
-            change
-                .snapshot_content
-                .as_deref()
-                .expect("change should have snapshot"),
+    #[tokio::test]
+    async fn initialize_writes_initial_commit_through_commit_store() {
+        let backend: Arc<dyn Backend + Send + Sync> = Arc::new(UnitTestBackend::new());
+        let storage = StorageContext::new(backend);
+        let commit_store = CommitStoreContext::new();
+        let tracked_state = TrackedStateContext::new();
+        let untracked_state = UntrackedStateContext::new();
+
+        let receipt = initialize(
+            storage.clone(),
+            &commit_store,
+            &tracked_state,
+            &untracked_state,
         )
-        .expect("snapshot should be JSON")
+        .await
+        .expect("engine should initialize");
+        let reader = commit_store.reader(storage.clone());
+        let commit = reader
+            .load_commit(&receipt.initial_commit_id)
+            .await
+            .expect("commit should load")
+            .expect("initial commit should exist");
+
+        assert_eq!(commit.id, receipt.initial_commit_id);
+        assert_eq!(commit.change_pack_count, 1);
+        assert_eq!(commit.membership_pack_count, 0);
+
+        let change_pack = reader
+            .load_change_pack(&commit.id, 0)
+            .await
+            .expect("change pack should load")
+            .expect("initial change pack should exist");
+        assert_eq!(change_pack.len(), seed_schema_definitions().len() + 3);
+        assert!(change_pack
+            .iter()
+            .all(|change| change.id != commit.change_id));
+
+        let entries = reader
+            .load_change_index_entries(&[commit.change_id.clone(), "global".to_string()])
+            .await
+            .expect("change index should load");
+        assert!(entries[0].is_some());
+        assert!(entries[1].is_some());
     }
 
-    fn untracked_snapshot(row: &MaterializedUntrackedStateRow) -> JsonValue {
-        serde_json::from_str(
-            row.snapshot_content
-                .as_deref()
-                .expect("row should have snapshot"),
-        )
-        .expect("snapshot should be JSON")
+    fn snapshot(change: &InitSeedChange) -> JsonValue {
+        serde_json::from_str(&change.snapshot_content).expect("snapshot should be JSON")
+    }
+
+    fn untracked_snapshot(row: &InitSeedLiveRow) -> JsonValue {
+        serde_json::from_str(&row.snapshot_content).expect("snapshot should be JSON")
     }
 
     fn test_functions() -> FunctionProviderHandle {