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

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

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

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

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

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

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

@@ -1,50 +0,0 @@
-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);
-    }
-}