Merge pull request #211 from graphql-rust/recursive-fragments

Support recursive fragments

Author: tomhoule

CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## Unreleased
 
+### Added
+
+- If there is no `schema` declaration in a schema, the root types will be matched by name (`Query`, `Mutation` and `Subscription`).
+
+### Changed
+
+- Enums now always derive PartialEq and Eq by default
+
+### Fixed
+
+- Code generation for fragments on unions was fixed
+- Support for recursive fragments and input types
+- The graphql-parser dependency version is no longer pinned
+
 ## 0.6.0 (2018-12-30)
 
 ### Added

graphql_client/tests/fragments.rs

@@ -55,3 +55,25 @@ fn fragments_with_snake_case_name() {
         "value"
     );
 }
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    query_path = "tests/fragments/query.graphql",
+    schema_path = "tests/fragments/schema.graphql"
+)]
+pub struct RecursiveFragmentQuery;
+
+#[test]
+fn recursive_fragment() {
+    use recursive_fragment_query::*;
+
+    let _ = RecursiveFragment {
+        head: Some("ABCD".to_string()),
+        tail: Some(RecursiveFragmentTail {
+            recursive_fragment: Box::new(RecursiveFragment {
+                head: Some("EFGH".to_string()),
+                tail: None,
+            }),
+        }),
+    };
+}

graphql_client/tests/fragments/query.graphql

@@ -6,10 +6,23 @@ fragment snake_case_fragment on QueryRoot {
   inFragment
 }
 
+fragment RecursiveFragment on RecursiveNode {
+  head
+  tail {
+    ...RecursiveFragment
+  }
+}
+
 query FragmentReference {
   ...FragmentReference
 }
 
 query SnakeCaseFragment {
   ...snake_case_fragment
 }
+
+query RecursiveFragmentQuery {
+  recursive {
+    ...RecursiveFragment
+  }
+}

graphql_client/tests/fragments/schema.graphql

@@ -2,7 +2,13 @@ schema {
   query: QueryRoot
 }
 
+type RecursiveNode {
+  head: String
+  tail: RecursiveNode
+}
+
 type QueryRoot {
   extra: String
   inFragment: String
+  recursive: RecursiveNode!
 }

graphql_client/tests/input_object_variables.rs

@@ -74,3 +74,29 @@ fn recursive_input_objects_can_be_constructed() {
         })),
     };
 }
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    query_path = "tests/input_object_variables/input_object_variables_query.graphql",
+    schema_path = "tests/input_object_variables/input_object_variables_schema.graphql",
+    response_derives = "Debug, PartialEq"
+)]
+pub struct IndirectlyRecursiveInputQuery;
+
+#[test]
+fn indirectly_recursive_input_objects_can_be_constructed() {
+    use indirectly_recursive_input_query::*;
+
+    IndirectlyRecursiveInput {
+        head: "hello".to_string(),
+        tail: Box::new(None),
+    };
+
+    IndirectlyRecursiveInput {
+        head: "hi".to_string(),
+        tail: Box::new(Some(IndirectlyRecursiveInputTailPart {
+            name: "this is crazy".to_string(),
+            recursed_field: Box::new(None),
+        })),
+    };
+}

graphql_client/tests/input_object_variables/input_object_variables_query.graphql

