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

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

@@ -1,14 +1,18 @@
 use std::collections::HashMap;
 
+use crate::json_store::JsonStoreContext;
 use crate::storage::{KvGetGroup, KvGetRequest, StorageReader, StorageWriteSet};
 use crate::tracked_state::codec::PendingChunkWrite;
-use crate::tracked_state::tree_types::{TrackedStateRootId, TRACKED_STATE_HASH_BYTES};
+use crate::tracked_state::types::{
+    TrackedStateDeltaEntry, TrackedStateDeltaRef, TrackedStateRootId, TRACKED_STATE_HASH_BYTES,
+};
 use crate::LixError;
 
 pub(crate) const TRACKED_STATE_CHUNK_NAMESPACE: &'static str = "tracked_state.tree.chunk";
 pub(crate) const TRACKED_STATE_ROOT_NAMESPACE: &'static str = "tracked_state.tree.root";
 pub(crate) const TRACKED_STATE_BY_FILE_ROOT_NAMESPACE: &'static str =
     "tracked_state.tree.root.by_file";
+pub(crate) const TRACKED_STATE_DELTA_PACK_NAMESPACE: &'static str = "tracked_state.delta_pack";
 
 async fn get_one(
     store: &mut (impl StorageReader + ?Sized),
@@ -85,13 +89,141 @@ pub(crate) fn stage_by_file_root(
     );
 }
 
-#[cfg(test)]
-pub(crate) fn stage_delete_root(writes: &mut StorageWriteSet, commit_id: &str) {
-    writes.delete(TRACKED_STATE_ROOT_NAMESPACE, commit_id.as_bytes().to_vec());
-    writes.delete(
-        TRACKED_STATE_BY_FILE_ROOT_NAMESPACE,
+pub(crate) async fn load_delta_pack(
+    store: &mut (impl StorageReader + ?Sized),
+    commit_id: &str,
+) -> Result<Option<Vec<TrackedStateDeltaEntry>>, LixError> {
+    let json_store = JsonStoreContext::new();
+    let result = store
+        .get_values(KvGetRequest {
+            groups: vec![
+                KvGetGroup {
+                    namespace: TRACKED_STATE_DELTA_PACK_NAMESPACE.to_string(),
+                    keys: vec![commit_id.as_bytes().to_vec()],
+                },
+                json_store.commit_pack_get_group(commit_id, 0),
+            ],
+        })
+        .await?;
+    let mut groups = result.groups.into_iter();
+    let delta_group = groups.next().ok_or_else(|| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            "tracked-state delta pack load returned no delta result group",
+        )
+    })?;
+    let json_pack_group = groups.next().ok_or_else(|| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            "tracked-state delta pack load returned no JSON pack result group",
+        )
+    })?;
+    let Some(bytes) = delta_group.single_value_owned() else {
+        return Ok(None);
+    };
+    let pack_refs = if crate::tracked_state::codec::delta_pack_uses_json_pack_indexes(&bytes)? {
+        json_pack_group
+            .single_value_owned()
+            .map(|bytes| json_store.decode_pack_refs(&bytes))
+            .transpose()?
+    } else {
+        None
+    };
+    let (stored_commit_id, entries) =
+        crate::tracked_state::codec::decode_delta_pack(&bytes, pack_refs.as_deref())?;
+    if stored_commit_id != commit_id {
+        return Err(LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            format!(
+                "tracked-state delta pack identity mismatch: expected '{commit_id}', got '{stored_commit_id}'"
+            ),
+        ));
+    }
+    Ok(Some(entries))
+}
+
+pub(crate) async fn delta_pack_exists(
+    store: &mut (impl StorageReader + ?Sized),
+    commit_id: &str,
+) -> Result<bool, LixError> {
+    let result = store
+        .exists_many(KvGetRequest {
+            groups: vec![KvGetGroup {
+                namespace: TRACKED_STATE_DELTA_PACK_NAMESPACE.to_string(),
+                keys: vec![commit_id.as_bytes().to_vec()],
+            }],
+        })
+        .await?;
+    let group = result.groups.into_iter().next().ok_or_else(|| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            "tracked-state delta pack existence check returned no result group",
+        )
+    })?;
+    group.exists.into_iter().next().ok_or_else(|| {
+        LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            "tracked-state delta pack existence check returned no result",
+        )
+    })
+}
+
+pub(crate) fn stage_delta_pack_refs(
+    writes: &mut StorageWriteSet,
+    commit_id: &str,
+    deltas: &[TrackedStateDeltaRef<'_>],
+) -> Result<(), LixError> {
+    writes.put(
+        TRACKED_STATE_DELTA_PACK_NAMESPACE,
+        commit_id.as_bytes().to_vec(),
+        crate::tracked_state::codec::encode_delta_pack_refs(commit_id, deltas)?,
+    );
+    Ok(())
+}
+
+pub(crate) struct DeltaJsonPackIndexesRef<'a> {
+    pub(crate) commit_id: &'a str,
+    pub(crate) pack_id: u32,
+    pub(crate) indexes: &'a std::collections::HashMap<[u8; TRACKED_STATE_HASH_BYTES], usize>,
+}
+
+pub(crate) fn stage_delta_pack_refs_with_json_pack_indexes(
+    writes: &mut StorageWriteSet,
+    commit_id: &str,
+    deltas: &[TrackedStateDeltaRef<'_>],
+    json_pack_indexes: DeltaJsonPackIndexesRef<'_>,
+) -> Result<(), LixError> {
+    if json_pack_indexes.commit_id != commit_id {
+        return Err(LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            format!(
+                "tracked-state delta JSON pack indexes for '{}' cannot encode delta pack '{}'",
+                json_pack_indexes.commit_id, commit_id
+            ),
+        ));
+    }
+    if json_pack_indexes.pack_id != 0 {
+        return Err(LixError::new(
+            LixError::CODE_INTERNAL_ERROR,
+            format!(
+                "tracked-state delta JSON pack indexes only support pack 0, got pack {}",
+                json_pack_indexes.pack_id
+            ),
+        ));
+    }
+    if json_pack_indexes.indexes.is_empty() {
+        return stage_delta_pack_refs(writes, commit_id, deltas);
+    }
+    writes.put(
+        TRACKED_STATE_DELTA_PACK_NAMESPACE,
         commit_id.as_bytes().to_vec(),
+        crate::tracked_state::codec::encode_delta_pack_refs_with_json_pack_indexes(
+            commit_id,
+            deltas,
+            Some(json_pack_indexes.indexes),
+        )?,
     );
+    Ok(())
 }
 
 pub(crate) async fn read_chunk(