feat: create @call operator

autogen/src/gen_gql_schema.rs

@@ -9,11 +9,12 @@ use schemars::schema::{
 use tailcall::config;
 
 static GRAPHQL_SCHEMA_FILE: &str = "generated/.tailcallrc.graphql";
-static DIRECTIVE_ALLOW_LIST: [(&str, Entity, bool); 13] = [
+static DIRECTIVE_ALLOW_LIST: [(&str, Entity, bool); 14] = [
     ("server", Entity::Schema, false),
     ("link", Entity::Schema, true),
     ("upstream", Entity::Schema, false),
     ("http", Entity::FieldDefinition, false),
+    ("call", Entity::FieldDefinition, false),
     ("grpc", Entity::FieldDefinition, false),
     ("addField", Entity::Object, true),
     ("modify", Entity::FieldDefinition, false),

examples/jsonplaceholder.graphql

@@ -24,5 +24,5 @@ type Post {
   userId: Int!
   title: String!
   body: String!
-  user: User @http(path: "/users/{{value.userId}}")
+  user: User @call(query: "user", args: {id: "{{value.userId}}"})
 }

generated/.tailcallrc.graphql

@@ -24,6 +24,35 @@ directive @cache(
   maxAge: Int!
 ) on FIELD_DEFINITION
 
+"""
+For instance, if you have a `user(id: Int!): User @http(path: "/users/{{args.id}}")` 
+field on the `Query` type, you can reference it from another field on the `Query` 
+type using the `@call` operator. So, on `Post.user` you can declare `user: User @call(query: 
+"user", args: {id: "{{value.userId}}"})`, and this will replace the `{{args.id}}` 
+used in the `@http` operator with the value of `userId` from the `Post` type.In case 
+you have a `user(input: UserInput!): User @http(path: "/users")` field on the `Mutation` 
+type, you can reference it from another field on the `Mutation` type. So, on `Post.user` 
+you can declare `user: User @call(mutation: "user", args: {input: "{{value.userInput}}"})`, 
+and this will replace the `{{args.input}}` used in the `@http` operator with the 
+value of `userInput` from the `Post` type.
+"""
+directive @call(
+  """
+  The arguments of the field on the `Query` type that you want to call. For instance 
+  `{id: "{{value.userId}}"}`.
+  """
+  args: JSON
+  """
+  The name of the field on the `Mutation` type that you want to call. For instance 
+  `createUser`.
+  """
+  mutation: String
+  """
+  The name of the field on the `Query` type that you want to call. For instance `user`.
+  """
+  query: String
+) on FIELD_DEFINITION
+
 """
 The `@const` operators allows us to embed a constant response for the schema.
 """
@@ -418,6 +447,7 @@ input ExprBody {
   http: Http
   grpc: Grpc
   graphQL: GraphQL
+  call: Call
   const: JSON
   if: ExprIf
   and: [ExprBody]

generated/.tailcallrc.schema.json

@@ -151,6 +151,36 @@
         }
       }
     },
+    "Call": {
+      "description": "For instance, if you have a `user(id: Int!): User @http(path: \"/users/{{args.id}}\")` field on the `Query` type, you can reference it from another field on the `Query` type using the `@call` operator. So, on `Post.user` you can declare `user: User @call(query: \"user\", args: {id: \"{{value.userId}}\"})`, and this will replace the `{{args.id}}` used in the `@http` operator with the value of `userId` from the `Post` type.\n\nIn case you have a `user(input: UserInput!): User @http(path: \"/users\")` field on the `Mutation` type, you can reference it from another field on the `Mutation` type. So, on `Post.user` you can declare `user: User @call(mutation: \"user\", args: {input: \"{{value.userInput}}\"})`, and this will replace the `{{args.input}}` used in the `@http` operator with the value of `userInput` from the `Post` type.",
+      "type": "object",
+      "required": [
+        "args"
+      ],
+      "properties": {
+        "args": {
+          "description": "The arguments of the field on the `Query` type that you want to call. For instance `{id: \"{{value.userId}}\"}`.",
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "mutation": {
+          "description": "The name of the field on the `Mutation` type that you want to call. For instance `createUser`.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "query": {
+          "description": "The name of the field on the `Query` type that you want to call. For instance `user`.",
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      }
+    },
     "Const": {
       "description": "The `@const` operators allows us to embed a constant response for the schema.",
       "type": "object",
@@ -226,6 +256,19 @@
           },
           "additionalProperties": false
         },
+        {
+          "description": "Reuses a resolver pre-defined on `Query` or `Mutation`",
+          "type": "object",
+          "required": [
+            "call"
+          ],
+          "properties": {
+            "call": {
+              "$ref": "#/definitions/Call"
+            }
+          },
+          "additionalProperties": false
+        },
         {
           "description": "Evaluate to constant data",
           "type": "object",
@@ -927,6 +970,17 @@
             }
           ]
         },
