Use selection ids to resolve selections

Author: tomhoule

graphql_client/tests/union_query.rs

@@ -32,21 +32,19 @@ fn union_query_deserialization() {
 
     let expected = union_query::ResponseData {
         names: Some(vec![
-            union_query::UnionQueryNames::Person(union_query::UnionQueryNamesOnPerson {
+            union_query::UnionQueryNames::Person {
                 first_name: "Audrey".to_string(),
                 last_name: Some("Lorde".to_string()),
-            }),
-            union_query::UnionQueryNames::Dog(union_query::UnionQueryNamesOnDog {
+            },
+            union_query::UnionQueryNames::Dog {
                 name: "Laïka".to_string(),
-            }),
-            union_query::UnionQueryNames::Organization(
-                union_query::UnionQueryNamesOnOrganization {
-                    title: "Mozilla".to_string(),
-                },
-            ),
-            union_query::UnionQueryNames::Dog(union_query::UnionQueryNamesOnDog {
+            },
+            union_query::UnionQueryNames::Organization {
+                title: "Mozilla".to_string(),
+            },
+            union_query::UnionQueryNames::Dog {
                 name: "Norbert".to_string(),
-            }),
+            },
         ]),
     };
 
@@ -61,27 +59,25 @@ fn fragment_on_union() {
 
     let expected = fragment_on_union::ResponseData {
         names: Some(vec![
-            fragment_on_union::FragmentOnUnionNames::Person(
-                fragment_on_union::FragmentOnUnionNamesOnPerson {
+            fragment_on_union::FragmentOnUnionNames {
+                names_fragment: fragment_on_union::NamesFragment::Person {
                     first_name: "Audrey".to_string(),
                 },
-            ),
-            fragment_on_union::FragmentOnUnionNames::Dog(
-                fragment_on_union::FragmentOnUnionNamesOnDog {
+            },
+            fragment_on_union::FragmentOnUnionNames {
+                names_fragment: fragment_on_union::NamesFragment::Dog {
                     name: "Laïka".to_string(),
                 },
-            ),
-            fragment_on_union::FragmentOnUnionNames::Organization(
-                fragment_on_union::FragmentOnUnionNamesOnOrganization {
+            },
+            fragment_on_union::FragmentOnUnionNames {
+                names_fragment: fragment_on_union::NamesFragment::Organization {
                     title: "Mozilla".to_string(),
                 },
-            ),
+            },
             fragment_on_union::FragmentOnUnionNames {
-                names_fragment: fragment_on_union::NamesFragment::Dog(
-                    fragment_on_union::NamesFragmentOnDog {
-                        name: "Norbert".to_string(),
-                    },
-                ),
+                names_fragment: fragment_on_union::NamesFragment::Dog {
+                    name: "Norbert".to_string(),
+                },
             },
         ]),
     };
@@ -91,5 +87,21 @@ fn fragment_on_union() {
 
 #[test]
 fn fragment_and_more_on_union() {
-    todo!()
+    let _expected = fragment_and_more_on_union::ResponseData {
+        names: Some(vec![
+            fragment_and_more_on_union::FragmentAndMoreOnUnionNames::Person {
+                first_name: "Audrey".to_string(),
+                last_name: Some("Lorde".to_string()),
+            },
+            fragment_and_more_on_union::FragmentAndMoreOnUnionNames::Dog {
+                name: "Laïka".to_string(),
+            },
+            fragment_and_more_on_union::FragmentAndMoreOnUnionNames::Organization {
+                title: "Mozilla".to_string(),
+            },
+            fragment_and_more_on_union::FragmentAndMoreOnUnionNames::Dog {
+                name: "Norbert".to_string(),
+            },
+        ]),
+    };
 }

graphql_client_codegen/src/codegen.rs

@@ -244,7 +244,8 @@ fn render_response_data_fields<'a>(
     let mut variants = Vec::new();
 
     render_selection(
-        operation.selection(),
+        operation.refocus(()),
+        operation.selection_ids(),
         &mut fields,
         &mut variants,
         &mut response_types,
@@ -256,7 +257,8 @@ fn render_response_data_fields<'a>(
 }
 
 fn render_selection<'a>(
-    selection: impl Iterator<Item = WithQuery<'a, SelectionId>>,
+    q: WithQuery<'a, ()>,
+    selection: &[SelectionId],
     field_buffer: &mut Vec<TokenStream>,
     variants_buffer: &mut Vec<TokenStream>,
     response_type_buffer: &mut Vec<TokenStream>,
@@ -266,9 +268,9 @@ fn render_selection<'a>(
     // TODO: if the selection has one item, we can sometimes generate fewer structs (e.g. single fragment spread)
 
     for select in selection {
-        match &select.get() {
+        match q.refocus(*select).get() {
             Selection::Field(field) => {
-                let field = select.refocus(field);
+                let field = q.refocus(field);
 
                 let deprecation_annotation = match (
                     field.schema_field().is_deprecated(),
@@ -305,7 +307,7 @@ fn render_selection<'a>(
                         field_buffer.push(quote!(#deprecation_annotation #ident: #type_name));
                     }
                     TypeId::Object(_) | TypeId::Interface(_) => {
-                        let struct_name_string = select.full_path_prefix();
+                        let struct_name_string = q.refocus(*select).full_path_prefix();
                         let struct_name = Ident::new(&struct_name_string, Span::call_site());
                         let field_type =
                             decorate_type(&struct_name, field.schema_field().type_qualifiers());
@@ -315,7 +317,8 @@ fn render_selection<'a>(
                         let mut fields = Vec::new();
                         let mut variants = Vec::new();
                         render_selection(
-                            select.subselection(),
+                            q,
+                            q.refocus(*select).subselection_ids(),
                             &mut fields,
                             &mut variants,
                             response_type_buffer,
@@ -338,7 +341,7 @@ fn render_selection<'a>(
                         // We want a struct, because we want to preserve fragments in the output,
                         // and there can be fragment and inline spreads for a given selection set
                         // on an enum.
-                        let struct_name = select.full_path_prefix();
+                        let struct_name = q.refocus(*select).full_path_prefix();
                         let struct_name_ident = Ident::new(&struct_name, Span::call_site());
                         let field_type = decorate_type(
                             &struct_name_ident,
@@ -350,21 +353,18 @@ fn render_selection<'a>(
                         let mut fields = Vec::new();
                         let mut variants = Vec::new();
                         render_selection(
-                            select.subselection(),
+                            q,
+                            q.refocus(*select).subselection_ids(),
                             &mut fields,
                             &mut variants,
                             response_type_buffer,
                             response_derives,
                             options,
                         );
 
-                        let struct_definition = render_object_like_struct(
-                            response_derives,
-                            &struct_name,
-                            &fields,
-                            &variants,
-                        );
-                        response_type_buffer.push(struct_definition);
+                        let enum_definition =
+                            render_union_enum(response_derives, &struct_name, &variants);
+                        response_type_buffer.push(enum_definition);
                     }
                     TypeId::Input(_) => unreachable!("field selection on input type"),
                 };
@@ -376,29 +376,46 @@ fn render_selection<'a>(
                 ));
             }
             Selection::InlineFragment(inline) => {
-                let variant_name = select.refocus(inline).on().name();
-                let variant_name = Ident::new(variant_name, Span::call_site());
-                let variant_struct_name = select.full_path_prefix();
-                let variant_struct_name = Ident::new(&variant_struct_name, Span::call_site());
-
-                let variant = quote!(#variant_name(#variant_struct_name));
-                variants_buffer.push(variant);
+                let variant_name_str = q.refocus(inline).on().name();
+                let variant_name = Ident::new(variant_name_str, Span::call_site());
+                let variant_struct_name_str = q.refocus(*select).full_path_prefix();
+                let variant_struct_name = Ident::new(&variant_struct_name_str, Span::call_site());
 
                 // Render the struct for the selection
 
-                todo!("We have to do more here");
+                let mut fields = Vec::new();
+                let mut variants = Vec::new();
 
                 render_selection(
-                    select.subselection(),
+                    q,
+                    q.refocus(*select).subselection_ids(),
                     &mut fields,
                     &mut variants,
                     response_type_buffer,
                     response_derives,
                     options,
                 );
+
+                let variant = quote!(#variant_name { });
+                variants_buffer.push(variant);
+
+                match q.refocus(inline).on().item {
+                    TypeId::Object(_) | TypeId::Interface(_) => {
+                        let struct_definition = render_object_like_struct(
+                            response_derives,
+                            &variant_struct_name_str,
+                            &fields,
+                            &variants,
+                        );
+
+                        response_type_buffer.push(struct_definition);
+                    }
+                    TypeId::Union(_) => todo!("inline fragment on union"),
+                    other => unreachable!("Inline fragment on non composite type ({:?})", other),
+                }
             }
             Selection::FragmentSpread(frag) => {
-                let frag = select.refocus(*frag);
+                let frag = q.refocus(*frag);
                 let original_field_name = frag.name().to_snake_case();
                 let final_field_name = keyword_replace(&original_field_name);
                 let annotation = field_rename_annotation(&original_field_name, &final_field_name);
@@ -494,7 +511,8 @@ fn generate_fragment_definitions(
         let mut variants = Vec::new();
 
         render_selection(
-            fragment.selection(),
+            fragment.refocus(()),
+            fragment.selection_ids(),
             &mut fields,
             &mut variants,
             &mut response_type_buffer,

graphql_client_codegen/src/resolution.rs

@@ -136,6 +136,10 @@ impl<'a> SelectionRef<'a> {
             .map(move |s| self.refocus(*s))
     }
 
+    pub(crate) fn subselection_ids(&self) -> &'a [SelectionId] {
+        self.get().subselection()
+    }
+
     pub(crate) fn collect_used_types(&self, used_types: &mut UsedTypes) {
         let selection = self.get();
         match selection {
@@ -640,6 +644,10 @@ impl<'a> OperationRef<'a> {
             .map(move |selection_id| self.refocus(*selection_id))
     }
 
+    pub(crate) fn selection_ids(&self) -> &[SelectionId] {
+        &self.get().selection
+    }
+
     pub(crate) fn variables<'b>(&'b self) -> impl Iterator<Item = VariableRef<'a>> + 'b {
         self.query
             .variables
@@ -722,6 +730,10 @@ impl<'a> FragmentRef<'a> {
             .map(move |item| self.refocus(*item))
     }
 
+    pub(crate) fn selection_ids(&self) -> &[SelectionId] {
+        &self.get().selection
+    }
+
     fn to_path_segment(&self) -> String {
         self.get().name.to_camel_case()
     }