feat(selection): support @include and @Skip on fragment spreads

Author: KonstantinSimeonov

graphql_client_codegen/src/codegen/selection.rs

@@ -92,6 +92,7 @@ fn calculate_custom_response_type_selection<'a>(
         name: custom_response_type.as_str(),
         struct_id,
         boxed: false,
+        has_skip_or_include: false
     });
 }
 
@@ -128,7 +129,7 @@ pub(super) fn render_fragment<'a>(
 /// A sub-selection set (spread) on one of the variants of a union or interface.
 enum VariantSelection<'a> {
     InlineFragment(&'a InlineFragment),
-    FragmentSpread((ResolvedFragmentId, &'a ResolvedFragment)),
+    FragmentSpread((ResolvedFragmentId, &'a ResolvedFragment), bool),
 }
 
 impl<'a> VariantSelection<'a> {
@@ -142,15 +143,15 @@ impl<'a> VariantSelection<'a> {
             Selection::InlineFragment(inline_fragment) => {
                 Some(VariantSelection::InlineFragment(inline_fragment))
             }
-            Selection::FragmentSpread(fragment_id) => {
+            Selection::FragmentSpread(fragment_id, has_skip_or_include) => {
                 let fragment = query.query.get_fragment(*fragment_id);
 
                 if fragment.on == type_id {
                     // The selection is on the type itself.
                     None
                 } else {
                     // The selection is on one of the variants of the type.
-                    Some(VariantSelection::FragmentSpread((*fragment_id, fragment)))
+                    Some(VariantSelection::FragmentSpread((*fragment_id, fragment), *has_skip_or_include))
                 }
             }
             Selection::Field(_) | Selection::Typename => None,
@@ -160,7 +161,7 @@ impl<'a> VariantSelection<'a> {
     fn variant_type_id(&self) -> TypeId {
         match self {
             VariantSelection::InlineFragment(f) => f.type_id,
-            VariantSelection::FragmentSpread((_id, f)) => f.on,
+            VariantSelection::FragmentSpread((_id, f), _) => f.on,
         }
     }
 }
@@ -175,14 +176,15 @@ fn calculate_selection<'a>(
     // If the selection only contains a fragment, replace the selection with
     // that fragment.
     if selection_set.len() == 1 {
-        if let Selection::FragmentSpread(fragment_id) =
+        if let Selection::FragmentSpread(fragment_id, has_skip_or_include) =
             context.query.query.get_selection(selection_set[0])
         {
             let fragment = context.query.query.get_fragment(*fragment_id);
             context.push_type_alias(TypeAlias {
                 name: &fragment.name,
                 struct_id,
                 boxed: fragment_is_recursive(*fragment_id, context.query.query),
+                has_skip_or_include: *has_skip_or_include
             });
             return;
         }
@@ -253,13 +255,14 @@ fn calculate_selection<'a>(
                     let struct_id = context.push_type(expanded_type);
 
                     if variant_selections.len() == 1 {
-                        if let VariantSelection::FragmentSpread((fragment_id, fragment)) =
+                        if let VariantSelection::FragmentSpread((fragment_id, fragment), has_skip_or_include) =
                             variant_selections[0].2
                         {
                             context.push_type_alias(TypeAlias {
                                 boxed: fragment_is_recursive(fragment_id, context.query.query),
                                 name: &fragment.name,
                                 struct_id,
+                                has_skip_or_include
                             });
                             continue;
                         }
@@ -276,7 +279,7 @@ fn calculate_selection<'a>(
                                     options,
                                 );
                             }
-                            VariantSelection::FragmentSpread((fragment_id, fragment)) => context
+                            VariantSelection::FragmentSpread((fragment_id, fragment), has_skip_or_include) => context
                                 .push_field(ExpandedField {
                                     field_type: fragment.name.as_str().into(),
                                     field_type_qualifiers: &[GraphqlTypeQualifier::Required],
@@ -286,8 +289,7 @@ fn calculate_selection<'a>(
                                     struct_id,
                                     deprecation: None,
                                     boxed: fragment_is_recursive(*fragment_id, context.query.query),
-                                    // TODO
-                                    skip_or_include: false
+                                    skip_or_include: *has_skip_or_include
                                 }),
                         }
                     }
@@ -387,7 +389,7 @@ fn calculate_selection<'a>(
             }
             Selection::Typename => (),
             Selection::InlineFragment(_inline) => (),
-            Selection::FragmentSpread(fragment_id) => {
+            Selection::FragmentSpread(fragment_id, has_skip_or_include) => {
                 // Here we only render fragments that are directly on the type
                 // itself, and not on one of its variants.
 
@@ -413,7 +415,7 @@ fn calculate_selection<'a>(
                     flatten: true,
                     deprecation: None,
                     boxed: fragment_is_recursive(*fragment_id, context.query.query),
-                    skip_or_include: false
+                    skip_or_include: *has_skip_or_include
                 });
 
                 // We stop here, because the structs for the fragments are generated separately, to
@@ -430,6 +432,7 @@ struct TypeAlias<'a> {
     name: &'a str,
     struct_id: ResponseTypeId,
     boxed: bool,
+    has_skip_or_include: bool
 }
 
 struct ExpandedField<'a> {

graphql_client_codegen/src/query.rs

@@ -18,6 +18,7 @@ use crate::{
         StoredInputType, StoredScalar, TypeId, UnionId,
     },
 };
+use graphql_parser::query::Directive;
 use std::{
     collections::{BTreeMap, BTreeSet},
     fmt::Display,
@@ -279,7 +280,13 @@ where
                         ))
                     })?;
 
