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

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

@@ -0,0 +1,86 @@
+use cel::Context;
+use serde_json::{Map as JsonMap, Value as JsonValue};
+
+use crate::LixError;
+
+use super::provider::CelFunctionProvider;
+use super::value::json_to_cel;
+
+pub(crate) fn build_context_with_functions<P>(
+    variables: &JsonMap<String, JsonValue>,
+    functions: P,
+) -> Result<Context<'static>, LixError>
+where
+    P: CelFunctionProvider,
+{
+    let mut context = Context::default();
+
+    let uuid_functions = functions.clone();
+    context.add_function("lix_uuid_v7", move || uuid_functions.call_uuid_v7());
+    let timestamp_functions = functions.clone();
+    context.add_function("lix_timestamp", move || {
+        timestamp_functions.call_timestamp()
+    });
+
+    for (name, value) in variables {
+        let cel_value = json_to_cel(value)?;
+        context.add_variable_from_value(name.clone(), cel_value);
+    }
+
+    Ok(context)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::build_context_with_functions;
+    use crate::cel::CelFunctionProvider;
+    use cel::Program;
+    use serde_json::Map as JsonMap;
+
+    #[test]
+    fn registers_lix_uuid_v7_function() {
+        let context = build_context_with_functions(&JsonMap::new(), fixed_functions())
+            .expect("build context");
+        let program = Program::compile("lix_uuid_v7()").expect("compile CEL");
+        let value = program.execute(&context).expect("execute CEL");
+        let as_json = value.json().expect("to json");
+        assert!(as_json.as_str().is_some());
+    }
+
+    #[test]
+    fn errors_on_unknown_variables() {
+        let context = build_context_with_functions(&JsonMap::new(), fixed_functions())
+            .expect("build context");
+        let program = Program::compile("missing_var == null").expect("compile CEL");
+        let err = program
+            .execute(&context)
+            .expect_err("execute CEL should fail");
+        assert!(err.to_string().contains("Undeclared reference"));
+    }
+
+    #[derive(Clone)]
+    struct FixedFunctions;
+
+    impl CelFunctionProvider for FixedFunctions {
+        fn call_uuid_v7(&self) -> String {
+            "uuid-fixed".to_string()
+        }
+
+        fn call_timestamp(&self) -> String {
+            "1970-01-01T00:00:00.000Z".to_string()
+        }
+    }
+
+    fn fixed_functions() -> FixedFunctions {
+        FixedFunctions
+    }
+
+    #[test]
+    fn uses_supplied_function_provider() {
+        let context = build_context_with_functions(&JsonMap::new(), fixed_functions())
+            .expect("build context");
+        let program = Program::compile("lix_uuid_v7()").expect("compile CEL");
+        let value = program.execute(&context).expect("execute CEL");
+        assert_eq!(value.json().expect("to json").as_str(), Some("uuid-fixed"));
+    }
+}

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

@@ -0,0 +1,19 @@
+use crate::LixError;
+
+pub(crate) fn cel_parse_error(expression: &str, error: impl std::fmt::Display) -> LixError {
+    LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: format!("failed to parse CEL expression '{expression}': {error}"),
+        hint: None,
+        details: None,
+    }
+}
+
+pub(crate) fn cel_runtime_error(expression: &str, error: impl std::fmt::Display) -> LixError {
+    LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: format!("failed to evaluate CEL expression '{expression}': {error}"),
+        hint: None,
+        details: None,
+    }
+}

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

@@ -0,0 +1,8 @@
+mod context;
+mod error;
+mod provider;
+mod runtime;
+mod value;
+
+pub(crate) use provider::CelFunctionProvider;
+pub(crate) use runtime::shared_runtime;

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

@@ -0,0 +1,9 @@
+/// Function source available to CEL expressions.
+///
+/// CEL is shared infrastructure for schema expressions. It should not depend
+/// on engine1 or engine runtime traits directly; callers adapt their own
+/// execution-scoped function provider to this small boundary.
+pub(crate) trait CelFunctionProvider: Clone + Send + Sync + 'static {
+    fn call_uuid_v7(&self) -> String;
+    fn call_timestamp(&self) -> String;
+}

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

