perf: optimize the body batching flow

generated/.tailcallrc.graphql

@@ -167,10 +167,10 @@ directive @http(
   batchKey: [String!]
   """
   The body of the API call. It's used for methods like POST or PUT that send data to 
-  the server. You can pass it as a static object or use a Mustache template to substitute 
-  variables from the GraphQL variables.
+  the server. You can pass it as a static object or use a Mustache template with object 
+  to substitute variables from the GraphQL variables.
   """
-  body: String
+  body: JSON
   """
   Enables deduplication of IO operations to enhance performance.This flag prevents 
   duplicate IO requests from being executed concurrently, reducing resource load. Caution: 
@@ -900,10 +900,10 @@ input Http {
   batchKey: [String!]
   """
   The body of the API call. It's used for methods like POST or PUT that send data to 
-  the server. You can pass it as a static object or use a Mustache template to substitute 
-  variables from the GraphQL variables.
+  the server. You can pass it as a static object or use a Mustache template with object 
+  to substitute variables from the GraphQL variables.
   """
-  body: String
+  body: JSON
   """
   Enables deduplication of IO operations to enhance performance.This flag prevents 
   duplicate IO requests from being executed concurrently, reducing resource load. Caution: 

generated/.tailcallrc.schema.json

@@ -654,11 +654,7 @@
           }
         },
         "body": {
-          "description": "The body of the API call. It's used for methods like POST or PUT that send data to the server. You can pass it as a static object or use a Mustache template to substitute variables from the GraphQL variables.",
-          "type": [
-            "string",
-            "null"
-          ]
+          "description": "The body of the API call. It's used for methods like POST or PUT that send data to the server. You can pass it as a static object or use a Mustache template with object to substitute variables from the GraphQL variables."
         },
         "dedupe": {
           "description": "Enables deduplication of IO operations to enhance performance.\n\nThis flag prevents duplicate IO requests from being executed concurrently, reducing resource load. Caution: May lead to issues with APIs that expect unique results for identical inputs, such as nonce-based APIs.",

src/core/blueprint/dynamic_value.rs

@@ -2,6 +2,7 @@ use async_graphql_value::{ConstValue, Name};
 use indexmap::IndexMap;
 use serde_json::Value;
 
+use crate::core::json::JsonLike;
 use crate::core::mustache::Mustache;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -90,7 +91,7 @@ impl<A> DynamicValue<A> {
     }
 }
 
-impl TryFrom<&Value> for DynamicValue<ConstValue> {
+impl<A: for<'a> JsonLike<'a>> TryFrom<&Value> for DynamicValue<A> {
     type Error = anyhow::Error;
 
     fn try_from(value: &Value) -> Result<Self, Self::Error> {
@@ -104,19 +105,19 @@ impl TryFrom<&Value> for DynamicValue<ConstValue> {
                 Ok(DynamicValue::Object(out))
             }
             Value::Array(arr) => {
-                let out: Result<Vec<DynamicValue<ConstValue>>, Self::Error> =
+                let out: Result<Vec<DynamicValue<A>>, Self::Error> =
                     arr.iter().map(DynamicValue::try_from).collect();
                 Ok(DynamicValue::Array(out?))
             }
             Value::String(s) => {
                 let m = Mustache::parse(s.as_str());
                 if m.is_const() {
-                    Ok(DynamicValue::Value(ConstValue::from_json(value.clone())?))
+                    Ok(DynamicValue::Value(A::clone_from(value)))
                 } else {
                     Ok(DynamicValue::Mustache(m))
                 }
             }
-            _ => Ok(DynamicValue::Value(ConstValue::from_json(value.clone())?)),
+            _ => Ok(DynamicValue::Value(A::clone_from(value))),
         }
     }
 }

src/core/blueprint/error.rs

