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

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

@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use serde_json::Value as JsonValue;
 
 use crate::catalog::SchemaCatalogFact;
-use crate::domain::{committed_row_is_exact_version_scoped, Domain};
+use crate::domain::{committed_row_is_exact_branch_scoped, Domain};
 use crate::live_state::MaterializedLiveStateRow;
 use crate::live_state::{LiveStateFilter, LiveStateReader, LiveStateScanRequest};
 use crate::schema::schema_key_from_definition;
@@ -23,7 +23,7 @@ impl CatalogContext {
         Self
     }
 
-    /// Loads schema definitions for SQL surface planning at `version_id`.
+    /// Loads schema definitions for SQL surface planning at `branch_id`.
     ///
     /// SQL surfaces are a read-planning projection over the active untracked
     /// schema catalog. Validation must use `schema_facts_for_domain` instead so
@@ -31,13 +31,13 @@ impl CatalogContext {
     pub(crate) async fn schema_jsons_for_sql_read_planning<R>(
         &self,
         live_state: &R,
-        version_id: &str,
+        branch_id: &str,
     ) -> Result<Vec<JsonValue>, LixError>
     where
         R: LiveStateReader + ?Sized,
     {
         let facts = self
-            .schema_facts_for_domain(live_state, &Domain::schema_catalog(version_id, true))
+            .schema_facts_for_domain(live_state, &Domain::schema_catalog(branch_id, true))
             .await?;
         let mut schemas = BTreeMap::<String, JsonValue>::new();
         for fact in facts {
@@ -74,7 +74,7 @@ impl CatalogContext {
                 .scan_rows(&LiveStateScanRequest {
                     filter: LiveStateFilter {
                         schema_keys: vec![REGISTERED_SCHEMA_KEY.to_string()],
-                        version_ids: vec![schema_domain.version_id().to_string()],
+                        branch_ids: vec![schema_domain.branch_id().to_string()],
                         file_ids: vec![NullableKeyFilter::Null],
                         untracked: Some(schema_domain.untracked()),
                         include_tombstones: false,
@@ -101,9 +101,9 @@ fn row_belongs_to_schema_catalog_domain(row: &MaterializedLiveStateRow, domain:
     row.schema_key == REGISTERED_SCHEMA_KEY
         && row.file_id.is_none()
         && row.snapshot_content.is_some()
-        && row.version_id == domain.version_id()
+        && row.branch_id == domain.branch_id()
         && row.untracked == domain.untracked()
-        && committed_row_is_exact_version_scoped(row, domain.version_id())
+        && committed_row_is_exact_branch_scoped(row, domain.branch_id())
 }
 
 fn decode_registered_schema_row(
@@ -146,7 +146,7 @@ mod tests {
 
     use super::*;
     use crate::live_state::LiveStateRowRequest;
-    use crate::GLOBAL_VERSION_ID;
+    use crate::GLOBAL_BRANCH_ID;
 
     #[tokio::test]
     async fn visible_schemas_are_loaded_from_registered_schema_rows() {
@@ -257,11 +257,11 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn visible_schemas_ignore_projected_global_schema_rows_for_version_scope() {
+    async fn visible_schemas_ignore_projected_global_schema_rows_for_branch_scope() {
         let context = CatalogContext::new();
         let mut global_only = registered_schema_row("global_only_schema");
         global_only.global = true;
-        global_only.version_id = "main".to_string();
+        global_only.branch_id = "main".to_string();
 
         let schemas = context
             .schema_jsons_for_sql_read_planning(
@@ -338,8 +338,8 @@ mod tests {
                         || request.filter.schema_keys.contains(&row.schema_key)
                 })
                 .filter(|row| {
-                    request.filter.version_ids.is_empty()
-                        || request.filter.version_ids.contains(&row.version_id)
+                    request.filter.branch_ids.is_empty()
+                        || request.filter.branch_ids.contains(&row.branch_id)
                 })
                 .filter(|row| {
                     request
@@ -360,8 +360,8 @@ mod tests {
                 .iter()
                 .find(|row| {
                     row.schema_key == request.schema_key
-                        && row.version_id == request.version_id
-                        && row.entity_id == request.entity_id
+                        && row.branch_id == request.branch_id
+                        && row.entity_pk == request.entity_pk
                 })
                 .cloned())
         }
@@ -369,10 +369,10 @@ mod tests {
 
     fn registered_schema_row(schema_key: &str) -> MaterializedLiveStateRow {
         MaterializedLiveStateRow {
-            entity_id: registered_schema_entity_id(schema_key),
+            entity_pk: registered_schema_entity_pk(schema_key),
             file_id: None,
             schema_key: REGISTERED_SCHEMA_KEY.to_string(),
-            version_id: GLOBAL_VERSION_ID.to_string(),
+            branch_id: GLOBAL_BRANCH_ID.to_string(),
             metadata: None,
             deleted: false,
             change_id: Some("change-registered-schema".to_string()),
@@ -398,8 +398,8 @@ mod tests {
         }
     }
 
-    fn registered_schema_entity_id(schema_key: &str) -> crate::entity_identity::EntityIdentity {
-        crate::entity_identity::EntityIdentity::from_primary_key_paths(
+    fn registered_schema_entity_pk(schema_key: &str) -> crate::entity_pk::EntityPk {
+        crate::entity_pk::EntityPk::from_primary_key_paths(
             &json!({
                 "value": {
                     "x-lix-key": schema_key,

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

@@ -5,7 +5,7 @@ use serde_json::{Map as JsonMap, Value as JsonValue};
 
 use crate::common::{format_json_pointer, parse_json_pointer};
 use crate::domain::{Domain, DomainSchemaIdentity};
-use crate::entity_identity::canonical_json_text;
+use crate::entity_pk::canonical_json_text;
 use crate::functions::FunctionProviderHandle;
 use crate::schema::{compile_lix_schema, validate_schema_amendment, SchemaKey};
 use crate::LixError;
@@ -48,7 +48,7 @@ impl CatalogSnapshot {
             let key = crate::schema::schema_key_from_definition(schema)?;
             let catalog_key = SchemaCatalogKey::from_schema_key(key);
             let identity = DomainSchemaIdentity::new(
-                Domain::schema_catalog(crate::GLOBAL_VERSION_ID, true),
+                Domain::schema_catalog(crate::GLOBAL_BRANCH_ID, true),
                 catalog_key.schema_key.clone(),
             );
             catalog.remember_schema_identity(identity, catalog_key, schema.clone())?;
@@ -447,8 +447,8 @@ struct UnboundForeignKeyPlan {
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) struct StateForeignKeyPlan {
-    /// Slot [0] in `x-lix-state-foreign-keys`: local pointer to the target entity_id.
-    pub(crate) entity_id_property: Vec<String>,
+    /// Slot [0] in `x-lix-state-foreign-keys`: local pointer to the target entity_pk.
+    pub(crate) entity_pk_property: Vec<String>,
     /// Slot [1] in `x-lix-state-foreign-keys`: local pointer to the target schema_key.
     pub(crate) schema_key_property: Vec<String>,
     /// Slot [2] in `x-lix-state-foreign-keys`: local pointer to the target file_id.
@@ -458,7 +458,7 @@ pub(crate) struct StateForeignKeyPlan {
 impl StateForeignKeyPlan {
     pub(crate) fn local_properties(&self) -> PointerGroup {
         vec![
-            self.entity_id_property.clone(),
+            self.entity_pk_property.clone(),
             self.schema_key_property.clone(),
             self.file_id_property.clone(),
         ]
@@ -648,7 +648,7 @@ fn bind_foreign_key_plans(
                 return Err(LixError::new(
                     LixError::CODE_SCHEMA_DEFINITION,
                     format!(
-                        "foreign key on schema '{}' must not reference schemaKey 'lix_state'; use x-lix-state-foreign-keys with pointers ordered as [entity_id, schema_key, file_id]",
+                        "foreign key on schema '{}' must not reference schemaKey 'lix_state'; use x-lix-state-foreign-keys with pointers ordered as [entity_pk, schema_key, file_id]",
                         source_key.schema_key
                     ),
                 ));
@@ -868,12 +868,12 @@ fn state_foreign_key_plans(schema: &JsonValue) -> Result<Vec<StateForeignKeyPlan
                 return Err(LixError::new(
                     LixError::CODE_SCHEMA_DEFINITION,
                     format!(
-                        "x-lix-state-foreign-keys[{index}] must contain exactly three JSON Pointers ordered as [entity_id, schema_key, file_id]"
+                        "x-lix-state-foreign-keys[{index}] must contain exactly three JSON Pointers ordered as [entity_pk, schema_key, file_id]"
                     ),
                 ));
             }
             Ok(StateForeignKeyPlan {
-                entity_id_property: local_properties[0].clone(),
+                entity_pk_property: local_properties[0].clone(),
                 schema_key_property: local_properties[1].clone(),
                 file_id_property: local_properties[2].clone(),
             })