feat(expr): enhance expr with JQ functionality

Cargo.toml

@@ -176,6 +176,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]

benches/data_loader_bench.rs

@@ -33,6 +33,10 @@ impl EnvIO for Env {
     fn get(&self, _: &str) -> Option<Cow<'_, str>> {
         unimplemented!("Not needed for this bench")
     }
+
+    fn get_raw(&self) -> Vec<(String, String)> {
+        unimplemented!("Not needed for this bench")
+    }
 }
 
 struct File;

benches/impl_path_string_for_evaluation_context.rs

@@ -84,6 +84,10 @@ impl EnvIO for Env {
     fn get(&self, _: &str) -> Option<Cow<'_, str>> {
         unimplemented!("Not needed for this bench")
     }
+
+    fn get_raw(&self) -> Vec<(String, String)> {
+        unimplemented!("Not needed for this bench")
+    }
 }
 
 struct File;

src/cli/runtime/env.rs

@@ -12,6 +12,13 @@ impl EnvIO for EnvNative {
     fn get(&self, key: &str) -> Option<Cow<'_, str>> {
         self.vars.get(key).map(Cow::from)
     }
+
+    fn get_raw(&self) -> Vec<(String, String)> {
+        self.vars
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect()
+    }
 }
 
 impl EnvNative {

src/core/blueprint/dynamic_value.rs

@@ -2,12 +2,13 @@ use async_graphql_value::{ConstValue, Name};
 use indexmap::IndexMap;
 use serde_json::Value;
 
-use crate::core::mustache::Mustache;
+use crate::core::mustache::JqTemplate;
 
 #[derive(Debug, Clone, PartialEq)]
+/// This is used to express dynamic value resolver engine.
 pub enum DynamicValue<A> {
     Value(A),
-    Mustache(Mustache),
+    JqTemplate(JqTemplate),
     Object(IndexMap<Name, DynamicValue<A>>),
     Array(Vec<DynamicValue<A>>),
 }
@@ -25,19 +26,25 @@ impl<A> DynamicValue<A> {
     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)
-                    {
-                        vec.insert(0, name.to_string());
-                    }
-                    DynamicValue::Mustache(mustache)
-                }
-            }
+            DynamicValue::JqTemplate(jqt) => DynamicValue::JqTemplate(JqTemplate(
+                jqt.0
+                    .into_iter()
+                    .map(|mut f| match &mut f {
+                        crate::core::mustache::JqTemplateIR::JqTransform(_) => f,
+                        crate::core::mustache::JqTemplateIR::Literal(_) => f,
+                        // this function can prepend a custom prefix to mustache only
+                        crate::core::mustache::JqTemplateIR::Mustache(mustache) => {
+                            let segments = mustache.segments_mut();
+                            if let Some(crate::core::mustache::Segment::Expression(vec)) =
+                                segments.get_mut(0)
+                            {
+                                vec.insert(0, name.to_string());
+                            }
+                            f
+                        }
+                    })
+                    .collect(),
+            )),
             DynamicValue::Object(index_map) => {
                 let index_map = index_map
                     .into_iter()
@@ -59,8 +66,8 @@ impl TryFrom<&DynamicValue<ConstValue>> for ConstValue {
     fn try_from(value: &DynamicValue<ConstValue>) -> Result<Self, Self::Error> {
         match value {
             DynamicValue::Value(v) => Ok(v.to_owned()),
-            DynamicValue::Mustache(_) => Err(anyhow::anyhow!(
-                "mustache cannot be converted to const value"
+            DynamicValue::JqTemplate(_) => Err(anyhow::anyhow!(
+                "jq template cannot be converted to const value"
             )),
             DynamicValue::Object(obj) => {
                 let out: Result<IndexMap<Name, ConstValue>, anyhow::Error> = obj
@@ -82,7 +89,7 @@ impl<A> DynamicValue<A> {
     // 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::JqTemplate(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 +100,7 @@ impl<A> DynamicValue<A> {
 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,11 +117,12 @@ impl TryFrom<&Value> for DynamicValue<ConstValue> {
                 Ok(DynamicValue::Array(out?))
             }
             Value::String(s) => {
-                let m = Mustache::parse(s.as_str());
-                if m.is_const() {
+                let jqt = JqTemplate::parse(s);
+
+                if jqt.is_const() {
                     Ok(DynamicValue::Value(ConstValue::from_json(value.clone())?))
                 } else {
-                    Ok(DynamicValue::Mustache(m))
+                    Ok(DynamicValue::JqTemplate(jqt))
                 }
             }
             _ => Ok(DynamicValue::Value(ConstValue::from_json(value.clone())?)),
@@ -128,31 +137,33 @@ mod test {
     #[test]
     fn test_dynamic_value_inject() {
         let value: DynamicValue<ConstValue> =
-            DynamicValue::Mustache(Mustache::parse("{{.foo}}")).prepend("args");
+            DynamicValue::JqTemplate(JqTemplate::parse("{{.foo}}")).prepend("args");
         let expected: DynamicValue<ConstValue> =
-            DynamicValue::Mustache(Mustache::parse("{{.args.foo}}"));
+            DynamicValue::JqTemplate(JqTemplate::parse("{{.args.foo}}"));
         assert_eq!(value, expected);
 
         let mut value_map = IndexMap::new();
         value_map.insert(
             Name::new("foo"),
-            DynamicValue::Mustache(Mustache::parse("{{.foo}}")),
+            DynamicValue::JqTemplate(JqTemplate::parse("{{.foo}}")),
         );
         let value: DynamicValue<ConstValue> = DynamicValue::Object(value_map).prepend("args");
         let mut expected_map = IndexMap::new();
         expected_map.insert(
             Name::new("foo"),
-            DynamicValue::Mustache(Mustache::parse("{{.args.foo}}")),
+            DynamicValue::JqTemplate(JqTemplate::parse("{{.args.foo}}")),
         );
         let expected: DynamicValue<ConstValue> = DynamicValue::Object(expected_map);
         assert_eq!(value, expected);
 
-        let value: DynamicValue<ConstValue> =
-            DynamicValue::Array(vec![DynamicValue::Mustache(Mustache::parse("{{.foo}}"))])
-                .prepend("args");
-        let expected: DynamicValue<ConstValue> = DynamicValue::Array(vec![DynamicValue::Mustache(
-            Mustache::parse("{{.args.foo}}"),
-        )]);
+        let value: DynamicValue<ConstValue> = DynamicValue::Array(vec![DynamicValue::JqTemplate(
+            JqTemplate::parse("{{.foo}}"),
+        )])
+        .prepend("args");
+        let expected: DynamicValue<ConstValue> =
+            DynamicValue::Array(vec![DynamicValue::JqTemplate(JqTemplate::parse(
+                "{{.args.foo}}",
+            ))]);
         assert_eq!(value, expected);
 
         let value: DynamicValue<ConstValue> = DynamicValue::Value(ConstValue::Null).prepend("args");

src/core/ir/error.rs

@@ -6,6 +6,7 @@ use derive_more::From;
 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 @@ pub enum Error {
 
     Cache(cache::Error),
 
+    DynamicValue(JqRuntimeError),
+
     #[from(ignore)]
     Entity(String),
 }
@@ -67,7 +70,8 @@ impl From<Error> for Errata {
             }
             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()?;