feat: create @call operator

examples/jsonplaceholder.graphql

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

src/blueprint/from_config/definitions.rs

@@ -345,6 +345,7 @@ fn to_fields(object_name: &str, type_of: &config::Type, config: &Config) -> Vali
       .and(update_const_field().trace(config::Const::trace_name().as_str()))
       .and(update_graphql(&operation_type).trace(config::GraphQL::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())
       .try_fold(&(config, field, type_of, name), FieldDefinition::default())
   };
@@ -383,6 +384,7 @@ fn to_fields(object_name: &str, type_of: &config::Type, config: &Config) -> Vali
             const_field: source_field.const_field.clone(),
             graphql: source_field.graphql.clone(),
             cache: source_field.cache.clone(),
+            call: source_field.call.clone(),
           };
           to_field(&add_field.name, &new_field)
             .and_then(|field_definition| {

src/blueprint/from_config/operators/call.rs

@@ -0,0 +1,59 @@
+use crate::blueprint::*;
+use crate::config;
+use crate::config::{Config, Field, GraphQLOperationType};
+use crate::directive::DirectiveCodec;
+use crate::try_fold::TryFold;
+use crate::valid::Valid;
+
+pub fn update_call(
+  operation_type: &GraphQLOperationType,
+) -> TryFold<'_, (&Config, &Field, &config::Type, &str), FieldDefinition, String> {
+  TryFold::<(&Config, &Field, &config::Type, &str), FieldDefinition, String>::new(
+    move |(config, field, type_of, name), b_field| {
+      let Some(call) = &field.call else {
+        return Valid::succeed(b_field);
+      };
+
+      let type_and_field = if let Some(mutation) = &call.mutation {
+        Valid::succeed(("Mutation", mutation.as_str()))
+      } else if let Some(query) = &call.query {
+        Valid::succeed(("Query", query.as_str()))
+      } else {
+        Valid::fail("call must have one of mutation or query".to_string())
+      };
+
+      type_and_field
+        .and_then(|(type_name, field_name)| {
+          Valid::from_option(
+            config.find_type(type_name),
+            format!("{} type not found on config", type_name),
+          )
+          .zip(Valid::succeed(field_name))
+        })
+        .and_then(|(query_type, field_name)| {
+          Valid::from_option(
+            query_type.fields.get(field_name),
+            format!("{} field not found", field_name),
+          )
+          .and_then(|field| {
+            if !field.has_resolver() {
+              return Valid::fail(format!("{} field has no resolver", field_name));
+            }
+
+            Valid::succeed(field)
+          })
+        })
+        .and_then(|field| {
+          // TO-DO: parse call.args into a way that `update_http`, `update_grpc` and `update_graphql` can use
+
+          TryFold::<(&Config, &Field, &config::Type, &str), FieldDefinition, String>::new(|_, b_field| {
+            Valid::succeed(b_field)
+          })
+          .and(update_http().trace(config::Http::trace_name().as_str()))
+          .and(update_grpc(operation_type).trace(config::Grpc::trace_name().as_str()))
+          .and(update_graphql(operation_type).trace(config::GraphQL::trace_name().as_str()))
+          .try_fold(&(config, field, type_of, name), b_field)
+        })
+    },
+  )
+}

src/blueprint/from_config/operators/mod.rs

@@ -1,10 +1,12 @@
+mod call;
 mod const_field;
 mod graphql;
 mod grpc;
 mod http;
 mod modify;
 mod unsafe_field;
 
+pub use call::*;
 pub use const_field::*;
 pub use graphql::*;
 pub use grpc::*;

src/config/config.rs

@@ -251,6 +251,8 @@ pub struct Field {
   #[serde(default, skip_serializing_if = "is_default")]
   pub http: Option<Http>,
   #[serde(default, skip_serializing_if = "is_default")]
+  pub call: Option<Call>,
+  #[serde(default, skip_serializing_if = "is_default")]
   pub grpc: Option<Grpc>,
   #[serde(rename = "unsafe", default, skip_serializing_if = "is_default")]
   pub unsafe_operation: Option<Unsafe>,
@@ -387,6 +389,15 @@ pub struct Http {
   pub group_by: Vec<String>,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+pub struct Call {
+  #[serde(default, skip_serializing_if = "is_default")]
+  pub query: Option<String>,
+  #[serde(default, skip_serializing_if = "is_default")]
+  pub mutation: Option<String>,
+  pub args: KeyValues,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct Grpc {

src/config/from_document.rs

@@ -8,7 +8,7 @@ use async_graphql::parser::Positioned;
 use async_graphql::Name;
 
 use super::Cache;
-use crate::config::{self, Config, GraphQL, Grpc, RootSchema, Server, Union, Upstream};
+use crate::config::{self, Call, Config, GraphQL, Grpc, RootSchema, Server, Union, Upstream};
 use crate::directive::DirectiveCodec;
 use crate::valid::Valid;
 
@@ -222,7 +222,8 @@ where
     .zip(GraphQL::from_directives(directives.iter()))
     .zip(Cache::from_directives(directives.iter()))
     .zip(Grpc::from_directives(directives.iter()))
-    .map(|(((http, graphql), cache), grpc)| {
+    .zip(Call::from_directives(directives.iter()))
+    .map(|((((http, graphql), cache), grpc), call)| {
       let unsafe_operation = to_unsafe_operation(directives);
       let const_field = to_const_field(directives);
       config::Field {
@@ -239,6 +240,7 @@ where
         const_field,
         graphql,
         cache: cache.or(parent_cache),
+        call,
       }
     })
 }