+        "call": {
+          "description": "Inserts a call resolver for the field.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Call"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "const": {
           "description": "Inserts a constant resolver for the field.",
           "anyOf": [

src/blueprint/definitions.rs

@@ -396,6 +396,7 @@ fn to_fields(
             .and(update_graphql(&operation_type).trace(config::GraphQL::trace_name().as_str()))
             .and(update_expr(&operation_type).trace(config::Expr::trace_name().as_str()))
             .and(update_modify().trace(config::Modify::trace_name().as_str()))
+            .and(update_call(&operation_type).trace(config::Call::trace_name().as_str()))
             .and(update_nested_resolvers())
             .and(update_cache_resolvers())
             .try_fold(

src/blueprint/mustache.rs

@@ -101,14 +101,14 @@ impl<'a> MustachePartsValidator<'a> {
 }
 
 impl FieldDefinition {
-    pub fn validate_field(&self, type_of: &config::Type, config: &Config) -> Valid<(), String> {
+    pub fn validate_field(self, type_of: &config::Type, config: &Config) -> Valid<Self, String> {
         // XXX we could use `Mustache`'s `render` method with a mock
         // struct implementing the `PathString` trait encapsulating `validation_map`
         // but `render` simply falls back to the default value for a given
         // type if it doesn't exist, so we wouldn't be able to get enough
         // context from that method alone
         // So we must duplicate some of that logic here :(
-        let parts_validator = MustachePartsValidator::new(type_of, config, self);
+        let parts_validator = MustachePartsValidator::new(type_of, config, &self);
 
         match &self.resolver {
             Some(Expression::IO(IO::Http { req_template, .. })) => {
@@ -168,5 +168,6 @@ impl FieldDefinition {
             }
             _ => Valid::succeed(()),
         }
+        .map_to(self)
     }
 }

src/blueprint/operators/call.rs

@@ -0,0 +1,168 @@
+use std::collections::hash_map::Iter;
+
+use crate::blueprint::*;
+use crate::config;
+use crate::config::{Field, GraphQLOperationType, KeyValues};
+use crate::lambda::Expression;
+use crate::mustache::{Mustache, Segment};
+use crate::try_fold::TryFold;
+use crate::valid::{Valid, Validator};
+
+fn find_value<'a>(args: &'a Iter<'a, String, String>, key: &'a String) -> Option<&'a String> {
+    args.clone()
+        .find_map(|(k, value)| if k == key { Some(value) } else { None })
+}
+
+pub fn update_call(
+    operation_type: &GraphQLOperationType,
+) -> TryFold<'_, (&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String> {
+    TryFold::<(&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String>::new(
+        move |(config, field, _, _), b_field| {
+            let Some(call) = &field.call else {
+                return Valid::succeed(b_field);
+            };
+
+            compile_call(field, config, call, operation_type)
+                .map(|resolver| b_field.resolver(Some(resolver)))
+        },
+    )
+}
+
+pub fn compile_call(
+    field: &Field,
+    config_module: &ConfigModule,
+    call: &config::Call,
+    operation_type: &GraphQLOperationType,
+) -> Valid<Expression, String> {
+    get_field_and_field_name(call, config_module).and_then(|(_field, field_name, args)| {
+        let empties: Vec<(&String, &config::Arg)> = _field
+            .args
+            .iter()
+            .filter(|(k, _)| !args.clone().any(|(k1, _)| k1.eq(*k)))
+            .collect();
+
+        if empties.len().gt(&0) {
+            return Valid::fail(format!(
+                "no argument {} found",
+                empties
+                    .iter()
+                    .map(|(k, _)| format!("'{}'", k))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ))
+            .trace(field_name.as_str());
+        }
+
+        let string_replacer = replace_string(&args);
+        let key_value_replacer = replace_key_values(&args);
+
+        if let Some(mut http) = _field.http.clone() {
+            http.path = string_replacer(http.path.clone());
+            http.body = http.body.clone().map(string_replacer);
+            http.query = key_value_replacer(http.query);
+            http.headers = key_value_replacer(http.headers);
+
+            compile_http(config_module, field, &http)
+        } else if let Some(mut graphql) = _field.graphql.clone() {
+            graphql.headers = key_value_replacer(graphql.headers);
+            graphql.args = graphql.args.clone().map(key_value_replacer);
+
+            compile_graphql(config_module, operation_type, &graphql)
+        } else if let Some(mut grpc) = _field.grpc.clone() {
+            grpc.base_url = grpc.base_url.clone().map(&string_replacer);
+            grpc.headers = key_value_replacer(grpc.headers);
+            grpc.body = grpc.body.clone().map(string_replacer);
+
+            compile_grpc(CompileGrpc {
+                config_module,
+                operation_type,
+                field,
+                grpc: &grpc,
+                validate_with_schema: true,
+            })
+        } else {
+            return Valid::fail(format!("{} field has no resolver", field_name));
+        }
+    })
+}
+
+fn replace_key_values<'a>(
+    args: &'a Iter<'a, String, String>,
+) -> impl Fn(KeyValues) -> KeyValues + 'a {
+    |key_values| {
+        KeyValues(
+            key_values
+                .iter()
+                .map(|(k, v)| (k.clone(), replace_string(args)(v.clone())))
+                .collect(),
+        )
+    }
+}
+
+fn replace_string<'a>(args: &'a Iter<'a, String, String>) -> impl Fn(String) -> String + 'a {
+    |str| {
+        let mustache = Mustache::parse(&str).unwrap();
+
+        let mustache = replace_mustache_value(&mustache, args);
+
+        mustache.to_string()
+    }
+}
+
+fn get_type_and_field(call: &config::Call) -> Option<(String, String)> {
+    if let Some(query) = &call.query {
+        Some(("Query".to_string(), query.clone()))
+    } else {
+        call.mutation
+            .as_ref()
+            .map(|mutation| ("Mutation".to_string(), mutation.clone()))
+    }
+}
+
+fn get_field_and_field_name<'a>(
+    call: &'a config::Call,
+    config_module: &'a ConfigModule,
+) -> Valid<(&'a Field, String, Iter<'a, String, String>), String> {
+    Valid::from_option(
+        get_type_and_field(call),
+        "call must have query or mutation".to_string(),
+    )
+    .and_then(|(type_name, field_name)| {
+        Valid::from_option(
+            config_module.config.find_type(&type_name),
+            format!("{} type not found on config", type_name),
+        )
+        .and_then(|query_type| {
+            Valid::from_option(
+                query_type.fields.get(&field_name),
+                format!("{} field not found", field_name),
+            )
+        })
+        .fuse(Valid::succeed(field_name))
+        .fuse(Valid::succeed(call.args.iter()))
+        .into()
+    })
+}
+
+fn replace_mustache_value(value: &Mustache, args: &Iter<'_, String, String>) -> Mustache {
+    value
+        .get_segments()
+        .iter()
+        .map(|segment| match segment {
+            Segment::Literal(literal) => Segment::Literal(literal.clone()),
+            Segment::Expression(expression) => {
+                if expression[0] == "args" {
+                    let value = find_value(args, &expression[1]).unwrap();
+                    let item = Mustache::parse(value).unwrap();
+
+                    let expression = item.get_segments().first().unwrap().to_owned().to_owned();
+
+                    expression
+                } else {
+                    Segment::Expression(expression.clone())
+                }
+            }
+        })
+        .collect::<Vec<Segment>>()
+        .into()
+}

src/blueprint/operators/expr.rs

@@ -68,6 +68,7 @@
             compile_grpc(grpc)
         }
         ExprBody::GraphQL(gql) => compile_graphql(config_module, operation_type, &gql),
+        ExprBody::Call(call) => compile_call(field, config_module, &call, operation_type),
 
         // Safe Expr
         ExprBody::Const(value) => Valid::from(

src/blueprint/operators/graphql.rs

@@ -49,9 +49,11 @@ pub fn update_graphql<'a>(
                 return Valid::succeed(b_field);
             };
 
-            compile_graphql(config, operation_type, graphql)
-                .map(|resolver| b_field.resolver(Some(resolver)))
-                .and_then(|b_field| b_field.validate_field(type_of, config).map_to(b_field))
+            compile_graphql(config, operation_type, graphql).and_then(|resolver| {
+                b_field
+                    .resolver(Some(resolver))
+                    .validate_field(type_of, config)
+            })
         },
     )
 }

src/blueprint/operators/grpc.rs

@@ -215,11 +215,10 @@ pub fn update_grpc<'a>(
                 grpc,
                 validate_with_schema: true,
             })
-            .map(|resolver| b_field.resolver(Some(resolver)))
-            .and_then(|b_field| {
+            .and_then(|resolver| {
                 b_field
-                    .validate_field(type_of, config_module)
-                    .map_to(b_field)
+                    .resolver(Some(resolver))
+                    .validate_field(type_of, &config_module.config)
             })
         },
     )

src/blueprint/operators/http.rs

@@ -80,13 +80,11 @@ pub fn update_http<'a>(
                 return Valid::succeed(b_field);
             };
 
-            compile_http(config_module, field, http)
-                .map(|resolver| b_field.resolver(Some(resolver)))
-                .and_then(|b_field| {
-                    b_field
-                        .validate_field(type_of, config_module)
-                        .map_to(b_field)
-                })
+            compile_http(config_module, field, http).and_then(|resolver| {
+                b_field
+                    .resolver(Some(resolver))
+                    .validate_field(type_of, &config_module.config)
+            })
         },
     )
 }