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

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

@@ -1,37 +0,0 @@
-use crate::entity_identity::EntityIdentity;
-use crate::untracked_state::UntrackedStateRow;
-use crate::version::VERSION_REF_SCHEMA_KEY;
-use crate::{LixError, GLOBAL_VERSION_ID};
-
-pub(crate) struct PreparedVersionRefRow {
-    pub(crate) row: UntrackedStateRow,
-}
-
-pub(crate) fn prepare_version_ref_row(
-    version_id: &str,
-    commit_id: &str,
-    timestamp: &str,
-) -> Result<PreparedVersionRefRow, LixError> {
-    let snapshot = serde_json::json!({
-        "id": version_id,
-        "commit_id": commit_id,
-    });
-    let snapshot = crate::json_store::NormalizedJson::from_value(
-        &snapshot,
-        "engine version-ref snapshot_content",
-    )?;
-
-    Ok(PreparedVersionRefRow {
-        row: UntrackedStateRow {
-            entity_id: EntityIdentity::single(version_id),
-            schema_key: VERSION_REF_SCHEMA_KEY.to_string(),
-            file_id: None,
-            snapshot_content: Some(snapshot.as_str().to_string()),
-            metadata: None,
-            created_at: timestamp.to_string(),
-            updated_at: timestamp.to_string(),
-            global: true,
-            version_id: GLOBAL_VERSION_ID.to_string(),
-        },
-    })
-}

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

@@ -1,149 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-
-use crate::catalog::{CatalogContext, CatalogSnapshot, SchemaCatalogFact};
-use crate::domain::Domain;
-use crate::live_state::{
-    LiveStateReader, LiveStateRowRequest, LiveStateScanRequest, MaterializedLiveStateRow,
-};
-use crate::transaction::live_state_overlay::overlay_scan_rows;
-use crate::transaction::staging::PreparedStateRowOverlay;
-use crate::LixError;
-
-pub(crate) struct TransactionSchemaResolver {
-    context: Arc<CatalogContext>,
-    catalogs_by_domain: BTreeMap<Domain, CatalogEntry>,
-}
-
-enum CatalogEntry {
-    SchemaFacts(Vec<SchemaCatalogFact>),
-    Catalog(CatalogSnapshot),
-}
-
-impl TransactionSchemaResolver {
-    pub(crate) fn new(context: Arc<CatalogContext>) -> Self {
-        Self {
-            context,
-            catalogs_by_domain: BTreeMap::new(),
-        }
-    }
-
-    async fn load_catalog_for_domain(
-        &mut self,
-        live_state: &dyn LiveStateReader,
-        staged: Option<&PreparedStateRowOverlay>,
-        domain: &Domain,
-    ) -> Result<(), LixError> {
-        let domain = domain.schema_catalog_domain();
-        let needs_load = !self.catalogs_by_domain.contains_key(&domain);
-        if needs_load {
-            let facts = if let Some(staged) = staged {
-                let reader = TransactionSchemaLiveStateReader {
-                    base: live_state,
-                    staged,
-                };
-                self.context
-                    .schema_facts_for_domain(&reader, &domain)
-                    .await?
-            } else {
-                self.context
-                    .schema_facts_for_domain(live_state, &domain)
-                    .await?
-            };
-            self.catalogs_by_domain
-                .insert(domain.clone(), CatalogEntry::SchemaFacts(facts));
-        }
-
-        let should_materialize = self
-            .catalogs_by_domain
-            .get(&domain)
-            .is_some_and(|entry| matches!(entry, CatalogEntry::SchemaFacts(_)));
-        if should_materialize {
-            #[cfg(feature = "storage-benches")]
-            crate::storage_bench::record_transaction_schema_catalog_load();
-            let entry = self
-                .catalogs_by_domain
-                .remove(&domain)
-                .expect("schema catalog entry should exist after load");
-            let CatalogEntry::SchemaFacts(facts) = entry else {
-                unreachable!("catalog entry was checked as schema facts");
-            };
-            let catalog = CatalogSnapshot::from_schema_facts(&facts)?;
-            self.catalogs_by_domain
-                .insert(domain, CatalogEntry::Catalog(catalog));
-        }
-        Ok(())
-    }
-
-    pub(crate) async fn catalog_for_row_normalization(
-        &mut self,
-        live_state: &dyn LiveStateReader,
-        staged: &PreparedStateRowOverlay,
-        domain: &Domain,
-    ) -> Result<&mut CatalogSnapshot, LixError> {
-        self.load_catalog_for_domain(live_state, Some(staged), domain)
-            .await?;
-        let domain = domain.schema_catalog_domain();
-        match self
-            .catalogs_by_domain
-            .get_mut(&domain)
-            .expect("catalog cache should contain requested version")
-        {
-            CatalogEntry::Catalog(catalog) => Ok(catalog),
-            CatalogEntry::SchemaFacts(_) => {
-                unreachable!("schema catalog should be materialized before mutable access")
-            }
-        }
-    }
-
-    pub(crate) async fn catalog_for_validation(
-        &mut self,
-        live_state: &dyn LiveStateReader,
-        domain: &Domain,
-    ) -> Result<&CatalogSnapshot, LixError> {
-        self.load_catalog_for_domain(live_state, None, domain)
-            .await?;
-        let domain = domain.schema_catalog_domain();
-        match self
-            .catalogs_by_domain
-            .get(&domain)
-            .expect("catalog cache should contain requested version")
-        {
-            CatalogEntry::Catalog(catalog) => Ok(catalog),
-            CatalogEntry::SchemaFacts(_) => {
-                unreachable!("schema catalog should be materialized before validation access")
-            }
-        }
-    }
-
-    pub(crate) fn remember_schema_facts(&mut self, domain: &Domain, facts: Vec<SchemaCatalogFact>) {
-        self.catalogs_by_domain.insert(
-            domain.schema_catalog_domain(),
-            CatalogEntry::SchemaFacts(facts),
-        );
-    }
-}
-
-struct TransactionSchemaLiveStateReader<'a> {
-    base: &'a dyn LiveStateReader,
-    staged: &'a PreparedStateRowOverlay,
-}
-
-#[async_trait]
-impl LiveStateReader for TransactionSchemaLiveStateReader<'_> {
-    async fn scan_rows(
-        &self,
-        request: &LiveStateScanRequest,
-    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
-        overlay_scan_rows(self.base, self.staged, request).await
-    }
-
-    async fn load_row(
-        &self,
-        request: &LiveStateRowRequest,
-    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
-        self.base.load_row(request).await
-    }
-}