@@ -7,3 +7,7 @@ query VariablesQuery($msg: Message) {
 query RecursiveInputQuery($input: RecursiveInput!) {
   saveRecursiveInput(recursiveInput: $input)
 }
+
+query IndirectlyRecursiveInputQuery($input: IndirectlyRecursiveInput!) {
+  saveRecursiveInput(recursiveInput: $input)
+}

graphql_client/tests/input_object_variables/input_object_variables_schema.graphql

@@ -29,6 +29,16 @@ input RecursiveInput {
   tail: RecursiveInput
 }
 
+input IndirectlyRecursiveInput {
+  head: String!
+  tail: IndirectlyRecursiveInputTailPart
+}
+
+input IndirectlyRecursiveInputTailPart {
+  name: String!
+  recursed_field: IndirectlyRecursiveInput
+}
+
 type InputObjectVariablesQuery {
   echo(message: Message!, options: Options = { pgpSignature: true }): EchoResult
   saveRecursiveInput(recursiveInput: RecursiveInput!): Category

graphql_client_codegen/src/codegen.rs

@@ -55,6 +55,13 @@ pub(crate) fn response_for_query(
             query::Definition::Operation(_op) => (),
             query::Definition::Fragment(fragment) => {
                 let &query::TypeCondition::On(ref on) = &fragment.type_condition;
+                let on = schema.fragment_target(on).ok_or_else(|| {
+                    format_err!(
+                        "Fragment {} is defined on unknown type: {}",
+                        &fragment.name,
+                        on,
+                    )
+                })?;
                 context.fragments.insert(
                     &fragment.name,
                     GqlFragment {
@@ -82,7 +89,7 @@ pub(crate) fn response_for_query(
         let prefix = &operation.name;
         let selection = &operation.selection;
 
-        if operation.is_subscription() && selection.0.len() > 1 {
+        if operation.is_subscription() && selection.len() > 1 {
             Err(format_err!(
                 "{}",
                 ::constants::MULTIPLE_SUBSCRIPTION_FIELDS_ERROR

graphql_client_codegen/src/fragments.rs

@@ -3,13 +3,31 @@ use query::QueryContext;
 use selection::Selection;
 use std::cell::Cell;
 
+/// Represents which type a fragment is defined on. This is the type mentioned in the fragment's `on` clause.
+#[derive(Debug, PartialEq)]
+pub(crate) enum FragmentTarget<'context> {
+    Object(&'context crate::objects::GqlObject<'context>),
+    Interface(&'context crate::interfaces::GqlInterface<'context>),
+    Union(&'context crate::unions::GqlUnion<'context>),
+}
+
+impl<'context> FragmentTarget<'context> {
+    pub(crate) fn name(&self) -> &str {
+        match self {
+            FragmentTarget::Object(obj) => obj.name,
+            FragmentTarget::Interface(iface) => iface.name,
+            FragmentTarget::Union(unn) => unn.name,
+        }
+    }
+}
+
 /// Represents a fragment extracted from a query document.
 #[derive(Debug, PartialEq)]
 pub(crate) struct GqlFragment<'query> {
     /// The name of the fragment, matching one-to-one with the name in the GraphQL query document.
     pub name: &'query str,
     /// The `on` clause of the fragment.
-    pub on: &'query str,
+    pub on: FragmentTarget<'query>,
     /// The selected fields.
     pub selection: Selection<'query>,
     /// Whether the fragment is used in the current query
@@ -19,16 +37,20 @@ pub(crate) struct GqlFragment<'query> {
 impl<'query> GqlFragment<'query> {
     /// Generate all the Rust code required by the fragment's object selection.
     pub(crate) fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, ::failure::Error> {
-        if let Some(obj) = context.schema.objects.get(&self.on) {
-            obj.response_for_selection(context, &self.selection, &self.name)
-        } else if let Some(iface) = context.schema.interfaces.get(&self.on) {
-            iface.response_for_selection(context, &self.selection, &self.name)
-        } else {
-            Err(format_err!(
-                "Fragment {} is defined on unknown type: {}",
-                self.name,
-                self.on
-            ))?
+        match self.on {
+            FragmentTarget::Object(obj) => {
+                obj.response_for_selection(context, &self.selection, &self.name)
+            }
+            FragmentTarget::Interface(iface) => {
+                iface.response_for_selection(context, &self.selection, &self.name)
+            }
+            FragmentTarget::Union(_) => {
+                unreachable!("Wrong code path. Fragment on unions are treated differently.")
+            }
         }
     }
+
+    pub(crate) fn is_recursive(&self) -> bool {
+        self.selection.contains_fragment(&self.name)
+    }
 }

graphql_client_codegen/src/inputs.rs

@@ -30,6 +30,36 @@ impl<'schema> GqlInput<'schema> {
         })
     }
 
+    fn contains_type_without_indirection(&self, context: &QueryContext, type_name: &str) -> bool {
+        // the input type is recursive if any of its members contains it, without indirection
+        self.fields.values().any(|field| {
+            // the field is indirected, so no boxing is needed
+            if field.type_.is_indirected() {
+                return false;
+            }
+
+            let field_type_name = field.type_.inner_name_str();
+            let input = context.schema.inputs.get(field_type_name);
+
+            if let Some(input) = input {
+                // the input contains itself, not indirected
+                if input.name == type_name {
+                    return true;
+                }
+
+                // we check if the other input contains this one (without indirection)
+                input.contains_type_without_indirection(context, type_name)
+            } else {
+                // the field is not referring to an input type
+                false
+            }
+        })
+    }
+
+    fn is_recursive_without_indirection(&self, context: &QueryContext) -> bool {
+        self.contains_type_without_indirection(context, &self.name)
+    }
+
     pub(crate) fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, failure::Error> {
         let name = Ident::new(&self.name, Span::call_site());
         let mut fields: Vec<&GqlObjectField> = self.fields.values().collect();
@@ -38,10 +68,14 @@ impl<'schema> GqlInput<'schema> {
             let ty = field.type_.to_rust(&context, "");
 
             // If the type is recursive, we have to box it
-            let ty = if field.type_.is_indirected() || field.type_.inner_name_str() != self.name {
-                ty
+            let ty = if let Some(input) = context.schema.inputs.get(field.type_.inner_name_str()) {
+                if input.is_recursive_without_indirection(context) {
+                    quote! { Box<#ty> }
+                } else {
+                    quote!(#ty)
+                }
             } else {
-                quote! { Box<#ty> }
+                quote!(#ty)
             };
 
             context.schema.require(&field.type_.inner_name_str());