fix(jit): input arguments required error

src/core/blueprint/index.rs

@@ -1,5 +1,6 @@
 use indexmap::IndexMap;
 
+use super::InputObjectTypeDefinition;
 use crate::core::blueprint::{
     Blueprint, Definition, FieldDefinition, InputFieldDefinition, SchemaDefinition,
 };
@@ -78,6 +79,13 @@ impl Index {
             false
         }
     }
+
+    pub fn get_input_type_definition(&self, type_name: &str) -> Option<&InputObjectTypeDefinition> {
+        match self.map.get(type_name) {
+            Some((Definition::InputObject(input), _)) => Some(input),
+            _ => None,
+        }
+    }
 }
 
 impl From<&Blueprint> for Index {

src/core/jit/context.rs

@@ -70,16 +70,9 @@ impl<'a, Input: Clone, Output> Context<'a, Input, Output> {
 
         for arg in field.args.iter() {
             let name = arg.name.as_str();
-            let value = arg
-                .value
-                .clone()
-                // TODO: default value resolution should happen in the InputResolver
-                .or_else(|| arg.default_value.clone());
+            let value = arg.value.clone();
             if let Some(value) = value {
                 arg_map.insert(Name::new(name), value);
-            } else if !arg.type_of.is_nullable() {
-                // TODO: throw error here
-                todo!()
             }
         }
         Some(arg_map)

src/core/jit/error.rs

@@ -20,6 +20,11 @@ pub enum BuildError {
 pub enum ResolveInputError {
     #[error("Variable `{0}` is not defined")]
     VariableIsNotFound(String),
+    #[error("Argument `{arg_name}` for field `{field_name}` is required")]
+    ArgumentIsRequired {
+        arg_name: String,
+        field_name: String,
+    },
 }
 
 #[derive(Error, Debug, Clone)]

src/core/jit/input_resolver.rs

@@ -1,6 +1,8 @@
 use async_graphql_value::{ConstValue, Value};
 
-use super::{OperationPlan, ResolveInputError, Variables};
+use super::{Arg, Field, OperationPlan, ResolveInputError, Variables};
+use crate::core::json::{JsonLikeOwned, JsonObjectLike};
+use crate::core::Type;
 
 /// Trait to represent conversion from some dynamic type (with variables)
 /// to the resolved variant based on the additional provided info.
@@ -18,8 +20,6 @@
 impl InputResolvable for Value {
     type Output = ConstValue;
 
-    // TODO:
-    // - provide default values
     fn resolve(self, variables: &Variables<ConstValue>) -> Result<Self::Output, ResolveInputError> {
         self.into_const_with(|name| {
             variables
@@ -30,6 +30,19 @@
     }
 }
 
+pub trait OutputHelpers {
+    type Output;
+
+    fn from_json(value: Option<serde_json::Value>) -> Option<Self::Output>;
+}
+
+impl OutputHelpers for ConstValue {
+    type Output = ConstValue;
+    fn from_json(value: Option<serde_json::Value>) -> Option<Self::Output> {
+        value.map(ConstValue::from_json).and_then(Result::ok)
+    }
+}
+
 /// Transforms [OperationPlan] values the way that all the input values
 /// are transformed to const variant with the help of [InputResolvable] trait
 pub struct InputResolver<Input> {
@@ -45,7 +58,7 @@
 impl<Input, Output> InputResolver<Input>
 where
     Input: Clone,
-    Output: Clone,
+    Output: Clone + JsonLikeOwned + OutputHelpers<Output = Output>,
     Input: InputResolvable<Output = Output>,
 {
     pub fn resolve_input(
@@ -57,7 +70,28 @@
             .as_parent()
             .iter()
             .map(|field| field.clone().try_map(|value| value.resolve(variables)))
-            .collect::<Result<_, _>>()?;
+            .map(|field| match field {
+                Ok(field) => {
+                    let args = field
+                        .args
+                        .into_iter()
+                        .map(|arg| {
+                            let value = self.recursive_parse_arg(
+                                &field.name,
+                                &arg.name,
+                                &arg.type_of,
+                                &arg.default_value,
+                                arg.value,
+                            )?;
+                            Ok(Arg { value, ..arg })
+                        })
+                        .collect::<Result<_, _>>()?;
+
+                    Ok(Field { args, ..field })
+                }
+                Err(err) => Err(err),
+            })
+            .collect::<Result<Vec<_>, _>>()?;
 
         Ok(OperationPlan::new(
             new_fields,
@@ -66,4 +100,79 @@
             self.plan.is_introspection_query,
         ))
     }
+
+    #[allow(clippy::too_many_arguments)]
+    fn recursive_parse_arg(
+        &self,
+        parent_name: &str,
+        arg_name: &str,
+        type_of: &Type,
+        default_value: &Option<Output>,
+        value: Option<Output>,
+    ) -> Result<Option<Output>, ResolveInputError> {
+        let is_value_null = value.as_ref().map(|val| val.is_null()).unwrap_or(true);
+        let value: Result<Option<Output>, ResolveInputError> =
+            if !type_of.is_nullable() && value.is_none() {
+                let default_value = default_value.clone();
+                match default_value {
+                    Some(value) => Ok(Some(value)),
+                    None => Err(ResolveInputError::ArgumentIsRequired {
+                        arg_name: arg_name.to_string(),
+                        field_name: parent_name.to_string(),
+                    }),
+                }
+            } else if !type_of.is_nullable() && is_value_null {
+                Err(ResolveInputError::ArgumentIsRequired {
+                    arg_name: arg_name.to_string(),
+                    field_name: parent_name.to_string(),
+                })
+            } else if value.is_none() {
+                let default_value = default_value.clone();
+                Ok(default_value)
+            } else {
+                Ok(value)
+            };
+
+        match value? {
+            Some(mut value) => match self.plan.index.get_input_type_definition(type_of.name()) {
+                Some(def) => {
+                    if let Some(obj) = value.as_object_mut() {
+                        for arg_field in &def.fields {
+                            let parent_name = format!("{}.{}", parent_name, arg_name);
+                            let field_value = obj.get_key(&arg_field.name).cloned();
+                            let field_default = arg_field.default_value.clone();
+                            let field_default = Output::from_json(field_default);
+                            let value = self.recursive_parse_arg(
+                                &parent_name,
+                                &arg_field.name,
+                                &arg_field.of_type,
+                                &field_default,
+                                field_value,
+                            )?;
+                            if let Some(value) = value {
+                                obj.insert_key(&arg_field.name, value);
+                            }
+                        }
+                    } else if let Some(arr) = value.as_array_mut() {
+                        for (index, item) in arr.iter_mut().enumerate() {
+                            let parent_name = format!("{}.{}.{}", parent_name, arg_name, index);
+
+                            *item = self
+                                .recursive_parse_arg(
+                                    &parent_name,
+                                    &index.to_string(),
+                                    type_of,
+                                    default_value,
+                                    Some(item.clone()),
+                                )?
+                                .expect("Because we start with `Some`, we will end with `Some`");
+                        }
+                    }
+                    Ok(Some(value))
+                }
+                None => Ok(Some(value)),
+            },
+            None => Ok(None),
+        }
+    }
 }

src/core/jit/snapshots/tailcall__core__jit__builder__tests__default_value.snap

@@ -35,6 +35,11 @@ expression: plan.into_nested()
                             ): String(
                                 "tailcall test",
                             ),
+                            Name(
+                                "id",
+                            ): Number(
+                                Number(101),
+                            ),
                         },
                     ),
                 ),

src/core/jit/snapshots/tailcall__core__jit__builder__tests__resolving_operation-2.snap

@@ -35,6 +35,11 @@ expression: plan.into_nested()
                             ): String(
                                 "test-12",
                             ),
+                            Name(
+                                "id",
+                            ): Number(
+                                Number(101),
+                            ),
                         },
                     ),
                 ),

