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

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

@@ -1,11 +0,0 @@
-mod chunking;
-mod codec;
-mod context;
-pub(crate) mod kv;
-mod types;
-
-pub(crate) use context::{BinaryCasContext, BlobDataReader};
-pub(crate) use types::{
-    BlobBytesBatch, BlobExistsBatch, BlobHash, BlobLayout, BlobMetadata, BlobMetadataBatch,
-    BlobWrite, BlobWriteReceipt,
-};

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

@@ -1,121 +0,0 @@
-use crate::binary_cas::codec::{binary_blob_hash_bytes, hash_bytes_to_hex, hash_hex_to_bytes};
-use crate::LixError;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub(crate) struct BlobHash([u8; 32]);
-
-impl BlobHash {
-    pub(crate) fn from_bytes(bytes: [u8; 32]) -> Self {
-        Self(bytes)
-    }
-
-    pub(crate) fn from_content(content: &[u8]) -> Self {
-        Self(binary_blob_hash_bytes(content))
-    }
-
-    pub(crate) fn from_hex(hash_hex: &str) -> Result<Self, LixError> {
-        Ok(Self(hash_hex_to_bytes(hash_hex, "binary CAS blob")?))
-    }
-
-    pub(crate) fn to_hex(self) -> String {
-        hash_bytes_to_hex(&self.0)
-    }
-
-    pub(crate) fn as_bytes(&self) -> &[u8; 32] {
-        &self.0
-    }
-
-    pub(crate) fn into_bytes(self) -> [u8; 32] {
-        self.0
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum BlobLayout {
-    Empty,
-    SingleChunk { chunk_hash: BlobHash },
-    Chunked { chunk_count: u32 },
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BlobMetadata {
-    pub(crate) hash: BlobHash,
-    pub(crate) size_bytes: u64,
-    pub(crate) layout: BlobLayout,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BlobExistsBatch {
-    entries: Vec<bool>,
-}
-
-impl BlobExistsBatch {
-    pub(crate) fn new(entries: Vec<bool>) -> Self {
-        Self { entries }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn get(&self, index: usize) -> bool {
-        self.entries.get(index).copied().unwrap_or(false)
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn into_vec(self) -> Vec<bool> {
-        self.entries
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BlobMetadataBatch {
-    entries: Vec<Option<BlobMetadata>>,
-}
-
-impl BlobMetadataBatch {
-    pub(crate) fn new(entries: Vec<Option<BlobMetadata>>) -> Self {
-        Self { entries }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn get(&self, index: usize) -> Option<&BlobMetadata> {
-        self.entries.get(index).and_then(Option::as_ref)
-    }
-
-    pub(crate) fn into_vec(self) -> Vec<Option<BlobMetadata>> {
-        self.entries
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BlobBytesBatch {
-    entries: Vec<Option<Vec<u8>>>,
-}
-
-impl BlobBytesBatch {
-    pub(crate) fn new(entries: Vec<Option<Vec<u8>>>) -> Self {
-        Self { entries }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn get(&self, index: usize) -> Option<&[u8]> {
-        self.entries
-            .get(index)
-            .and_then(Option::as_ref)
-            .map(Vec::as_slice)
-    }
-
-    pub(crate) fn into_vec(self) -> Vec<Option<Vec<u8>>> {
-        self.entries
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct BlobWrite<'a> {
-    pub(crate) bytes: &'a [u8],
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BlobWriteReceipt {
-    pub(crate) hash: BlobHash,
-    pub(crate) size_bytes: u64,
-    pub(crate) layout: BlobLayout,
-}

package/dist-engine-src/src/branch/context.rs

@@ -1,40 +0,0 @@
-use std::sync::Arc;
-
-use crate::storage::{StorageRead, StorageWriteSet};
-use crate::untracked_state::{UntrackedStateContext, UntrackedStateRow};
-
-use super::refs::BranchRefContext;
-use super::BranchRefReader;
-
-/// Aggregate entrypoint for branch-domain services.
-///
-/// Today this owns the moving-ref subsystem. Descriptor helpers are re-exported
-/// by `branch`; future branch APIs can grow here without making session or
-/// SQL code depend directly on ref storage details.
-pub(crate) struct BranchContext {
-    refs: Arc<BranchRefContext>,
-}
-
-impl BranchContext {
-    pub(crate) fn new(untracked_state: Arc<UntrackedStateContext>) -> Self {
-        Self {
-            refs: Arc::new(BranchRefContext::new(untracked_state)),
-        }
-    }
-
-    /// Creates a branch-ref reader over a caller-provided KV store.
-    pub(crate) fn ref_reader<S>(&self, store: S) -> impl BranchRefReader
-    where
-        S: StorageRead + Send + Sync,
-    {
-        self.refs.reader(store)
-    }
-
-    pub(crate) fn stage_canonical_ref_rows(
-        &self,
-        writes: &mut StorageWriteSet,
-        rows: &[UntrackedStateRow],
-    ) -> Result<(), crate::LixError> {
-        self.refs.writer(writes).stage_rows(rows)
-    }
-}

package/dist-engine-src/src/branch/lifecycle.rs

@@ -1,221 +0,0 @@
-use crate::commit_graph::{CommitGraphCommit, CommitGraphReader};
-use crate::common::validate_non_empty_identity_value;
-use crate::LixError;
-
-use super::{BranchHead, BranchRefReader};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum BranchOperation {
-    CreateBranch,
-    SwitchBranch,
-    MergeBranch,
-    MergeBranchPreview,
-    LoadWorkspaceSelector,
-}
-
-impl BranchOperation {
-    pub(crate) fn label(self) -> &'static str {
-        match self {
-            Self::CreateBranch => "create_branch",
-            Self::SwitchBranch => "switch_branch",
-            Self::MergeBranch => "merge_branch",
-            Self::MergeBranchPreview => "merge_branch_preview",
-            Self::LoadWorkspaceSelector => "load_workspace_branch_id",
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum BranchReferenceRole {
-    Source,
-    Target,
-    WorkspaceSelector,
-    CommitSource,
-}
-
-impl BranchReferenceRole {
-    pub(crate) fn label(self) -> &'static str {
-        match self {
-            Self::Source => "source",
-            Self::Target => "target",
-            Self::WorkspaceSelector => "workspace_selector",
-            Self::CommitSource => "commit_source",
-        }
-    }
-}
-
-/// Shared domain service for resolving public branch references.
-///
-/// Built-in branch schemas describe row shape. This service owns semantic
-/// ref validation: non-empty ids, global sentinel handling, and missing refs.
-pub(crate) struct BranchLifecycle<'a> {
-    refs: &'a dyn BranchRefReader,
-}
-
-impl<'a> BranchLifecycle<'a> {
-    pub(crate) fn new(refs: &'a dyn BranchRefReader) -> Self {
-        Self { refs }
-    }
-
-    pub(crate) fn require_non_empty_id(
-        branch_id: &str,
-        operation: BranchOperation,
-        role: BranchReferenceRole,
-    ) -> Result<(), LixError> {
-        require_non_empty_public_id("branch_id", branch_id, operation, role)
-    }
-
-    pub(crate) async fn require_existing_commit(
-        commit_graph: &mut dyn CommitGraphReader,
-        commit_id: &str,
-        operation: BranchOperation,
-        role: BranchReferenceRole,
-    ) -> Result<CommitGraphCommit, LixError> {
-        require_non_empty_public_id("commit_id", commit_id, operation, role)?;
-        commit_graph
-            .load_commit(commit_id)
-            .await?
-            .ok_or_else(|| LixError::commit_not_found(commit_id, operation.label(), role.label()))
-    }
-
-    pub(crate) async fn require_existing_ref(
-        &self,
-        branch_id: &str,
-        operation: BranchOperation,
-        role: BranchReferenceRole,
-    ) -> Result<BranchHead, LixError> {
-        Self::require_non_empty_id(branch_id, operation, role)?;
-        self.require_existing_stored_ref(branch_id, operation, role)
-            .await
-    }
-
-    pub(crate) async fn require_existing_commit_id(
-        &self,
-        branch_id: &str,
-        operation: BranchOperation,
-        role: BranchReferenceRole,
-    ) -> Result<String, LixError> {
-        Ok(self
-            .require_existing_ref(branch_id, operation, role)
-            .await?
-            .commit_id)
-    }
-
-    async fn require_existing_stored_ref(
-        &self,
-        branch_id: &str,
-        operation: BranchOperation,
-        role: BranchReferenceRole,
-    ) -> Result<BranchHead, LixError> {
-        self.refs
-            .load_head(branch_id)
-            .await?
-            .ok_or_else(|| LixError::branch_not_found(branch_id, operation.label(), role.label()))
-    }
-}
-
-fn require_non_empty_public_id(
-    label: &str,
-    value: &str,
-    operation: BranchOperation,
-    role: BranchReferenceRole,
-) -> Result<(), LixError> {
-    validate_non_empty_identity_value(label, value)
-        .map(|_| ())
-        .map_err(|_| {
-            LixError::new(
-                LixError::CODE_INVALID_PARAM,
-                format!(
-                    "{} {} {label} must be non-empty",
-                    operation.label(),
-                    role.label()
-                ),
-            )
-        })
-}
-
-#[cfg(test)]
-mod tests {
-    use async_trait::async_trait;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn require_existing_ref_returns_head() {
-        let reader = RowsBranchRefReader::new(vec![BranchHead {
-            branch_id: "branch-a".to_string(),
-            commit_id: "commit-a".to_string(),
-        }]);
-        let lifecycle = BranchLifecycle::new(&reader);
-
-        let head = lifecycle
-            .require_existing_ref(
-                "branch-a",
-                BranchOperation::SwitchBranch,
-                BranchReferenceRole::Target,
-            )
-            .await
-            .expect("branch should resolve");
-
-        assert_eq!(head.commit_id, "commit-a");
-    }
-
-    #[tokio::test]
-    async fn require_existing_ref_rejects_empty_id_as_invalid_param() {
-        let reader = RowsBranchRefReader::new(Vec::new());
-        let lifecycle = BranchLifecycle::new(&reader);
-
-        let error = lifecycle
-            .require_existing_ref(
-                "",
-                BranchOperation::SwitchBranch,
-                BranchReferenceRole::Target,
-            )
-            .await
-            .expect_err("empty branch id should be rejected before lookup");
-
-        assert_eq!(error.code, LixError::CODE_INVALID_PARAM);
-    }
-
-    #[tokio::test]
-    async fn require_existing_ref_reports_missing_branch() {
-        let reader = RowsBranchRefReader::new(Vec::new());
-        let lifecycle = BranchLifecycle::new(&reader);
-
-        let error = lifecycle
-            .require_existing_ref(
-                "missing",
-                BranchOperation::SwitchBranch,
-                BranchReferenceRole::Target,
-            )
-            .await
-            .expect_err("missing branch should be rejected");
-
-        assert_eq!(error.code, LixError::CODE_BRANCH_NOT_FOUND);
-    }
-
-    struct RowsBranchRefReader {
-        heads: Vec<BranchHead>,
-    }
-
-    impl RowsBranchRefReader {
-        fn new(heads: Vec<BranchHead>) -> Self {
-            Self { heads }
-        }
-    }
-
-    #[async_trait]
-    impl BranchRefReader for RowsBranchRefReader {
-        async fn load_head(&self, branch_id: &str) -> Result<Option<BranchHead>, LixError> {
-            Ok(self
-                .heads
-                .iter()
-                .find(|head| head.branch_id == branch_id)
-                .cloned())
-        }
-
-        async fn scan_heads(&self) -> Result<Vec<BranchHead>, LixError> {
-            Ok(self.heads.clone())
-        }
-    }
-}

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

@@ -1,13 +0,0 @@
-mod context;
-mod lifecycle;
-mod refs;
-mod stage_rows;
-mod types;
-
-pub(crate) use context::BranchContext;
-pub(crate) use lifecycle::{BranchLifecycle, BranchOperation, BranchReferenceRole};
-pub(crate) use stage_rows::{
-    branch_descriptor_stage_row, branch_descriptor_tombstone_row, branch_ref_stage_row,
-    branch_ref_tombstone_row, BRANCH_DESCRIPTOR_SCHEMA_KEY, BRANCH_REF_SCHEMA_KEY,
-};
-pub(crate) use types::{BranchHead, BranchRefReader};