Support recursive fragments

Author: tomhoule

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());

graphql_client_codegen/src/interfaces.rs

@@ -34,59 +34,53 @@ impl<'schema> GqlInterface<'schema> {
         selection: &'query Selection<'query>,
         query_context: &QueryContext,
     ) -> Selection<'query> {
-        Selection(
-            selection
-                .0
-                .iter()
-                // Only keep what we can handle
-                .filter(|f| match f {
-                    SelectionItem::Field(f) => f.name != TYPENAME_FIELD,
-                    SelectionItem::FragmentSpread(SelectionFragmentSpread { fragment_name }) => {
-                        // only if the fragment refers to the interface’s own fields (to take into account type-refining fragments)
-                        let fragment = query_context
-                            .fragments
-                            .get(fragment_name)
-                            .ok_or_else(|| format_err!("Unknown fragment: {}", &fragment_name))
-                            // TODO: fix this
-                            .unwrap();
+        (&selection)
+            .into_iter()
+            // Only keep what we can handle
+            .filter(|f| match f {
+                SelectionItem::Field(f) => f.name != TYPENAME_FIELD,
+                SelectionItem::FragmentSpread(SelectionFragmentSpread { fragment_name }) => {
+                    // only if the fragment refers to the interface’s own fields (to take into account type-refining fragments)
+                    let fragment = query_context
+                        .fragments
+                        .get(fragment_name)
+                        .ok_or_else(|| format_err!("Unknown fragment: {}", &fragment_name))
+                        // TODO: fix this
+                        .unwrap();
 
-                        fragment.on == self.name
-                    }
-                    SelectionItem::InlineFragment(_) => false,
-                })
-                .map(|a| (*a).clone())
-                .collect(),
-        )
+                    fragment.on.name() == self.name
+                }
+                SelectionItem::InlineFragment(_) => false,
+            })
+            .map(|a| (*a).clone())
+            .collect()
     }
 
     fn union_selection<'query>(
         &self,
         selection: &'query Selection,
         query_context: &QueryContext,
     ) -> Selection<'query> {
-        Selection(
-            selection
-                .0
-                .iter()
-                // Only keep what we can handle
-                .filter(|f| match f {
-                    SelectionItem::InlineFragment(_) => true,
-                    SelectionItem::FragmentSpread(SelectionFragmentSpread { fragment_name }) => {
-                        let fragment = query_context
-                            .fragments
-                            .get(fragment_name)
-                            .ok_or_else(|| format_err!("Unknown fragment: {}", &fragment_name))
-                            // TODO: fix this
-                            .unwrap();
+        (&selection)
+            .into_iter()
+            // Only keep what we can handle
+            .filter(|f| match f {
+                SelectionItem::InlineFragment(_) => true,
+                SelectionItem::FragmentSpread(SelectionFragmentSpread { fragment_name }) => {
+                    let fragment = query_context
+                        .fragments
+                        .get(fragment_name)
+                        .ok_or_else(|| format_err!("Unknown fragment: {}", &fragment_name))
+                        // TODO: fix this
+                        .unwrap();
 
-                        // only the fragments _not_ on the interface
-                        fragment.on != self.name
-                    }
-                    SelectionItem::Field(SelectionField { name, .. }) => *name == "__typename",
-                })
-                .map(|a| (*a).clone())
-                .collect(),
-        )
+                    // only the fragments _not_ on the interface
+                    fragment.on.name() != self.name
+                }
+                SelectionItem::Field(SelectionField { name, .. }) => *name == "__typename",
+            })
+            .map(|a| (*a).clone())
+            .collect()
     }
 
     /// Create an empty interface. This needs to be mutated before it is useful.
@@ -227,13 +221,13 @@ mod tests {
         let typename_field = ::selection::SelectionItem::Field(::selection::SelectionField {
             alias: None,
             name: "__typename",
-            fields: Selection(vec![]),
+            fields: Selection::new_empty(),
         });
-        let selection = Selection(vec![typename_field.clone()]);
+        let selection = Selection::from_vec(vec![typename_field.clone()]);
 
         assert_eq!(
             iface.union_selection(&selection, &context),
-            Selection(vec![typename_field])
+            Selection::from_vec(vec![typename_field])
         );
     }
 
@@ -254,13 +248,13 @@ mod tests {
         let typename_field = ::selection::SelectionItem::Field(::selection::SelectionField {
             alias: None,
             name: "__typename",
-            fields: Selection(vec![]),
+            fields: Selection::new_empty(),
         });
-        let selection = Selection(vec![typename_field]);
+        let selection: Selection = vec![typename_field].into_iter().collect();
 
         assert_eq!(
             iface.object_selection(&selection, &context),
-            Selection(vec![])
+            Selection::new_empty()
         );
     }
 }