-                let id = query.push_selection(Selection::FragmentSpread(fragment_id), parent);
+                let id = query.push_selection(
+                    Selection::FragmentSpread(
+                        fragment_id,
+                        has_skip_or_include(fragment_spread.directives.as_slice()),
+                    ),
+                    parent,
+                );
 
                 parent.add_to_selection_set(query, id);
             }
@@ -318,17 +325,12 @@ where
                         ))
                     })?;
 
-                let has_skip_or_include = field
-                    .directives
-                    .iter()
-                    .any(|directive| ["skip", "include"].contains(&directive.name.as_ref()));
-
                 let id = query.push_selection(
                     Selection::Field(SelectedField {
                         alias: field.alias.as_ref().map(|alias| alias.as_ref().into()),
                         field_id,
                         selection_set: Vec::with_capacity(selection_set.items.len()),
-                        skip_or_include: has_skip_or_include
+                        skip_or_include: has_skip_or_include(field.directives.as_slice()),
                     }),
                     parent,
                 );
@@ -358,7 +360,13 @@ where
                         ))
                     })?;
 
-                let id = query.push_selection(Selection::FragmentSpread(fragment_id), parent);
+                let id = query.push_selection(
+                    Selection::FragmentSpread(
+                        fragment_id,
+                        has_skip_or_include(fragment_spread.directives.as_slice()),
+                    ),
+                    parent,
+                );
 
                 parent.add_to_selection_set(query, id);
             }
@@ -368,6 +376,15 @@ where
     Ok(())
 }
 
+fn has_skip_or_include<'doc, T>(directives: &[Directive<'doc, T>]) -> bool
+where
+    T: graphql_parser::query::Text<'doc>,
+{
+    directives
+        .iter()
+        .any(|directive| ["skip", "include"].contains(&directive.name.as_ref()))
+}
+
 fn resolve_selection<'doc, T>(
     ctx: &mut Query,
     on: TypeId,
@@ -731,7 +748,7 @@ pub(crate) fn all_used_types(operation_id: OperationId, query: &BoundQuery<'_>)
 
 pub(crate) fn full_path_prefix(selection_id: SelectionId, query: &BoundQuery<'_>) -> String {
     let mut path = match query.query.get_selection(selection_id) {
-        Selection::FragmentSpread(_) | Selection::InlineFragment(_) => Vec::new(),
+        Selection::FragmentSpread(..) | Selection::InlineFragment(_) => Vec::new(),
         selection => vec![selection.to_path_segment(query)],
     };
 

graphql_client_codegen/src/query/selection.rs

@@ -14,7 +14,7 @@ pub(super) fn validate_type_conditions(
     let selection = query.query.get_selection(selection_id);
 
     let selected_type = match selection {
-        Selection::FragmentSpread(fragment_id) => query.query.get_fragment(*fragment_id).on,
+        Selection::FragmentSpread(fragment_id, _) => query.query.get_fragment(*fragment_id).on,
         Selection::InlineFragment(inline_fragment) => inline_fragment.type_id,
         _ => return Ok(()),
     };
@@ -146,7 +146,7 @@ impl SelectionParent {
 pub(crate) enum Selection {
     Field(SelectedField),
     InlineFragment(InlineFragment),
-    FragmentSpread(ResolvedFragmentId),
+    FragmentSpread(ResolvedFragmentId, bool),
     Typename,
 }
 
@@ -184,7 +184,7 @@ impl Selection {
                     selection.collect_used_types(used_types, query);
                 }
             }
-            Selection::FragmentSpread(fragment_id) => {
+            Selection::FragmentSpread(fragment_id, _) => {
                 // This is necessary to avoid infinite recursion.
                 if used_types.fragments.contains(fragment_id) {
                     return;
@@ -204,7 +204,7 @@ impl Selection {
 
     pub(crate) fn contains_fragment(&self, fragment_id: ResolvedFragmentId, query: &Query) -> bool {
         match self {
-            Selection::FragmentSpread(id) => *id == fragment_id,
+            Selection::FragmentSpread(id, _) => *id == fragment_id,
             _ => self.subselection().iter().any(|selection_id| {
                 query
                     .get_selection(*selection_id)

graphql_client_codegen/src/query/validation.rs

@@ -56,7 +56,7 @@ fn selection_set_contains_type_name(
 
         match selection {
             Selection::Typename => return true,
-            Selection::FragmentSpread(fragment_id) => {
+            Selection::FragmentSpread(fragment_id, _) => {
                 let fragment = query.get_fragment(*fragment_id);
                 if fragment.on == parent_type_id
                     && selection_set_contains_type_name(fragment.on, &fragment.selection_set, query)