feat(expr): enhance expr with JQ functionality

Cargo.toml

@@ -175,6 +175,9 @@ tailcall-valid = { workspace = true }
 dashmap = "6.1.0"
 urlencoding = "2.1.3"
 tailcall-chunk = "0.3.0"
+jaq-core = "2.0.0"
+jaq-std = "2.0.0"
+jaq-json = { version = "1.0.0", features = ["serde_json"]}
 
 # to build rquickjs bindings on systems without builtin bindings
 [target.'cfg(all(target_os = "windows", target_arch = "x86"))'.dependencies]

src/core/blueprint/dynamic_value.rs

@@ -2,9 +2,10 @@
 use indexmap::IndexMap;
 use serde_json::Value;
 
-use crate::core::mustache::Mustache;
+use crate::core::Mustache;
 
 #[derive(Debug, Clone, PartialEq)]
+/// This is used to express dynamic value resolver engine.
 pub enum DynamicValue<A> {
     Value(A),
     Mustache(Mustache),
@@ -25,18 +26,14 @@
     pub fn prepend(self, name: &str) -> Self {
         match self {
             DynamicValue::Value(value) => DynamicValue::Value(value),
-            DynamicValue::Mustache(mut mustache) => {
-                if mustache.is_const() {
-                    DynamicValue::Mustache(mustache)
-                } else {
-                    let segments = mustache.segments_mut();
-                    if let Some(crate::core::mustache::Segment::Expression(vec)) =
-                        segments.get_mut(0)
-                    {
+            DynamicValue::Mustache(mut m) => {
+                for seg in m.segments_mut() {
+                    if let crate::core::mustache::Segment::Expression(vec) = seg {
                         vec.insert(0, name.to_string());
                     }
-                    DynamicValue::Mustache(mustache)
                 }
+
+                DynamicValue::Mustache(m)
             }
             DynamicValue::Object(index_map) => {
                 let index_map = index_map
@@ -60,7 +57,7 @@
         match value {
             DynamicValue::Value(v) => Ok(v.to_owned()),
             DynamicValue::Mustache(_) => Err(anyhow::anyhow!(
-                "mustache cannot be converted to const value"
+                "Mustache template cannot be converted to const value"
             )),
             DynamicValue::Object(obj) => {
                 let out: Result<IndexMap<Name, ConstValue>, anyhow::Error> = obj
@@ -82,7 +79,7 @@
     // Helper method to determine if the value is constant (non-mustache).
     pub fn is_const(&self) -> bool {
         match self {
-            DynamicValue::Mustache(m) => m.is_const(),
+            DynamicValue::Mustache(t) => t.is_const(),
             DynamicValue::Object(obj) => obj.values().all(|v| v.is_const()),
             DynamicValue::Array(arr) => arr.iter().all(|v| v.is_const()),
             _ => true,
@@ -93,6 +90,7 @@
 impl TryFrom<&Value> for DynamicValue<ConstValue> {
     type Error = anyhow::Error;
 
+    /// Used to convert json notation to dynamic value
     fn try_from(value: &Value) -> Result<Self, Self::Error> {
         match value {
             Value::Object(obj) => {
@@ -109,7 +107,8 @@
                 Ok(DynamicValue::Array(out?))
             }
             Value::String(s) => {
-                let m = Mustache::parse(s.as_str());
+                let m = Mustache::parse(s);
+
                 if m.is_const() {
                     Ok(DynamicValue::Value(ConstValue::from_json(value.clone())?))
                 } else {

src/core/http/request_template.rs

@@ -301,6 +301,7 @@
                     async_graphql::Value::String(text.to_owned()),
                 ))),
                 Segment::Expression(parts) => in_value.raw_value(parts),
+                Segment::JqTransform(_) => panic!("Cannot eval JQ for PathValue"),
             })
             .next() // Return the first value that is found
     }
@@ -344,6 +345,7 @@
                         }
                     }
                 }
+                Segment::JqTransform(_) => panic!("Cannot eval JQ for PathString"),
             }
         }
         (result, first_expression_value)

src/core/ir/error.rs

@@ -6,6 +6,7 @@
 use thiserror::Error;
 
 use crate::core::jit::graphql_error::{Error as ExtensionError, ErrorExtensions};
+use crate::core::mustache::JqRuntimeError;
 use crate::core::{auth, cache, worker, Errata};
 
 #[derive(From, Debug, Error, Clone)]
@@ -33,6 +34,8 @@
 
     Cache(cache::Error),
 
+    DynamicValue(JqRuntimeError),
+
     #[from(ignore)]
     Entity(String),
 }
@@ -67,7 +70,8 @@
             }
             Error::Worker(err) => Errata::new("Worker Error").description(err.to_string()),
             Error::Cache(err) => Errata::new("Cache Error").description(err.to_string()),
-            Error::Entity(message) => Errata::new("Entity Resolver Error").description(message)
+            Error::Entity(message) => Errata::new("Entity Resolver Error").description(message),
+            Error::DynamicValue(err) => Errata::new("Dynamic Value Rendering Error").description(err.to_string())
         }
     }
 }

src/core/ir/eval.rs

@@ -36,7 +36,7 @@ impl IR {
                         .unwrap_or(&async_graphql::Value::Null)
                         .clone())
                 }
-                IR::Dynamic(value) => Ok(value.render_value(ctx)),
+                IR::Dynamic(value) => Ok(value.render_value(ctx)?),
                 IR::Protect(auth, expr) => {
                     let verifier = AuthVerifier::from(auth.clone());
                     verifier.verify(ctx.request_ctx).await.to_result()?;

src/core/mustache/eval.rs

@@ -38,6 +38,11 @@
                     .unwrap_or(
                         Mustache::from(vec![Segment::Expression(parts.to_vec())]).to_string(),
                     ),
+                Segment::JqTransform(jqt) => {
+                    Mustache::from(vec![Segment::JqTransform(jqt.clone())])
+                        .to_string()
+                        .replace("\"", "\\\"")
+                }
             })
             .collect()
     }
@@ -57,6 +62,7 @@
                     .path_string(parts)
                     .map(|a| a.to_string())
                     .unwrap_or_default(),
+                Segment::JqTransform(_) => Default::default(),
             })
             .collect()
     }
@@ -92,6 +98,7 @@
             .filter_map(|segment| match segment {
                 Segment::Literal(text) => Some(Exit::Text(text)),
                 Segment::Expression(parts) => in_value.get_path(parts).map(Exit::Value),
+                Segment::JqTransform(_) => panic!("Cannot eval JQ for Path"),
             })
             .collect::<Vec<_>>()
     }
@@ -116,6 +123,7 @@
             .map(|segment| match segment {
                 Segment::Literal(text) => text.to_string(),
                 Segment::Expression(parts) => in_value.path_graphql(parts).unwrap_or_default(),
+                Segment::JqTransform(_) => panic!("Cannot eval JQ for PathGraphql"),
             })
             .collect()
     }