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

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

@@ -1,48 +1,49 @@
 use std::sync::Arc;
 
 use crate::binary_cas::BinaryCasContext;
+use crate::branch::{BranchContext, BranchRefReader};
 use crate::catalog::CatalogContext;
 use crate::commit_graph::CommitGraphContext;
-use crate::commit_store::CommitStoreContext;
-use crate::entity_identity::EntityIdentity;
+use crate::entity_pk::EntityPk;
 use crate::init::InitReceipt;
 use crate::live_state::LiveStateContext;
 use crate::live_state::LiveStateRowRequest;
 use crate::session::SessionContext;
+use crate::storage::{DurableWriteLock, StorageBackend, StorageReadOptions, StorageWriteOptions};
 use crate::storage::{StorageContext, StorageWriteSet};
 use crate::tracked_state::TrackedStateContext;
 use crate::untracked_state::UntrackedStateContext;
-use crate::version::{VersionContext, VersionRefReader};
-use crate::GLOBAL_VERSION_ID;
-use crate::{Backend, LixError, NullableKeyFilter};
+use crate::GLOBAL_BRANCH_ID;
+use crate::{LixError, NullableKeyFilter};
 
 #[derive(Clone)]
-pub struct Engine {
-    storage: StorageContext,
+pub struct Engine<B: StorageBackend = crate::storage::InMemoryStorageBackend> {
+    storage: StorageContext<B>,
     tracked_state: Arc<TrackedStateContext>,
     live_state: Arc<LiveStateContext>,
-    version_ctx: Arc<VersionContext>,
+    branch_ctx: Arc<BranchContext>,
     binary_cas: Arc<BinaryCasContext>,
-    commit_store: Arc<CommitStoreContext>,
     catalog_context: Arc<CatalogContext>,
+    write_lock: DurableWriteLock,
 }
 
-impl Engine {
+impl<B> Engine<B>
+where
+    B: StorageBackend + Clone + Send + Sync + 'static,
+    for<'backend> B::Read<'backend>: Clone + Send + Sync + 'static,
+    for<'backend> B::Write<'backend>: Send,
+{
     /// Seeds an empty backend with the engine repository bootstrap facts.
     ///
     /// Initialization is a storage lifecycle operation, separate from runtime
     /// construction. Call this before `Engine::new(...)` for a brand-new
     /// backend.
-    pub async fn initialize(
-        backend: Box<dyn Backend + Send + Sync>,
-    ) -> Result<InitReceipt, LixError> {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::from(backend);
+    pub async fn initialize(backend: B) -> Result<InitReceipt, LixError> {
         let storage = StorageContext::new(backend);
-        let commit_store = CommitStoreContext::new();
+        let _write_guard = storage.durable_write_lock().lock_owned().await;
 
         crate::init::initialize(
             storage,
-            &commit_store,
             &TrackedStateContext::new(),
             &UntrackedStateContext::new(),
         )
@@ -53,20 +54,18 @@ impl Engine {
     ///
     /// SessionContext, execution, and transaction overlays are layered below the
     /// instance instead of being hidden behind a legacy boot path.
-    pub async fn new(backend: Box<dyn Backend + Send + Sync>) -> Result<Self, LixError> {
-        let backend: Arc<dyn Backend + Send + Sync> = Arc::from(backend);
+    pub async fn new(backend: B) -> Result<Self, LixError> {
         let storage = StorageContext::new(backend);
 
         let tracked_state = Arc::new(TrackedStateContext::new());
         let untracked_state = Arc::new(UntrackedStateContext::new());
-        let commit_store = Arc::new(CommitStoreContext::new());
         let commit_graph = CommitGraphContext::new();
         let live_state = Arc::new(LiveStateContext::new(
             tracked_state.as_ref().clone(),
             *untracked_state,
             commit_graph,
         ));
-        let version_ctx = Arc::new(VersionContext::new(Arc::clone(&untracked_state)));
+        let branch_ctx = Arc::new(BranchContext::new(Arc::clone(&untracked_state)));
         assert_initialized(storage.clone(), live_state.as_ref()).await?;
 
         // SessionContext::execute later projects these stable state contexts into one
@@ -75,144 +74,123 @@ impl Engine {
 
         Ok(Self {
             binary_cas: Arc::new(BinaryCasContext::new()),
-            commit_store,
+            write_lock: storage.durable_write_lock(),
             storage,
             tracked_state,
             live_state,
-            version_ctx,
+            branch_ctx,
             catalog_context: Arc::new(CatalogContext::new()),
         })
     }
 
-    pub(crate) fn storage(&self) -> StorageContext {
+    pub(crate) fn storage(&self) -> StorageContext<B> {
         self.storage.clone()
     }
 
-    /// Loads the current commit head for a version.
+    /// Loads the current commit head for a branch.
     ///
-    /// This is the public engine-level form of the typed `version_ref` context:
-    /// callers should not need to know that version heads are represented as
-    /// untracked `lix_version_ref` rows in live_state.
-    pub async fn load_version_head_commit_id(
+    /// This is the public engine-level form of the typed `branch_ref` context:
+    /// callers should not need to know that branch heads are represented as
+    /// untracked `lix_branch_ref` rows in live_state.
+    pub async fn load_branch_head_commit_id(
         &self,
-        version_id: &str,
+        branch_id: &str,
     ) -> Result<Option<String>, LixError> {
-        let mut transaction = self.storage.begin_read_transaction().await?;
+        let read = self.storage.begin_read(StorageReadOptions::default())?;
         let result = self
-            .version_ctx
-            .ref_reader(transaction.as_mut())
-            .load_head_commit_id(version_id)
+            .branch_ctx
+            .ref_reader(&read)
+            .load_head_commit_id(branch_id)
             .await;
-        match result {
-            Ok(result) => {
-                transaction.rollback().await?;
-                Ok(result)
-            }
-            Err(error) => {
-                let _ = transaction.rollback().await;
-                Err(error)
-            }
-        }
+        result
     }
 
     pub async fn open_session(
         &self,
-        active_version_id: impl Into<String>,
-    ) -> Result<SessionContext, LixError> {
+        active_branch_id: impl Into<String>,
+    ) -> Result<SessionContext<B>, LixError> {
         SessionContext::open(
-            active_version_id.into(),
+            active_branch_id.into(),
             self.storage(),
             Arc::clone(&self.live_state),
             Arc::clone(&self.tracked_state),
             Arc::clone(&self.binary_cas),
-            Arc::clone(&self.commit_store),
-            Arc::clone(&self.version_ctx),
+            Arc::clone(&self.branch_ctx),
             Arc::clone(&self.catalog_context),
+            self.write_lock.clone(),
         )
         .await
     }
 
-    pub async fn open_workspace_session(&self) -> Result<SessionContext, LixError> {
+    pub async fn open_workspace_session(&self) -> Result<SessionContext<B>, LixError> {
         SessionContext::open_workspace(
             self.storage(),
             Arc::clone(&self.live_state),
             Arc::clone(&self.tracked_state),
             Arc::clone(&self.binary_cas),
-            Arc::clone(&self.commit_store),
-            Arc::clone(&self.version_ctx),
+            Arc::clone(&self.branch_ctx),
             Arc::clone(&self.catalog_context),
+            self.write_lock.clone(),
         )
         .await
     }
 
-    /// Materializes the tracked serving projection root for one version from commit_store.
+    /// Rebuilds the tracked serving commit root for one branch from changelog.
     ///
     /// This is intentionally an engine-level operation: callers should not need
     /// to know which KV namespaces back changelog, commit graph, or tracked
-    /// state. The current version head is read from the live-state facade so
-    /// materialization uses the same moving-ref visibility as normal execution.
-    pub async fn rebuild_tracked_state_for_version(
-        &self,
-        version_id: &str,
-    ) -> Result<(), LixError> {
+    /// state. The current branch head is read from the live-state facade so
+    /// rebuild uses the same moving-ref visibility as normal execution.
+    pub async fn rebuild_tracked_state_for_branch(&self, branch_id: &str) -> Result<(), LixError> {
+        let _write_guard = self.write_lock.lock_owned().await;
         let head_commit_id = self
-            .load_version_head_commit_id(version_id)
+            .load_branch_head_commit_id(branch_id)
             .await?
             .ok_or_else(|| {
-                LixError::version_not_found(
-                    version_id.to_string(),
-                    "rebuild_tracked_state_for_version",
+                LixError::branch_not_found(
+                    branch_id.to_string(),
+                    "rebuild_tracked_state_for_branch",
                     "target",
                 )
             })?;
         let storage = self.storage();
-        let mut transaction = storage.begin_write_transaction().await?;
+        let read = storage.begin_read(StorageReadOptions::default())?;
         let mut writes = StorageWriteSet::new();
-        let materialize_result = self
+        let rebuild_result = self
             .tracked_state
-            .materializer(
-                transaction.as_mut(),
-                &mut writes,
-                self.commit_store.as_ref(),
-            )
-            .materialize_root_at(&head_commit_id)
+            .root_rebuilder(&read, &mut writes)
+            .rebuild_commit_root_at(&head_commit_id)
             .await;
-        if let Err(error) = materialize_result {
-            let _ = transaction.rollback().await;
-            return Err(error);
-        }
-        if let Err(error) = writes.apply(&mut transaction.as_mut()).await {
-            let _ = transaction.rollback().await;
+        if let Err(error) = rebuild_result {
             return Err(error);
         }
-        transaction.commit().await
+        storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .map(|_| ())
+            .map_err(Into::into)
     }
 }
 
-async fn assert_initialized(
-    storage: StorageContext,
+async fn assert_initialized<B>(
+    storage: StorageContext<B>,
     live_state: &LiveStateContext,
-) -> Result<(), LixError> {
-    let mut transaction = storage.begin_read_transaction().await?;
-    let reader = live_state.reader(transaction.as_mut());
-    let result = reader
+) -> Result<(), LixError>
+where
+    B: StorageBackend + Clone + Send + Sync + 'static,
+    for<'backend> B::Read<'backend>: Clone + Send + Sync + 'static,
+    for<'backend> B::Write<'backend>: Send,
+{
+    let read = storage.begin_read(StorageReadOptions::default())?;
+    let reader = live_state.reader(&read);
+    let initialized = reader
         .load_row(&LiveStateRowRequest {
             schema_key: "lix_key_value".to_string(),
-            version_id: GLOBAL_VERSION_ID.to_string(),
-            entity_id: EntityIdentity::single("lix_id"),
+            branch_id: GLOBAL_BRANCH_ID.to_string(),
+            entity_pk: EntityPk::single("lix_id"),
             file_id: NullableKeyFilter::Null,
         })
-        .await;
-    let initialized = match result {
-        Ok(row) => {
-            transaction.rollback().await?;
-            row.is_some()
-        }
-        Err(error) => {
-            let _ = transaction.rollback().await;
-            return Err(error);
-        }
-    };
+        .await?
+        .is_some();
 
     if initialized {
         return Ok(());