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

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

@@ -0,0 +1,37 @@
+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

@@ -2,45 +2,77 @@ use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use serde_json::Value as JsonValue;
 
-use crate::live_state::{LiveStateReader, LiveStateRow, LiveStateRowRequest, LiveStateScanRequest};
-use crate::schema_registry::SchemaRegistry;
-use crate::transaction::live_state_overlay::overlay_scan_rows;
-use crate::transaction::normalization::{
-    remember_pending_registered_schema, TransactionSchemaCatalog, REGISTERED_SCHEMA_KEY,
+use crate::catalog::{CatalogContext, CatalogSnapshot, SchemaCatalogFact};
+use crate::domain::Domain;
+use crate::live_state::{
+    LiveStateReader, LiveStateRowRequest, LiveStateScanRequest, MaterializedLiveStateRow,
 };
-use crate::transaction::staging::{StagedStateRowOverlay, StagedWriteSet};
+use crate::transaction::live_state_overlay::overlay_scan_rows;
+use crate::transaction::staging::PreparedStateRowOverlay;
 use crate::LixError;
 
 pub(crate) struct TransactionSchemaResolver {
-    registry: Arc<SchemaRegistry>,
-    catalogs_by_version: BTreeMap<String, TransactionSchemaCatalog>,
+    context: Arc<CatalogContext>,
+    catalogs_by_domain: BTreeMap<Domain, CatalogEntry>,
+}
+
+enum CatalogEntry {
+    SchemaFacts(Vec<SchemaCatalogFact>),
+    Catalog(CatalogSnapshot),
 }
 
 impl TransactionSchemaResolver {
-    pub(crate) fn new(registry: Arc<SchemaRegistry>) -> Self {
+    pub(crate) fn new(context: Arc<CatalogContext>) -> Self {
         Self {
-            registry,
-            catalogs_by_version: BTreeMap::new(),
+            context,
+            catalogs_by_domain: BTreeMap::new(),
         }
     }
 
-    async fn load_catalog_for_version(
+    async fn load_catalog_for_domain(
         &mut self,
         live_state: &dyn LiveStateReader,
-        staged: StagedStateRowOverlay,
-        version_id: &str,
+        staged: Option<&PreparedStateRowOverlay>,
+        domain: &Domain,
     ) -> Result<(), LixError> {
-        if !self.catalogs_by_version.contains_key(version_id) {
-            let reader = TransactionSchemaLiveStateReader {
-                base: live_state,
-                staged,
+        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?
             };
-            let schemas = self.registry.visible_schemas(&reader, version_id).await?;
-            let catalog = TransactionSchemaCatalog::from_visible_schemas(&schemas)?;
-            self.catalogs_by_version
-                .insert(version_id.to_string(), catalog);
+            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(())
     }
@@ -48,65 +80,55 @@ impl TransactionSchemaResolver {
     pub(crate) async fn catalog_for_row_normalization(
         &mut self,
         live_state: &dyn LiveStateReader,
-        staged: StagedStateRowOverlay,
-        version_id: &str,
-    ) -> Result<&mut TransactionSchemaCatalog, LixError> {
-        self.load_catalog_for_version(live_state, staged, version_id)
+        staged: &PreparedStateRowOverlay,
+        domain: &Domain,
+    ) -> Result<&mut CatalogSnapshot, LixError> {
+        self.load_catalog_for_domain(live_state, Some(staged), domain)
             .await?;
-        Ok(self
-            .catalogs_by_version
-            .get_mut(version_id)
-            .expect("catalog cache should contain requested version"))
+        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,
-        staged_writes: &StagedWriteSet,
-        version_id: &str,
-    ) -> Result<TransactionSchemaCatalog, LixError> {
-        let schemas = self
-            .registry
-            .visible_schemas(live_state, version_id)
+        domain: &Domain,
+    ) -> Result<&CatalogSnapshot, LixError> {
+        self.load_catalog_for_domain(live_state, None, domain)
             .await?;
-        let mut catalog = TransactionSchemaCatalog::from_visible_schemas(&schemas)?;
-        absorb_registered_schema_writes(&mut catalog, staged_writes, version_id)?;
-        Ok(catalog)
-    }
-
-    pub(crate) fn remember_visible_schemas(
-        &mut self,
-        version_id: impl Into<String>,
-        schemas: Vec<JsonValue>,
-    ) -> Result<(), LixError> {
-        let version_id = version_id.into();
-        let catalog = TransactionSchemaCatalog::from_visible_schemas(&schemas)?;
-        self.catalogs_by_version.insert(version_id, catalog);
-        Ok(())
-    }
-}
-
-fn absorb_registered_schema_writes(
-    schema_catalog: &mut TransactionSchemaCatalog,
-    staged_writes: &StagedWriteSet,
-    version_id: &str,
-) -> Result<(), LixError> {
-    for row in &staged_writes.state_rows {
-        if row.schema_scope_version_id() == version_id && row.schema_key == REGISTERED_SCHEMA_KEY {
-            remember_pending_registered_schema(row.snapshot_content.as_deref(), schema_catalog)?;
+        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")
+            }
         }
     }
-    for row in &staged_writes.adopted_rows {
-        if row.schema_scope_version_id() == version_id && row.schema_key == REGISTERED_SCHEMA_KEY {
-            remember_pending_registered_schema(row.snapshot_content.as_deref(), schema_catalog)?;
-        }
+
+    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),
+        );
     }
-    Ok(())
 }
 
 struct TransactionSchemaLiveStateReader<'a> {
     base: &'a dyn LiveStateReader,
-    staged: StagedStateRowOverlay,
+    staged: &'a PreparedStateRowOverlay,
 }
 
 #[async_trait]
@@ -114,14 +136,14 @@ impl LiveStateReader for TransactionSchemaLiveStateReader<'_> {
     async fn scan_rows(
         &self,
         request: &LiveStateScanRequest,
-    ) -> Result<Vec<LiveStateRow>, LixError> {
-        overlay_scan_rows(self.base, &self.staged, request).await
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
+        overlay_scan_rows(self.base, self.staged, request).await
     }
 
     async fn load_row(
         &self,
         request: &LiveStateRowRequest,
-    ) -> Result<Option<LiveStateRow>, LixError> {
+    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
         self.base.load_row(request).await
     }
 }