@@ -49,8 +49,8 @@ pub enum BlueprintError {
     #[error("GroupBy is only supported for GET and POST requests")]
     GroupByOnlyForGetAndPost,
 
-    #[error("request body batching requires exactly one dynamic value in the body.")]
-    RequestBatchingRequiresAtLeastOneDynamicParameter,
+    #[error("Request body batching requires exactly one dynamic value in the body.")]
+    BatchRequiresDynamicParameter,
 
     #[error("Batching capability was used without enabling it in upstream")]
     IncorrectBatchingUsage,

src/core/blueprint/operators/http.rs

@@ -1,4 +1,5 @@
-use regex::Regex;
+use std::borrow::Cow;
+
 use tailcall_valid::{Valid, Validator};
 use template_validation::validate_argument;
 
@@ -22,39 +23,10 @@ pub fn compile_http(
         Err(e) => Valid::from_validation_err(BlueprintError::from_validation_string(e)),
     };
 
-    Valid::<(), BlueprintError>::fail(BlueprintError::GroupByOnlyForGetAndPost)
-        .when(|| !http.batch_key.is_empty() && !matches!(http.method, Method::GET | Method::POST))
-        .and(
-            Valid::<(), BlueprintError>::fail(BlueprintError::IncorrectBatchingUsage).when(|| {
-                (config_module.upstream.get_delay() < 1
-                    || config_module.upstream.get_max_size() < 1)
-                    && !http.batch_key.is_empty()
-            }),
-        )
-        .and_then(|_| {
-            let result = if http.method == Method::POST {
-                if !http.batch_key.is_empty() {
-                    let keys = http
-                        .body
-                        .as_ref()
-                        .map(|b| extract_expression_keys(b).len())
-                        .unwrap_or_default();
-
-                    if keys == 1 {
-                        Valid::succeed(())
-                    } else {
-                        Valid::fail(
-                            BlueprintError::RequestBatchingRequiresAtLeastOneDynamicParameter,
-                        )
-                    }
-                } else {
-                    Valid::succeed(())
-                }
-            } else {
-                Valid::succeed(())
-            };
-
-            result.trace("body")
+    Valid::<(), BlueprintError>::fail(BlueprintError::IncorrectBatchingUsage)
+        .when(|| {
+            (config_module.upstream.get_delay() < 1 || config_module.upstream.get_max_size() < 1)
+                && !http.batch_key.is_empty()
         })
         .and(
             Valid::from_iter(http.query.iter(), |query| {
@@ -92,6 +64,23 @@ pub fn compile_http(
                 Err(e) => Valid::fail(BlueprintError::Error(e)),
             }
         })
+        .and_then(|request_template| {
+            if !http.batch_key.is_empty() && (http.body.is_some() || http.method != Method::GET) {
+                let keys = http.body.as_ref().map(|b| extract_expression_paths(b));
+                if let Some(keys) = keys {
+                    // only one dynamic value allowed in body for batching to work.
+                    if keys.len() != 1 {
+                        Valid::fail(BlueprintError::BatchRequiresDynamicParameter).trace("body")
+                    } else {
+                        Valid::succeed(request_template)
+                    }
+                } else {
+                    Valid::fail(BlueprintError::BatchRequiresDynamicParameter).trace("body")
+                }
+            } else {
+                Valid::succeed(request_template)
+            }
+        })
         .map(|req_template| {
             // marge http and upstream on_request
             let http_filter = http
@@ -111,17 +100,7 @@ pub fn compile_http(
                             .then(|| q.key.clone())
                     })
                 } else {
-                    // find the key from the body where value is mustache template.
-                    http.body
-                        .as_ref()
-                        .map(|b| extract_expression_keys(b))
-                        .and_then(|keys| {
-                            if keys.len() == 1 {
-                                Some(keys[0].clone())
-                            } else {
-                                None
-                            }
-                        })
+                    None
                 };
 
                 IR::IO(IO::Http {
@@ -149,33 +128,75 @@ pub fn compile_http(
 
 /// extracts the keys from the json representation, if the value is of mustache
 /// template type.
-fn extract_expression_keys(json: &str) -> Vec<String> {
-    let mut keys = Vec::new();
-    let re = Regex::new(r#""([^"]+)"\s*:\s*"\{\{.*?\}\}""#).unwrap();
-    for cap in re.captures_iter(json) {
-        if let Some(key) = cap.get(1) {
-            keys.push(key.as_str().to_string());
+fn extract_expression_paths(json: &serde_json::Value) -> Vec<Vec<Cow<'_, str>>> {
+    fn extract_paths<'a>(
+        json: &'a serde_json::Value,
+        path: &mut Vec<Cow<'a, str>>,
+    ) -> Vec<Vec<Cow<'a, str>>> {
+        let mut keys = vec![];
+        match json {
+            serde_json::Value::Array(arr) => {
+                arr.iter().enumerate().for_each(|(idx, v)| {
+                    let idx = idx.to_string();
+                    path.push(Cow::Owned(idx));
+                    keys.extend(extract_paths(v, path));
+                });
+            }
+            serde_json::Value::Object(obj) => {
+                obj.iter().for_each(|(k, v)| {
+                    path.push(Cow::Borrowed(k));
+                    keys.extend(extract_paths(v, path));
+                    path.pop();
+                });
+            }
+            serde_json::Value::String(s) => {
+                if !Mustache::parse(s).is_const() {
+                    keys.push(path.to_vec());
+                }
+            }
+            _ => {}
         }
+        keys
     }
-    println!("[Finder]: input: {:#?} and output: {:#?}", json, keys);
-    keys
+
+    extract_paths(json, &mut Vec::new())
 }
 
 #[cfg(test)]
 mod test {
+    use serde_json::json;
+
     use super::*;
 
     #[test]
-    fn test_extract_expression_keys_from_str() {
+    fn test_extract_expression_keys_from_nested_objects() {
         let json = r#"{"body":"d","userId":"{{.value.uid}}","nested":{"other":"{{test}}"}}"#;
-        let keys = extract_expression_keys(json);
-        assert_eq!(keys, vec!["userId", "other"]);
+        let json = serde_json::from_str(json).unwrap();
+        let keys = extract_expression_paths(&json);
+        assert_eq!(keys.len(), 2);
+        assert_eq!(keys, vec![vec!["userId"], vec!["nested", "other"]]);
+    }
+
+    #[test]
+    fn test_extract_expression_keys_from_mixed_json() {
+        let json = r#"{"body":"d","userId":"{{.value.uid}}","nested":{"other":"{{test}}"},"meta":[{"key": "id", "value": "{{.value.userId}}"}]}"#;
+        let json = serde_json::from_str(json).unwrap();
+        let keys = extract_expression_paths(&json);
+        assert_eq!(keys.len(), 3);
+        assert_eq!(
+            keys,
+            vec![
+                vec!["userId"],
+                vec!["nested", "other"],
+                vec!["meta", "0", "value"]
+            ]
+        );
     }
 
     #[test]
     fn test_with_non_json_value() {
-        let json = r#"{{.value}}"#;
-        let keys = extract_expression_keys(json);
-        assert_eq!(keys, Vec::<String>::new());
+        let json = json!(r#"{{.value}}"#);
+        let keys = extract_expression_paths(&json);
+        assert!(keys.iter().all(|f| f.is_empty()));
     }
 }

src/core/blueprint/snapshots/tailcall__core__blueprint__index__test__from_blueprint.snap

@@ -58,7 +58,7 @@ Index {
                                                 ),
                                                 headers: {},
                                                 body: Some(
-                                                    "{{.args.input}}",
+                                                    String("{{.args.input}}"),
                                                 ),
                                                 description: None,
                                                 encoding: ApplicationJson,
@@ -127,7 +127,7 @@ Index {
                                                 ),
                                                 headers: {},
                                                 body: Some(
-                                                    "{{.args.input}}",
+                                                    String("{{.args.input}}"),
                                                 ),
                                                 description: None,
                                                 encoding: ApplicationJson,
@@ -205,7 +205,7 @@ Index {
                                                 ),
                                                 headers: {},
                                                 body: Some(
-                                                    "{{.args.input}}",
+                                                    String("{{.args.input}}"),
                                                 ),
                                                 description: None,
                                                 encoding: ApplicationJson,
@@ -286,7 +286,7 @@ Index {
                                                 ),
                                                 headers: {},
                                                 body: Some(
-                                                    "{{.args.input}}",
+                                                    String("{{.args.input}}"),
                                                 ),
                                                 description: None,
                                                 encoding: ApplicationJson,

src/core/config/directives/http.rs

@@ -40,8 +40,9 @@ pub struct Http {
     #[serde(default, skip_serializing_if = "is_default")]
     /// The body of the API call. It's used for methods like POST or PUT that
     /// send data to the server. You can pass it as a static object or use a
-    /// Mustache template to substitute variables from the GraphQL variables.
-    pub body: Option<String>,
+    /// Mustache template with object to substitute variables from the GraphQL
+    /// variables.
+    pub body: Option<Value>,
 
     #[serde(default, skip_serializing_if = "is_default")]
     /// The `encoding` parameter specifies the encoding of the request body. It

src/core/config/transformer/subgraph.rs

@@ -275,7 +275,7 @@ impl KeysExtractor {
                 Valid::from_iter(
                     [
                         Self::parse_str(http.url.as_str()).trace("url"),
-                        Self::parse_str_option(http.body.as_deref()).trace("body"),
+                        Self::parse_json_option(http.body.as_ref()).trace("body"),
                         Self::parse_key_value_iter(http.headers.iter()).trace("headers"),
                         Self::parse_key_value_iter(http.query.iter().map(|q| KeyValue {
                             key: q.key.to_string(),
@@ -355,9 +355,9 @@ impl KeysExtractor {
         .map_to(keys)
     }
 
-    fn parse_str_option(s: Option<&str>) -> Valid<Keys, String> {
+    fn parse_json_option(s: Option<&serde_json::Value>) -> Valid<Keys, String> {
         if let Some(s) = s {
-            Self::parse_str(s)
+            Self::parse_str(&s.to_string())
         } else {
             Valid::succeed(Keys::new())
         }
@@ -483,7 +483,9 @@ mod tests {
         fn test_extract_http() {
             let http = Http {
                 url: "http://tailcall.run/users/{{.value.id}}".to_string(),
-                body: Some(r#"{ "obj": "{{.value.obj}}"} "#.to_string()),
+                body: Some(serde_json::Value::String(
+                    r#"{ "obj": "{{.value.obj}}"} "#.to_string(),
+                )),
                 headers: vec![KeyValue {
                     key: "{{.value.header.key}}".to_string(),
                     value: "{{.value.header.value}}".to_string(),

src/core/endpoint.rs

@@ -13,7 +13,7 @@ pub struct Endpoint {
     pub input: JsonSchema,
     pub output: JsonSchema,
     pub headers: HeaderMap,
-    pub body: Option<String>,
+    pub body: Option<serde_json::Value>,
     pub description: Option<String>,
     pub encoding: Encoding,
 }

src/core/generator/json/operation_generator.rs

@@ -41,7 +41,10 @@ impl OperationTypeGenerator {
             let arg_name_gen = NameGenerator::new(prefix.as_str());
             let arg_name = arg_name_gen.next();
 
-            http_resolver.body = Some(format!("{{{{.args.{}}}}}", arg_name));
+            http_resolver.body = Some(serde_json::Value::String(format!(
+                "{{{{.args.{}}}}}",
+                arg_name
+            )));
             http_resolver.method = request_sample.method.to_owned();
 
             field.args.insert(