@@ -0,0 +1,167 @@
+use std::collections::HashMap;
+use std::sync::{Arc, OnceLock, RwLock};
+
+use cel::Program;
+use serde_json::{Map as JsonMap, Value as JsonValue};
+
+use crate::LixError;
+
+use super::context::build_context_with_functions;
+use super::error::{cel_parse_error, cel_runtime_error};
+use super::provider::CelFunctionProvider;
+use super::value::cel_to_json;
+
+#[derive(Debug)]
+struct CompiledProgram {
+    program: Program,
+}
+
+#[derive(Default)]
+pub struct CelEvaluator {
+    programs: RwLock<HashMap<String, Arc<CompiledProgram>>>,
+}
+
+impl CelEvaluator {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn evaluate_with_functions<P>(
+        &self,
+        expression: &str,
+        variables: &JsonMap<String, JsonValue>,
+        functions: P,
+    ) -> Result<JsonValue, LixError>
+    where
+        P: CelFunctionProvider,
+    {
+        let compiled = self.compile(expression)?;
+        let context = build_context_with_functions(variables, functions)?;
+        let value = compiled
+            .program
+            .execute(&context)
+            .map_err(|error| cel_runtime_error(expression, error))?;
+        cel_to_json(&value)
+    }
+
+    fn compile(&self, expression: &str) -> Result<Arc<CompiledProgram>, LixError> {
+        if let Some(existing) = self.programs.read().unwrap().get(expression).cloned() {
+            return Ok(existing);
+        }
+
+        let program =
+            Program::compile(expression).map_err(|error| cel_parse_error(expression, error))?;
+        let compiled = Arc::new(CompiledProgram { program });
+
+        self.programs
+            .write()
+            .unwrap()
+            .insert(expression.to_string(), compiled.clone());
+
+        Ok(compiled)
+    }
+}
+
+pub(crate) fn shared_runtime() -> &'static CelEvaluator {
+    static SHARED_RUNTIME: OnceLock<CelEvaluator> = OnceLock::new();
+    SHARED_RUNTIME.get_or_init(CelEvaluator::new)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CelEvaluator;
+    use crate::cel::CelFunctionProvider;
+    use serde_json::{json, Map as JsonMap, Value as JsonValue};
+
+    #[derive(Clone)]
+    struct FixedFunctions;
+
+    impl CelFunctionProvider for FixedFunctions {
+        fn call_uuid_v7(&self) -> String {
+            "uuid-fixed".to_string()
+        }
+
+        fn call_timestamp(&self) -> String {
+            "1970-01-01T00:00:00.000Z".to_string()
+        }
+    }
+
+    fn fixed_functions() -> FixedFunctions {
+        FixedFunctions
+    }
+
+    #[test]
+    fn evaluates_basic_expressions() {
+        let evaluator = CelEvaluator::new();
+        let value = evaluator
+            .evaluate_with_functions("'open'", &JsonMap::new(), fixed_functions())
+            .expect("evaluate CEL");
+        assert_eq!(value, JsonValue::String("open".to_string()));
+    }
+
+    #[test]
+    fn evaluates_with_variables() {
+        let evaluator = CelEvaluator::new();
+        let mut context = JsonMap::new();
+        context.insert("name".to_string(), JsonValue::String("sample".to_string()));
+        let value = evaluator
+            .evaluate_with_functions("name + '-slug'", &context, fixed_functions())
+            .expect("evaluate CEL");
+        assert_eq!(value, JsonValue::String("sample-slug".to_string()));
+    }
+
+    #[test]
+    fn reports_parse_errors() {
+        let evaluator = CelEvaluator::new();
+        let err = evaluator
+            .evaluate_with_functions("lix_uuid_v7(", &JsonMap::new(), fixed_functions())
+            .expect_err("expected parse error");
+        assert!(err.to_string().contains("failed to parse CEL expression"));
+    }
+
+    #[test]
+    fn reports_runtime_errors() {
+        let evaluator = CelEvaluator::new();
+        let err = evaluator
+            .evaluate_with_functions("1 / 0", &JsonMap::new(), fixed_functions())
+            .expect_err("expected runtime error");
+        assert!(err
+            .to_string()
+            .contains("failed to evaluate CEL expression"));
+    }
+
+    #[test]
+    fn supports_function_calls() {
+        let evaluator = CelEvaluator::new();
+        let value = evaluator
+            .evaluate_with_functions("lix_timestamp()", &JsonMap::new(), fixed_functions())
+            .expect("evaluate CEL");
+        assert_eq!(value.as_str(), Some("1970-01-01T00:00:00.000Z"));
+    }
+
+    #[test]
+    fn caches_compiled_programs() {
+        let evaluator = CelEvaluator::new();
+        let mut context = JsonMap::new();
+        context.insert("name".to_string(), json!("x"));
+
+        let _ = evaluator
+            .evaluate_with_functions("name + '-slug'", &context, fixed_functions())
+            .expect("first evaluation");
+        let _ = evaluator
+            .evaluate_with_functions("name + '-slug'", &context, fixed_functions())
+            .expect("second evaluation");
+
+        let size = evaluator.programs.read().unwrap().len();
+        assert_eq!(size, 1);
+    }
+
+    #[test]
+    fn errors_on_unknown_variable() {
+        let evaluator = CelEvaluator::new();
+        let err = evaluator
+            .evaluate_with_functions("missing_var + '-slug'", &JsonMap::new(), fixed_functions())
+            .expect_err("expected unknown variable error");
+        assert!(err.to_string().contains("Undeclared reference"));
+    }
+}

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

@@ -0,0 +1,50 @@
+use cel::Value as CelValue;
+use serde_json::Value as JsonValue;
+
+use crate::LixError;
+
+pub fn json_to_cel(value: &JsonValue) -> Result<CelValue, LixError> {
+    cel::to_value(value).map_err(|err| LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: format!("failed to convert JSON value to CEL value: {err}"),
+        hint: None,
+        details: None,
+    })
+}
+
+pub fn cel_to_json(value: &CelValue) -> Result<JsonValue, LixError> {
+    value.json().map_err(|err| LixError {
+        code: "LIX_ERROR_UNKNOWN".to_string(),
+        message: format!("failed to convert CEL value to JSON value: {err}"),
+        hint: None,
+        details: None,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{cel_to_json, json_to_cel};
+    use serde_json::json;
+
+    #[test]
+    fn converts_json_scalars() {
+        let value = json!("hello");
+        let cel = json_to_cel(&value).expect("convert to CEL");
+        let roundtrip = cel_to_json(&cel).expect("convert to JSON");
+        assert_eq!(roundtrip, value);
+    }
+
+    #[test]
+    fn converts_json_objects_and_arrays() {
+        let value = json!({
+            "name": "Ada",
+            "flags": [true, false],
+            "meta": {
+                "count": 1
+            }
+        });
+        let cel = json_to_cel(&value).expect("convert to CEL");
+        let roundtrip = cel_to_json(&cel).expect("convert to JSON");
+        assert_eq!(roundtrip, value);
+    }
+}