feat: more

Author: kevinmichaelchen

libs/core/__tests__/cel.test.ts

@@ -8,7 +8,7 @@ describe("evaluate", () => {
       {},
     );
     // The expected result is '2023-01-01T01:00:00Z' as an ISO string
-    expect(result).toBe("2023-01-01T01:00:00Z");
+    expect(result).toBe("2023-01-01T01:00:00+00:00");
   });
   it("should evaluate a simple expression", async () => {
     const result = await evaluate("size(message) > 5", {

libs/core/src/lib.rs

@@ -1,7 +1,7 @@
 #![deny(clippy::all)]
 
+use cel_interpreter::{Context, Program, Value};
 use napi_derive::napi;
-use cel_interpreter::{Program, Context, Value};
 use serde_json::Value as JsonValue;
 use std::sync::Arc;
 
@@ -19,8 +19,8 @@ impl CelProgram {
 
     #[napi]
     pub fn compile(source: String) -> napi::Result<CelProgram> {
-        let program = Program::compile(&source)
-            .map_err(|e| napi::Error::from_reason(e.to_string()))?;
+        let program =
+            Program::compile(&source).map_err(|e| napi::Error::from_reason(e.to_string()))?;
         Ok(CelProgram { program })
     }
 
@@ -38,12 +38,12 @@ impl CelProgram {
                 } else {
                     Value::Null
                 }
-            },
+            }
             JsonValue::String(s) => Value::String(Arc::new(s.clone())),
             JsonValue::Array(arr) => {
                 let values: Vec<Value> = arr.iter().map(|v| Self::json_to_cel_value(v)).collect();
                 Value::List(Arc::new(values))
-            },
+            }
             JsonValue::Object(map) => {
                 let mut cel_map = std::collections::HashMap::new();
                 for (key, value) in map {
@@ -65,27 +65,37 @@ impl CelProgram {
                 .unwrap_or(JsonValue::Null),
             Value::String(s) => JsonValue::String((*s).to_string()),
             Value::List(list) => JsonValue::Array(
-                list.iter().map(|v| Self::cel_to_json_value(v.clone())).collect()
+                list.iter()
+                    .map(|v| Self::cel_to_json_value(v.clone()))
+                    .collect(),
             ),
             Value::Map(map) => JsonValue::Object(
-                map.map.iter().map(|(k, v)| (k.to_string(), Self::cel_to_json_value(v.clone()))).collect()
+                map.map
+                    .iter()
+                    .map(|(k, v)| (k.to_string(), Self::cel_to_json_value(v.clone())))
+                    .collect(),
             ),
+            Value::Timestamp(ts) => JsonValue::String(ts.to_rfc3339()),
+            Value::Duration(dur) => {
+                JsonValue::Number(serde_json::Number::from(dur.num_nanoseconds().unwrap_or(0)))
+            }
             _ => JsonValue::Null,
         }
     }
 
     #[napi]
     pub fn execute(&self, context: JsonValue) -> napi::Result<JsonValue> {
         let mut ctx = Context::default();
-        
+
         if let JsonValue::Object(map) = context {
             for (key, value) in map {
                 let cel_value = Self::json_to_cel_value(&value);
                 ctx.add_variable_from_value(key, cel_value);
             }
         }
 
-        self.program.execute(&ctx)
+        self.program
+            .execute(&ctx)
             .map_err(|e| napi::Error::from_reason(e.to_string()))
             .map(Self::cel_to_json_value)
     }