refactor(config): represent field resolver as separate enum

generated/.tailcallrc.schema.json

@@ -372,6 +372,80 @@
     "Field": {
       "description": "A field definition containing all the metadata information about resolving a field.",
       "type": "object",
+      "oneOf": [
+        {
+          "type": "object",
+          "required": [
+            "http"
+          ],
+          "properties": {
+            "http": {
+              "$ref": "#/definitions/Http"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "grpc"
+          ],
+          "properties": {
+            "grpc": {
+              "$ref": "#/definitions/Grpc"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "graphql"
+          ],
+          "properties": {
+            "graphql": {
+              "$ref": "#/definitions/GraphQL"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "call"
+          ],
+          "properties": {
+            "call": {
+              "$ref": "#/definitions/Call"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "js"
+          ],
+          "properties": {
+            "js": {
+              "$ref": "#/definitions/JS"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "expr"
+          ],
+          "properties": {
+            "expr": {
+              "$ref": "#/definitions/Expr"
+            }
+          },
+          "additionalProperties": false
+        }
+      ],
       "properties": {
         "args": {
           "description": "Map of argument name and its definition.",
@@ -391,17 +465,6 @@
             }
           ]
         },
-        "call": {
-          "description": "Inserts a call resolver for the field.",
-          "anyOf": [
-            {
-              "$ref": "#/definitions/Call"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
         "default_value": {
           "description": "Stores the default value for the field"
         },
@@ -412,50 +475,6 @@
             "null"
           ]
         },
-        "expr": {
-          "description": "Inserts a constant resolver for the field.",
-          "anyOf": [
-            {
-              "$ref": "#/definitions/Expr"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "graphql": {
-          "description": "Inserts a GraphQL resolver for the field.",
-          "anyOf": [
-            {
-              "$ref": "#/definitions/GraphQL"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "grpc": {
-          "description": "Inserts a GRPC resolver for the field.",
-          "anyOf": [
-            {
-              "$ref": "#/definitions/Grpc"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "http": {
-          "description": "Inserts an HTTP resolver for the field.",
-          "anyOf": [
-            {
-              "$ref": "#/definitions/Http"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
         "list": {
           "description": "Flag to indicate the type is a list.",
           "type": "boolean"
@@ -502,17 +521,6 @@
           "description": "Flag to indicate the type is required.",
           "type": "boolean"
         },
-        "script": {
-          "description": "Inserts a Javascript resolver for the field.",
-          "anyOf": [
-            {
-              "$ref": "#/definitions/JS"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
         "type": {
           "description": "Refers to the type of the value the field can be resolved to.",
           "type": "string"

src/cli/tc/init.rs

@@ -5,7 +5,7 @@ use anyhow::Result;
 
 use super::helpers::{FILE_NAME, JSON_FILE_NAME, YML_FILE_NAME};
 use crate::cli::runtime::{confirm_and_write, create_directory, select_prompt};
-use crate::core::config::{Config, Expr, Field, RootSchema, Source, Type};
+use crate::core::config::{Config, Expr, Field, Resolver, RootSchema, Source, Type};
 use crate::core::merge_right::MergeRight;
 use crate::core::runtime::TargetRuntime;
 
@@ -75,7 +75,7 @@ fn main_config() -> Config {
     let field = Field {
         type_of: "String".to_string(),
         required: true,
-        const_field: Some(Expr { body: "Hello, World!".into() }),
+        resolver: Some(Resolver::Expr(Expr { body: "Hello, World!".into() })),
         ..Default::default()
     };
 

src/core/blueprint/definitions.rs

@@ -102,20 +102,9 @@ fn process_field_within_type(context: ProcessFieldWithinTypeContext) -> Valid<Ty
     let path_resolver_error_handler = context.path_resolver_error_handler;
 
     if let Some(next_field) = type_info.fields.get(field_name) {
-        if next_field.has_resolver() {
-            let next_dir_http = next_field
-                .http
-                .as_ref()
-                .map(|_| config::Http::directive_name());
-            let next_dir_const = next_field
-                .const_field
-                .as_ref()
-                .map(|_| config::Expr::directive_name());
+        if let Some(resolver) = &next_field.resolver {
             return path_resolver_error_handler(
-                next_dir_http
-                    .or(next_dir_const)
-                    .unwrap_or(config::JS::directive_name())
-                    .as_str(),
+                &resolver.directive_name(),
                 &field.type_of,
                 field_name,
                 context.original_path,
@@ -423,7 +412,7 @@ fn to_fields(
                 &add_field.name,
             )
             .and_then(|field_definition| {
-                let added_field_path = match source_field.http {
+                let added_field_path = match source_field.resolver {
                     Some(_) => add_field.path[1..]
                         .iter()
                         .map(|s| s.to_owned())
@@ -497,15 +486,6 @@ pub fn to_field_definition(
     type_of: &config::Type,
     name: &String,
 ) -> Valid<FieldDefinition, String> {
-    let directives = field.resolvable_directives();
-
-    if directives.len() > 1 {
-        return Valid::fail(format!(
-            "Multiple resolvers detected [{}]",
-            directives.join(", ")
-        ));
-    }
-
     update_args()
         .and(update_http().trace(config::Http::trace_name().as_str()))
         .and(update_grpc(operation_type).trace(config::Grpc::trace_name().as_str()))

src/core/blueprint/from_config.rs

@@ -89,7 +89,7 @@ where
     let schema = if let Some(type_) = type_ {
         let mut schema_fields = HashMap::new();
         for (name, field) in type_.fields.iter() {
-            if field.script.is_none() && field.http.is_none() {
+            if field.resolver.is_none() {
                 schema_fields.insert(name.clone(), to_json_schema_for_field(field, config));
             }
         }

src/core/blueprint/operators/call.rs

@@ -2,7 +2,7 @@ use serde_json::Value;
 
 use crate::core::blueprint::*;
 use crate::core::config;
-use crate::core::config::{Field, GraphQLOperationType};
+use crate::core::config::{Field, GraphQLOperationType, Resolver};
 use crate::core::ir::model::IR;
 use crate::core::try_fold::TryFold;
 use crate::core::valid::{Valid, ValidationError, Validator};
@@ -14,11 +14,11 @@ pub fn update_call<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String>::new(
         move |(config, field, _, name), b_field| {
-            let Some(ref calls) = field.call else {
+            let Some(Resolver::Call(call)) = &field.resolver else {
                 return Valid::succeed(b_field);
             };
 
-            compile_call(config, calls, operation_type, object_name)
+            compile_call(config, call, operation_type, object_name)
                 .map(|field| b_field.resolver(field.resolver).name(name.to_string()))
         },
     )

src/core/blueprint/operators/expr.rs

@@ -2,7 +2,7 @@ use async_graphql_value::ConstValue;
 
 use crate::core::blueprint::*;
 use crate::core::config;
-use crate::core::config::Field;
+use crate::core::config::{Field, Resolver};
 use crate::core::ir::model::IR;
 use crate::core::ir::model::IR::Dynamic;
 use crate::core::try_fold::TryFold;
@@ -64,17 +64,12 @@ pub fn update_const_field<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String>::new(
         |(config_module, field, _, _), b_field| {
-            let Some(const_field) = &field.const_field else {
+            let Some(Resolver::Expr(expr)) = &field.resolver else {
                 return Valid::succeed(b_field);
             };
 
-            compile_expr(CompileExpr {
-                config_module,
-                field,
-                value: &const_field.body,
-                validate: true,
-            })
-            .map(|resolver| b_field.resolver(Some(resolver)))
+            compile_expr(CompileExpr { config_module, field, value: &expr.body, validate: true })
+                .map(|resolver| b_field.resolver(Some(resolver)))
         },
     )
 }

src/core/blueprint/operators/graphql.rs

@@ -1,7 +1,9 @@
 use std::collections::{HashMap, HashSet};
 
 use crate::core::blueprint::FieldDefinition;
-use crate::core::config::{Config, ConfigModule, Field, GraphQL, GraphQLOperationType, Type};
+use crate::core::config::{
+    Config, ConfigModule, Field, GraphQL, GraphQLOperationType, Resolver, Type,
+};
 use crate::core::graphql::RequestTemplate;
 use crate::core::helpers;
 use crate::core::ir::model::{IO, IR};
@@ -78,7 +80,7 @@ pub fn update_graphql<'a>(
 ) -> TryFold<'a, (&'a ConfigModule, &'a Field, &'a Type, &'a str), FieldDefinition, String> {
     TryFold::<(&ConfigModule, &Field, &Type, &'a str), FieldDefinition, String>::new(
         |(config, field, type_of, _), b_field| {
-            let Some(graphql) = &field.graphql else {
+            let Some(Resolver::Graphql(graphql)) = &field.resolver else {
                 return Valid::succeed(b_field);
             };
 

src/core/blueprint/operators/grpc.rs

@@ -5,7 +5,7 @@ use prost_reflect::FieldDescriptor;
 
 use crate::core::blueprint::{FieldDefinition, TypeLike};
 use crate::core::config::group_by::GroupBy;
-use crate::core::config::{Config, ConfigModule, Field, GraphQLOperationType, Grpc};
+use crate::core::config::{Config, ConfigModule, Field, GraphQLOperationType, Grpc, Resolver};
 use crate::core::grpc::protobuf::{ProtobufOperation, ProtobufSet};
 use crate::core::grpc::request_template::RequestTemplate;
 use crate::core::ir::model::{IO, IR};
@@ -216,7 +216,7 @@ pub fn update_grpc<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &'a str), FieldDefinition, String>::new(
         |(config_module, field, type_of, _name), b_field| {
-            let Some(grpc) = &field.grpc else {
+            let Some(Resolver::Grpc(grpc)) = &field.resolver else {
                 return Valid::succeed(b_field);
             };
 

src/core/blueprint/operators/http.rs

@@ -1,6 +1,6 @@
 use crate::core::blueprint::*;
 use crate::core::config::group_by::GroupBy;
-use crate::core::config::Field;
+use crate::core::config::{Field, Resolver};
 use crate::core::endpoint::Endpoint;
 use crate::core::http::{HttpFilter, Method, RequestTemplate};
 use crate::core::ir::model::{IO, IR};
@@ -93,7 +93,7 @@ pub fn update_http<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &'a str), FieldDefinition, String>::new(
         |(config_module, field, type_of, _), b_field| {
-            let Some(http) = &field.http else {
+            let Some(Resolver::Http(http)) = &field.resolver else {
                 return Valid::succeed(b_field);
             };
 

src/core/blueprint/operators/js.rs

@@ -1,6 +1,6 @@
 use crate::core::blueprint::FieldDefinition;
 use crate::core::config;
-use crate::core::config::{ConfigModule, Field};
+use crate::core::config::{ConfigModule, Field, Resolver};
 use crate::core::ir::model::{IO, IR};
 use crate::core::try_fold::TryFold;
 use crate::core::valid::{Valid, Validator};
@@ -21,7 +21,7 @@ pub fn update_js_field<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String>::new(
         |(module, field, _, _), b_field| {
-            let Some(js) = &field.script else {
+            let Some(Resolver::Js(js)) = &field.resolver else {
                 return Valid::succeed(b_field);
             };