src/core/json/borrow.rs

@@ -47,6 +47,13 @@
         }
     }
 
+    fn as_array_mut(&mut self) -> Option<&mut Vec<Self>> {
+        match self {
+            Value::Array(arr) => Some(arr),
+            _ => None,
+        }
+    }
+
     fn into_array(self) -> Option<Vec<Self>> {
         match self {
             Value::Array(array) => Some(array),

src/core/json/graphql.rs

@@ -33,6 +33,13 @@
         }
     }
 
+    fn as_array_mut(&mut self) -> Option<&mut Vec<Self>> {
+        match self {
+            ConstValue::List(seq) => Some(seq),
+            _ => None,
+        }
+    }
+
     fn into_array(self) -> Option<Vec<Self>> {
         match self {
             ConstValue::List(seq) => Some(seq),

src/core/json/json_like.rs

@@ -16,6 +16,7 @@ pub trait JsonLike<'json>: Sized {
 
     // Operators
     fn as_array(&self) -> Option<&Vec<Self>>;
+    fn as_array_mut(&mut self) -> Option<&mut Vec<Self>>;
     fn into_array(self) -> Option<Vec<Self>>;
     fn as_object(&self) -> Option<&Self::JsonObject>;
     fn as_object_mut(&mut self) -> Option<&mut Self::JsonObject>;

src/core/json/serde.rs

@@ -26,6 +26,10 @@
         self.as_array()
     }
 
+    fn as_array_mut(&mut self) -> Option<&mut Vec<Self>> {
+        self.as_array_mut()
+    }
+
     fn into_array(self) -> Option<Vec<Self>> {
         if let Self::Array(vec) = self {
             Some(vec)

tests/core/snapshots/graphql-conformance-001.md_5.snap

@@ -0,0 +1,18 @@
+---
+source: tests/core/spec.rs
+expression: response
+---
+{
+  "status": 200,
+  "headers": {
+    "content-type": "application/json"
+  },
+  "body": {
+    "data": null,
+    "errors": [
+      {
+        "message": "Build error: ResolveInputError: Argument `id` for field `user` is required"
+      }
+    ]
+  }
+}

tests/core/snapshots/graphql-conformance-015.md_10.snap

@@ -0,0 +1,18 @@
+---
+source: tests/core/spec.rs
+expression: response
+---
+{
+  "status": 200,
+  "headers": {
+    "content-type": "application/json"
+  },
+  "body": {
+    "data": null,
+    "errors": [
+      {
+        "message": "Build error: ResolveInputError: Argument `size` for field `profilePic` is required"
+      }
+    ]
+  }
+}

tests/core/snapshots/graphql-conformance-015.md_11.snap

@@ -0,0 +1,19 @@
+---
+source: tests/core/spec.rs
+expression: response
+---
+{
+  "status": 200,
+  "headers": {
+    "content-type": "application/json"
+  },
+  "body": {
+    "data": {
+      "user": {
+        "id": 4,
+        "name": "User 4",
+        "spam": "FIZZ: [{\"bar\":\"BUZZ\"},{\"bar\":\"test\"}]"
+      }
+    }
+  }
+}

tests/core/snapshots/graphql-conformance-015.md_5.snap

@@ -12,7 +12,7 @@ expression: response
       "user": {
         "id": 4,
         "name": "User 4",
-        "featuredVideo": "video_4_1600_900_"
+        "featuredVideo": "video_4_1600_900_true"
       }
     }
   }

tests/core/snapshots/graphql-conformance-015.md_9.snap

@@ -0,0 +1,18 @@
+---
+source: tests/core/spec.rs
+expression: response
+---
+{
+  "status": 200,
+  "headers": {
+    "content-type": "application/json"
+  },
+  "body": {
+    "data": null,
+    "errors": [
+      {
+        "message": "Build error: ResolveInputError: Argument `height` for field `featuredVideoPreview.video` is required"
+      }
+    ]
+  }
+}

tests/core/snapshots/graphql-conformance-015.md_client.snap

@@ -12,6 +12,10 @@ scalar Email
 
 scalar Empty
 
+input Foo {
+  bar: String! = "BUZZ"
+}
+
 scalar Int128
 
 scalar Int16
@@ -49,6 +53,7 @@ type User {
   name: String!
   profilePic(size: Int! = 100, width: Int, height: Int = 100): String!
   searchComments(query: [[String!]!]! = [["today"]]): String!
+  spam(foo: [Foo!]!): String!
 }
 
 input VideoSize {