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

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

@@ -0,0 +1,206 @@
+use serde_json::Value as JsonValue;
+
+use crate::entity_identity::EntityIdentity;
+use crate::LixError;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SchemaKey {
+    pub schema_key: String,
+    pub schema_version: String,
+}
+
+impl SchemaKey {
+    pub fn new(schema_key: impl Into<String>, schema_version: impl Into<String>) -> Self {
+        Self {
+            schema_key: schema_key.into(),
+            schema_version: schema_version.into(),
+        }
+    }
+
+    pub fn version_number(&self) -> Option<u64> {
+        self.schema_version.parse::<u64>().ok()
+    }
+}
+
+pub fn schema_key_from_definition(schema: &JsonValue) -> Result<SchemaKey, LixError> {
+    let object = schema.as_object().ok_or_else(|| LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: "schema definition must be a JSON object".to_string(),
+        hint: None,
+        details: None,
+    })?;
+    let schema_key = object
+        .get("x-lix-key")
+        .and_then(JsonValue::as_str)
+        .ok_or_else(|| LixError {
+            code: "LIX_ERROR_UNKNOWN".to_string(),
+            message: "schema definition must include string x-lix-key".to_string(),
+            hint: None,
+            details: None,
+        })?;
+    let schema_version = object
+        .get("x-lix-version")
+        .and_then(JsonValue::as_str)
+        .ok_or_else(|| LixError {
+            code: "LIX_ERROR_UNKNOWN".to_string(),
+            message: "schema definition must include string x-lix-version".to_string(),
+            hint: None,
+            details: None,
+        })?;
+
+    Ok(SchemaKey::new(
+        schema_key.to_string(),
+        schema_version.to_string(),
+    ))
+}
+
+pub fn schema_from_registered_snapshot(
+    snapshot: &JsonValue,
+) -> Result<(SchemaKey, JsonValue), LixError> {
+    let value = snapshot.get("value").ok_or_else(|| LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: "registered schema snapshot_content missing value".to_string(),
+        hint: None,
+        details: None,
+    })?;
+    let value = value.as_object().ok_or_else(|| LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: "registered schema snapshot_content value must be an object".to_string(),
+        hint: None,
+        details: None,
+    })?;
+
+    let schema_key = value
+        .get("x-lix-key")
+        .and_then(|value| value.as_str())
+        .ok_or_else(|| LixError {
+            code: "LIX_ERROR_UNKNOWN".to_string(),
+            message: "registered schema value.x-lix-key must be string".to_string(),
+            hint: None,
+            details: None,
+        })?;
+    let schema_version = value
+        .get("x-lix-version")
+        .and_then(|value| value.as_str())
+        .ok_or_else(|| LixError {
+            code: "LIX_ERROR_UNKNOWN".to_string(),
+            message: "registered schema value.x-lix-version must be string".to_string(),
+            hint: None,
+            details: None,
+        })?;
+
+    Ok((
+        SchemaKey::new(schema_key.to_string(), schema_version.to_string()),
+        JsonValue::Object(value.clone()),
+    ))
+}
+
+pub(crate) fn reject_unsupported_registered_schema_version(
+    key: &SchemaKey,
+) -> Result<(), LixError> {
+    if key.schema_version != "1" {
+        return Err(LixError::new(
+            LixError::CODE_SCHEMA_DEFINITION,
+            format!(
+                "schema '{}' uses x-lix-version '{}', but schema evolution is not supported yet; register schemas with x-lix-version '1'",
+                key.schema_key, key.schema_version
+            ),
+        ));
+    }
+    Ok(())
+}
+
+pub(crate) fn registered_schema_entity_id(
+    schema_key: &str,
+    schema_version: &str,
+) -> Result<EntityIdentity, LixError> {
+    EntityIdentity::from_primary_key_paths(
+        &serde_json::json!({
+            "value": {
+                "x-lix-key": schema_key,
+                "x-lix-version": schema_version,
+            }
+        }),
+        &[
+            vec!["value".to_string(), "x-lix-key".to_string()],
+            vec!["value".to_string(), "x-lix-version".to_string()],
+        ],
+    )
+    .map_err(|error| {
+        LixError::new(
+            LixError::CODE_SCHEMA_DEFINITION,
+            format!(
+                "registered schema identity could not be derived for schema '{schema_key}' version '{schema_version}': {error}"
+            ),
+        )
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::{schema_from_registered_snapshot, schema_key_from_definition, SchemaKey};
+
+    #[test]
+    fn schema_key_entity_id_and_numeric_version() {
+        let key = SchemaKey::new("users", "42");
+
+        assert_eq!(key.version_number(), Some(42));
+    }
+
+    #[test]
+    fn schema_key_non_numeric_version_returns_none() {
+        let key = SchemaKey::new("users", "v2");
+
+        assert_eq!(key.version_number(), None);
+    }
+
+    #[test]
+    fn schema_from_registered_snapshot_extracts_key_and_schema() {
+        let snapshot = json!({
+            "value": {
+                "x-lix-key": "profile",
+                "x-lix-version": "1",
+                "type": "object"
+            }
+        });
+
+        let (key, schema) = schema_from_registered_snapshot(&snapshot).expect("schema is valid");
+        assert_eq!(key, SchemaKey::new("profile", "1"));
+        assert_eq!(schema["type"], json!("object"));
+    }
+
+    #[test]
+    fn schema_from_registered_snapshot_requires_value_object() {
+        let snapshot = json!({});
+
+        let err = schema_from_registered_snapshot(&snapshot).expect_err("should fail");
+        assert!(err.message.contains("missing value"), "{err:?}");
+    }
+
+    #[test]
+    fn schema_from_registered_snapshot_requires_string_key() {
+        let snapshot = json!({
+            "value": {
+                "x-lix-key": 1,
+                "x-lix-version": "1"
+            }
+        });
+
+        let err = schema_from_registered_snapshot(&snapshot).expect_err("should fail");
+        assert!(err.message.contains("x-lix-key"), "{err:?}");
+    }
+
+    #[test]
+    fn schema_key_from_definition_extracts_key_and_version() {
+        let schema = json!({
+            "x-lix-key": "users",
+            "x-lix-version": "2",
+            "type": "object"
+        });
+
+        let key = schema_key_from_definition(&schema).expect("schema key");
+        assert_eq!(key, SchemaKey::new("users", "2"));
+    }
+}

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

@@ -0,0 +1,20 @@
+mod annotations;
+mod builtin;
+mod definition;
+mod key;
+pub(crate) mod seed;
+#[cfg(test)]
+mod tests;
+
+pub(crate) use annotations::defaults::apply_schema_defaults_with_shared_runtime;
+pub(crate) use builtin::lix_state_surface_schema_definition;
+pub(crate) use definition::{compile_lix_schema, format_lix_schema_validation_errors};
+pub use definition::{
+    lix_schema_definition, lix_schema_definition_json, validate_lix_schema,
+    validate_lix_schema_definition,
+};
+pub(crate) use key::{registered_schema_entity_id, reject_unsupported_registered_schema_version};
+pub use key::{schema_from_registered_snapshot, schema_key_from_definition, SchemaKey};
+#[cfg(test)]
+pub(crate) use seed::seed_schema_definition;
+pub(crate) use seed::{is_seed_schema_key, seed_schema_definitions};

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

@@ -0,0 +1,14 @@
+use serde_json::Value as JsonValue;
+
+pub(crate) fn is_seed_schema_key(schema_key: &str) -> bool {
+    super::builtin::is_seed_schema_key(schema_key)
+}
+
+#[cfg(test)]
+pub(crate) fn seed_schema_definition(schema_key: &str) -> Option<&'static JsonValue> {
+    super::builtin::seed_schema_definition(schema_key)
+}
+
+pub(crate) fn seed_schema_definitions() -> Vec<&'static JsonValue> {
+    super::builtin::seed_schema_definitions()
+}