feat: add a select field on HTTP and gRPC (#2962)

Co-authored-by: Tushar Mathur <tusharmath@gmail.com>

generated/.tailcallrc.graphql

@@ -141,6 +141,16 @@ directive @grpc(
   This refers to the gRPC method you're going to call. For instance `GetAllNews`.
   """
   method: String!
+  """
+  You can use `select` with mustache syntax to re-construct the directives response 
+  to the desired format. This is useful when data are deeply nested or want to keep 
+  specific fields only from the response.* EXAMPLE 1: if we have a call that returns 
+  `{ "user": { "items": [...], ... } ... }` we can use `"{{.user.items}}"`, to extract 
+  the `items`. * EXAMPLE 2: if we have a call that returns `{ "foo": "bar", "fizz": 
+  { "buzz": "eggs", ... }, ... }` we can use { foo: "{{.foo}}", buzz: "{{.fizz.buzz}}" 
+  }`
+  """
+  select: JSON
 ) on FIELD_DEFINITION | OBJECT
 
 """
@@ -218,6 +228,16 @@ directive @http(
   is automatically selected as the batching parameter.
   """
   query: [URLQuery]
+  """
+  You can use `select` with mustache syntax to re-construct the directives response 
+  to the desired format. This is useful when data are deeply nested or want to keep 
+  specific fields only from the response.* EXAMPLE 1: if we have a call that returns 
+  `{ "user": { "items": [...], ... } ... }` we can use `"{{.user.items}}"`, to extract 
+  the `items`. * EXAMPLE 2: if we have a call that returns `{ "foo": "bar", "fizz": 
+  { "buzz": "eggs", ... }, ... }` we can use { foo: "{{.foo}}", buzz: "{{.fizz.buzz}}" 
+  }`
+  """
+  select: JSON
 ) on FIELD_DEFINITION | OBJECT
 
 directive @js(
@@ -836,6 +856,16 @@ input Grpc {
   This refers to the gRPC method you're going to call. For instance `GetAllNews`.
   """
   method: String!
+  """
+  You can use `select` with mustache syntax to re-construct the directives response 
+  to the desired format. This is useful when data are deeply nested or want to keep 
+  specific fields only from the response.* EXAMPLE 1: if we have a call that returns 
+  `{ "user": { "items": [...], ... } ... }` we can use `"{{.user.items}}"`, to extract 
+  the `items`. * EXAMPLE 2: if we have a call that returns `{ "foo": "bar", "fizz": 
+  { "buzz": "eggs", ... }, ... }` we can use { foo: "{{.foo}}", buzz: "{{.fizz.buzz}}" 
+  }`
+  """
+  select: JSON
 }
 
 """
@@ -913,6 +943,16 @@ input Http {
   is automatically selected as the batching parameter.
   """
   query: [URLQuery]
+  """
+  You can use `select` with mustache syntax to re-construct the directives response 
+  to the desired format. This is useful when data are deeply nested or want to keep 
+  specific fields only from the response.* EXAMPLE 1: if we have a call that returns 
+  `{ "user": { "items": [...], ... } ... }` we can use `"{{.user.items}}"`, to extract 
+  the `items`. * EXAMPLE 2: if we have a call that returns `{ "foo": "bar", "fizz": 
+  { "buzz": "eggs", ... }, ... }` we can use { foo: "{{.foo}}", buzz: "{{.fizz.buzz}}" 
+  }`
+  """
+  select: JSON
 }
 
 """

generated/.tailcallrc.schema.json

@@ -610,6 +610,9 @@
         "method": {
           "description": "This refers to the gRPC method you're going to call. For instance `GetAllNews`.",
           "type": "string"
+        },
+        "select": {
+          "description": "You can use `select` with mustache syntax to re-construct the directives response to the desired format. This is useful when data are deeply nested or want to keep specific fields only from the response.\n\n* EXAMPLE 1: if we have a call that returns `{ \"user\": { \"items\": [...], ... } ... }` we can use `\"{{.user.items}}\"`, to extract the `items`. * EXAMPLE 2: if we have a call that returns `{ \"foo\": \"bar\", \"fizz\": { \"buzz\": \"eggs\", ... }, ... }` we can use { foo: \"{{.foo}}\", buzz: \"{{.fizz.buzz}}\" }`"
         }
       },
       "additionalProperties": false
@@ -759,6 +762,9 @@
           "items": {
             "$ref": "#/definitions/URLQuery"
           }
+        },
+        "select": {
+          "description": "You can use `select` with mustache syntax to re-construct the directives response to the desired format. This is useful when data are deeply nested or want to keep specific fields only from the response.\n\n* EXAMPLE 1: if we have a call that returns `{ \"user\": { \"items\": [...], ... } ... }` we can use `\"{{.user.items}}\"`, to extract the `items`. * EXAMPLE 2: if we have a call that returns `{ \"foo\": \"bar\", \"fizz\": { \"buzz\": \"eggs\", ... }, ... }` we can use { foo: \"{{.foo}}\", buzz: \"{{.fizz.buzz}}\" }`"
         }
       },
       "additionalProperties": false

src/core/blueprint/dynamic_value.rs

@@ -4,14 +4,49 @@ use serde_json::Value;
 
 use crate::core::mustache::Mustache;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum DynamicValue<A> {
     Value(A),
     Mustache(Mustache),
     Object(IndexMap<Name, DynamicValue<A>>),
     Array(Vec<DynamicValue<A>>),
 }
 
+impl<A> DynamicValue<A> {
+    /// This function is used to prepend a string to every Mustache Expression.
+    /// This is useful when we want to hide a Mustache data argument from the
+    /// user and make the use of Tailcall easier
+    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::Object(index_map) => {
+                let index_map = index_map
+                    .into_iter()
+                    .map(|(key, val)| (key, val.prepend(name)))
+                    .collect();
+                DynamicValue::Object(index_map)
+            }
+            DynamicValue::Array(vec) => {
+                let vec = vec.into_iter().map(|val| val.prepend(name)).collect();
+                DynamicValue::Array(vec)
+            }
+        }
+    }
+}
+
 impl TryFrom<&DynamicValue<ConstValue>> for ConstValue {
     type Error = anyhow::Error;
 
@@ -79,3 +114,43 @@ impl TryFrom<&Value> for DynamicValue<ConstValue> {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_dynamic_value_inject() {
+        let value: DynamicValue<ConstValue> =
+            DynamicValue::Mustache(Mustache::parse("{{.foo}}")).prepend("args");
+        let expected: DynamicValue<ConstValue> =
+            DynamicValue::Mustache(Mustache::parse("{{.args.foo}}"));
+        assert_eq!(value, expected);
+
+        let mut value_map = IndexMap::new();
+        value_map.insert(
+            Name::new("foo"),
+            DynamicValue::Mustache(Mustache::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}}")),
+        );
+        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}}"),
+        )]);
+        assert_eq!(value, expected);
+
+        let value: DynamicValue<ConstValue> = DynamicValue::Value(ConstValue::Null).prepend("args");
+        let expected: DynamicValue<ConstValue> = DynamicValue::Value(ConstValue::Null);
+        assert_eq!(value, expected);
+    }
+}

src/core/blueprint/operators/grpc.rs

@@ -3,6 +3,7 @@ use std::fmt::Display;
 use prost_reflect::prost_types::FileDescriptorSet;
 use prost_reflect::FieldDescriptor;
 
+use super::apply_select;
 use crate::core::blueprint::FieldDefinition;
 use crate::core::config::group_by::GroupBy;
 use crate::core::config::{Config, ConfigModule, Field, GraphQLOperationType, Grpc, Resolver};
@@ -197,7 +198,7 @@ pub fn compile_grpc(inputs: CompileGrpc) -> Valid<IR, String> {
                 body,
                 operation_type: operation_type.clone(),
             };
-            if !grpc.batch_key.is_empty() {
+            let io = if !grpc.batch_key.is_empty() {
                 IR::IO(IO::Grpc {
                     req_template,
                     group_by: Some(GroupBy::new(grpc.batch_key.clone(), None)),
@@ -206,8 +207,11 @@ pub fn compile_grpc(inputs: CompileGrpc) -> Valid<IR, String> {
                 })
             } else {
                 IR::IO(IO::Grpc { req_template, group_by: None, dl_id: None, dedupe })
-            }
+            };
+
+            (io, &grpc.select)
         })
+        .and_then(apply_select)
 }
 
 pub fn update_grpc<'a>(

src/core/blueprint/operators/http.rs

@@ -70,7 +70,7 @@ pub fn compile_http(
                 .or(config_module.upstream.on_request.clone())
                 .map(|on_request| HttpFilter { on_request });
 
-            if !http.batch_key.is_empty() && http.method == Method::GET {
+            let io = if !http.batch_key.is_empty() && http.method == Method::GET {
                 // Find a query parameter that contains a reference to the {{.value}} key
                 let key = http.query.iter().find_map(|q| {
                     Mustache::parse(&q.value)
@@ -94,8 +94,10 @@ pub fn compile_http(
                     is_list,
                     dedupe,
                 })
-            }
+            };
+            (io, &http.select)
         })
+        .and_then(apply_select)
 }
 
 pub fn update_http<'a>(

src/core/blueprint/operators/mod.rs

@@ -8,6 +8,7 @@ mod http;
 mod js;
 mod modify;
 mod protected;
+mod select;
 
 pub use apollo_federation::*;
 pub use call::*;
@@ -19,3 +20,4 @@ pub use http::*;
 pub use js::*;
 pub use modify::*;
 pub use protected::*;
+pub use select::*;

src/core/blueprint/operators/select.rs

@@ -0,0 +1,26 @@
+use serde_json::Value;
+
+use crate::core::blueprint::DynamicValue;
+use crate::core::ir::model::IR;
+use crate::core::valid::Valid;
+
+pub fn apply_select(input: (IR, &Option<Value>)) -> Valid<IR, String> {
+    let (mut ir, select) = input;
+
+    if let Some(select_value) = select {
+        let dynamic_value = match DynamicValue::try_from(select_value) {
+            Ok(dynamic_value) => dynamic_value.prepend("args"),
+            Err(e) => {
+                return Valid::fail_with(
+                    format!("syntax error when parsing `{:?}`", select),
+                    e.to_string(),
+                )
+            }
+        };
+
+        ir = ir.pipe(IR::Dynamic(dynamic_value));
+        Valid::succeed(ir)
+    } else {
+        Valid::succeed(ir)
+    }
+}

src/core/config/directives/grpc.rs

@@ -59,4 +59,15 @@ pub struct Grpc {
     /// with APIs that expect unique results for identical inputs, such as
     /// nonce-based APIs.
     pub dedupe: Option<bool>,
+
+    /// You can use `select` with mustache syntax to re-construct the directives
+    /// response to the desired format. This is useful when data are deeply
+    /// nested or want to keep specific fields only from the response.
+    ///
+    /// * EXAMPLE 1: if we have a call that returns `{ "user": { "items": [...],
+    ///   ... } ... }` we can use `"{{.user.items}}"`, to extract the `items`.
+    /// * EXAMPLE 2: if we have a call that returns `{ "foo": "bar", "fizz": {
+    ///   "buzz": "eggs", ... }, ... }` we can use { foo: "{{.foo}}", buzz:
+    ///   "{{.fizz.buzz}}" }`
+    pub select: Option<Value>,
 }

src/core/config/directives/http.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use tailcall_macros::{DirectiveDefinition, InputDefinition};
 
 use crate::core::config::{Encoding, KeyValue, URLQuery};
@@ -98,4 +99,15 @@ pub struct Http {
     /// with APIs that expect unique results for identical inputs, such as
     /// nonce-based APIs.
     pub dedupe: Option<bool>,
+
+    /// You can use `select` with mustache syntax to re-construct the directives
+    /// response to the desired format. This is useful when data are deeply
+    /// nested or want to keep specific fields only from the response.
+    ///
+    /// * EXAMPLE 1: if we have a call that returns `{ "user": { "items": [...],
+    ///   ... } ... }` we can use `"{{.user.items}}"`, to extract the `items`.
+    /// * EXAMPLE 2: if we have a call that returns `{ "foo": "bar", "fizz": {
+    ///   "buzz": "eggs", ... }, ... }` we can use { foo: "{{.foo}}", buzz:
+    ///   "{{.fizz.buzz}}" }`
+    pub select: Option<Value>,
 }

src/core/generator/from_proto.rs

@@ -373,6 +373,7 @@ impl Context {
                     headers: vec![],
                     method: field_name.id(),
                     dedupe: None,
+                    select: None,
                 }));
 
                 let method_path =

src/core/mustache/model.rs

@@ -33,6 +33,10 @@ impl Mustache {
         &self.0
     }
 
+    pub fn segments_mut(&mut self) -> &mut Vec<Segment> {
+        &mut self.0
+    }
+
     pub fn expression_segments(&self) -> Vec<&Vec<String>> {
         self.segments()
             .iter()

tests/core/snapshots/http-select.md_0.snap

@@ -0,0 +1,21 @@
+---
+source: tests/core/spec.rs
+expression: response
+---
+{
+  "status": 200,
+  "headers": {
+    "content-type": "application/json"
+  },
+  "body": {
+    "data": {
+      "userCompany": {
+        "name": "FOO",
+        "catchPhrase": "BAR"
+      },
+      "userDetails": {
+        "city": "FIZZ"
+      }
+    }
+  }
+}