fix: input types loose out on provided graphQL documentation (#2015)

Co-authored-by: Tushar Mathur <[email protected]>

src/core/blueprint/into_schema.rs

@@ -95,6 +95,9 @@ fn to_type(def: &Definition) -> dynamic::Type {
                 }
                 object = object.field(dyn_schema_field);
             }
+            if let Some(description) = &def.description {
+                object = object.description(description);
+            }
             for interface in def.implements.iter() {
                 object = object.implement(interface.clone());
             }
@@ -115,10 +118,15 @@ fn to_type(def: &Definition) -> dynamic::Type {
         Definition::InputObject(def) => {
             let mut input_object = dynamic::InputObject::new(def.name.clone());
             for field in def.fields.iter() {
-                input_object = input_object.field(dynamic::InputValue::new(
-                    field.name.clone(),
-                    to_type_ref(&field.of_type),
-                ));
+                let mut input_field =
+                    dynamic::InputValue::new(field.name.clone(), to_type_ref(&field.of_type));
+                if let Some(description) = &field.description {
+                    input_field = input_field.description(description);
+                }
+                input_object = input_object.field(input_field);
+            }
+            if let Some(description) = &def.description {
+                input_object = input_object.description(description);
             }
 
             dynamic::Type::InputObject(input_object)

src/core/config/from_document.rs

@@ -159,9 +159,12 @@ fn to_types(
             )
             .some(),
             TypeKind::Enum(_) => Valid::none(),
-            TypeKind::InputObject(input_object_type) => {
-                to_input_object(input_object_type, &type_definition.node.directives).some()
-            }
+            TypeKind::InputObject(input_object_type) => to_input_object(
+                input_object_type,
+                &type_definition.node.description,
+                &type_definition.node.directives,
+            )
+            .some(),
             TypeKind::Union(_) => Valid::none(),
             TypeKind::Scalar => Valid::succeed(Some(to_scalar_type())),
         }
@@ -252,11 +255,15 @@ where
 }
 fn to_input_object(
     input_object_type: InputObjectType,
+    description: &Option<Positioned<String>>,
     directives: &[Positioned<ConstDirective>],
 ) -> Valid<config::Type, String> {
     to_input_object_fields(&input_object_type.fields)
         .fuse(Protected::from_directives(directives.iter()))
-        .map(|(fields, protected)| config::Type { fields, protected, ..Default::default() })
+        .map(|(fields, protected)| {
+            let doc = description.to_owned().map(|pos| pos.node);
+            config::Type { fields, protected, doc, ..Default::default() }
+        })
 }
 
 fn to_fields_inner<T, F>(

src/core/config/into_document.rs

@@ -190,7 +190,7 @@ fn config_document(config: &ConfigModule) -> ServiceDocument {
         };
         definitions.push(TypeSystemDefinition::Type(pos(TypeDefinition {
             extend: false,
-            description: None,
+            description: type_def.doc.clone().map(pos),
             name: pos(Name::new(type_name.clone())),
             directives: type_def
                 .added_fields

src/core/document.rs

@@ -92,8 +92,12 @@ fn print_type_def(type_def: &TypeDefinition) -> String {
         }
         TypeKind::InputObject(input) => {
             let directives = print_directives(&type_def.directives);
+            let doc = type_def.description.as_ref().map_or(String::new(), |d| {
+                format!(r#"  """{}  {}{}  """{}"#, "\n", d.node, "\n", "\n")
+            });
             format!(
-                "input {} {}{{\n{}\n}}\n",
+                "{}input {} {}{{\n{}\n}}\n",
+                doc,
                 type_def.name.node,
                 directives,
                 input
@@ -145,8 +149,12 @@ fn print_type_def(type_def: &TypeDefinition) -> String {
                 String::new()
             };
             let directives = print_directives(&type_def.directives);
+            let doc = type_def.description.as_ref().map_or(String::new(), |d| {
+                format!(r#"  """{}  {}{}  """{}"#, "\n", d.node, "\n", "\n")
+            });
             format!(
-                "type {} {}{}{{\n{}\n}}\n",
+                "{}type {} {}{}{{\n{}\n}}\n",
+                doc,
                 type_def.name.node,
                 implements,
                 directives,
@@ -209,7 +217,13 @@ fn print_field(field: &async_graphql::parser::types::FieldDefinition) -> String
 
 fn print_input_value(field: &async_graphql::parser::types::InputValueDefinition) -> String {
     let directives_str = print_directives(&field.directives);
-    format!("  {}: {}{}", field.name.node, field.ty.node, directives_str)
+    let doc = field.description.as_ref().map_or(String::new(), |d| {
+        format!(r#"  """{}  {}{}  """{}"#, "\n", d.node, "\n", "\n")
+    });
+    format!(
+        "{}  {}: {}{}",
+        doc, field.name.node, field.ty.node, directives_str
+    )
 }
 fn print_directive(directive: &DirectiveDefinition) -> String {
     let args = directive

tests/core/snapshots/test-input-documentation.md_client.snap

@@ -0,0 +1,48 @@
+---
+source: tests/core/spec.rs
+assertion_line: 278
+expression: formatted
+---
+scalar Date
+
+scalar Email
+
+scalar Empty
+
+"""
+Test input documentation
+"""
+input Foo {
+  """
+  Test input field documentation
+  """
+  id: Int
+}
+
+scalar JSON
+
+type Mutation {
+  testDocumentation(input: Foo!): Post
+}
+
+scalar PhoneNumber
+
+type Post {
+  body: String
+  id: Int!
+}
+
+"""
+Some Documentation
+"""
+type Query {
+  foo: String
+  postFromFoo(id: Int!): Post
+}
+
+scalar Url
+
+schema {
+  query: Query
+  mutation: Mutation
+}

tests/core/snapshots/test-input-documentation.md_merged.snap

@@ -0,0 +1,36 @@
+---
+source: tests/core/spec.rs
+assertion_line: 235
+expression: formatter
+---
+schema @server @upstream(baseURL: "http://jsonplaceholder.typicode.com") {
+  query: Query
+  mutation: Mutation
+}
+
+"""
+Test input documentation
+"""
+input Foo {
+  """
+  Test input field documentation
+  """
+  id: Int
+}
+
+type Mutation {
+  testDocumentation(input: Foo!): Post @http(body: "{{.args.input}}", method: "POST", path: "/posts")
+}
+
+type Post {
+  body: String
+  id: Int!
+}
+
+"""
+Some Documentation
+"""
+type Query {
+  foo: String @http(path: "/foo")
+  postFromFoo(id: Int!): Post @http(path: "/posts?id={{.args.id}}")
+}

tests/execution/test-input-documentation.md

@@ -0,0 +1,39 @@
+---
+identity: true
+---
+
+# test-input-type-documentation
+
+```graphql @config
+schema @server @upstream(baseURL: "http://jsonplaceholder.typicode.com") {
+  query: Query
+  mutation: Mutation
+}
+
+"""
+Test input documentation
+"""
+input Foo {
+  """
+  Test input field documentation
+  """
+  id: Int
+}
+
+type Mutation {
+  testDocumentation(input: Foo!): Post @http(body: "{{.args.input}}", method: "POST", path: "/posts")
+}
+
+type Post {
+  body: String
+  id: Int!
+}
+
+"""
+Some Documentation
+"""
+type Query {
+  foo: String @http(path: "/foo")
+  postFromFoo(id: Int!): Post @http(path: "/posts?id={{.args.id}}")
+}
+```