Unknow other variant for fragment

graphql_client_cli/README.md

@@ -57,6 +57,8 @@ OPTIONS:
     -s, --schema-path <schema_path>                      Path to GraphQL schema file (.json or .graphql).
     -o, --selected-operation <selected_operation>
             Name of target query. If you don't set this parameter, cli generate all queries in query file.
+	--fragments-other-variant
+            Generate an Unknow variant for enums generated by fragments.
 
 
 ARGS:

graphql_client_cli/src/generate.rs

@@ -21,6 +21,7 @@ pub(crate) struct CliCodegenParams {
     pub module_visibility: Option<String>,
     pub output_directory: Option<PathBuf>,
     pub custom_scalars_module: Option<String>,
+    pub fragments_other_variant: bool,
 }
 
 pub(crate) fn generate_code(params: CliCodegenParams) -> CliResult<()> {
@@ -35,6 +36,7 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> CliResult<()> {
         schema_path,
         selected_operation,
         custom_scalars_module,
+        fragments_other_variant,
     } = params;
 
     let deprecation_strategy = deprecation_strategy.as_ref().and_then(|s| s.parse().ok());
@@ -48,6 +50,8 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> CliResult<()> {
         .into(),
     );
 
+    options.set_fragments_other_variant(fragments_other_variant);
+
     if let Some(selected_operation) = selected_operation {
         options.set_operation_name(selected_operation);
     }

graphql_client_cli/src/main.rs

@@ -9,6 +9,7 @@ use error::Error;
 use log::Level;
 use std::path::PathBuf;
 use structopt::StructOpt;
+use Cli::Generate;
 
 type CliResult<T> = Result<T, Error>;
 
@@ -76,6 +77,10 @@ enum Cli {
         /// --custom-scalars-module='crate::gql::custom_scalars'
         #[structopt(short = "p", long = "custom-scalars-module")]
         custom_scalars_module: Option<String>,
+        /// A flag indicating if the enum representing the variants of a fragment union/interface should have a "other" variant
+        /// --fragments-other-variant
+        #[structopt(long = "fragments-other-variant")]
+        fragments_other_variant: bool,
     },
 }
 
@@ -97,7 +102,7 @@ fn main() -> CliResult<()> {
             headers,
             no_ssl,
         ),
-        Cli::Generate {
+        Generate {
             variables_derives,
             response_derives,
             deprecation_strategy,
@@ -108,6 +113,7 @@ fn main() -> CliResult<()> {
             schema_path,
             selected_operation,
             custom_scalars_module,
+            fragments_other_variant,
         } => generate::generate_code(generate::CliCodegenParams {
             query_path,
             schema_path,
@@ -119,6 +125,7 @@ fn main() -> CliResult<()> {
             module_visibility,
             output_directory,
             custom_scalars_module,
+            fragments_other_variant,
         }),
     }
 }

graphql_client_codegen/src/codegen/selection.rs

@@ -197,6 +197,7 @@ fn calculate_selection<'a>(
                         name: variant_name_str.into(),
                         variant_type: Some(variant_struct_name_str.clone().into()),
                         on: struct_id,
+                        is_default_variant: false,
                     });
 
                     let expanded_type = ExpandedType {
@@ -247,9 +248,19 @@ fn calculate_selection<'a>(
                         name: variant_name_str.into(),
                         on: struct_id,
                         variant_type: None,
+                        is_default_variant: false,
                     });
                 }
             }
+
+            if *options.fragments_other_variant() {
+                context.push_variant(ExpandedVariant {
+                    name: "Unknown".into(),
+                    on: struct_id,
+                    variant_type: None,
+                    is_default_variant: true,
+                });
+            }
         }
     }
 
@@ -430,6 +441,7 @@ struct ExpandedVariant<'a> {
     name: Cow<'a, str>,
     variant_type: Option<Cow<'a, str>>,
     on: ResponseTypeId,
+    is_default_variant: bool,
 }
 
 impl<'a> ExpandedVariant<'a> {
@@ -440,7 +452,14 @@ impl<'a> ExpandedVariant<'a> {
             quote!((#ident))
         });
 
-        quote!(#name_ident #optional_type_ident)
+        if self.is_default_variant {
+            quote! {
+                    #[serde(other)]
+            #name_ident #optional_type_ident
+                }
+        } else {
+            quote!(#name_ident #optional_type_ident)
+        }
     }
 }
 

graphql_client_codegen/src/codegen_options.rs

@@ -43,6 +43,8 @@ pub struct GraphQLClientCodegenOptions {
     custom_scalars_module: Option<syn::Path>,
     /// List of externally defined enum types. Type names must match those used in the schema exactly.
     extern_enums: Vec<String>,
+    /// Flag to trigger generation of Other variant for fragments Enum
+    fragments_other_variant: bool,
 }
 
 impl GraphQLClientCodegenOptions {
@@ -62,6 +64,7 @@ impl GraphQLClientCodegenOptions {
             normalization: Normalization::None,
             custom_scalars_module: Default::default(),
             extern_enums: Default::default(),
+            fragments_other_variant: Default::default(),
         }
     }
 
@@ -200,4 +203,14 @@ impl GraphQLClientCodegenOptions {
     pub fn set_extern_enums(&mut self, enums: Vec<String>) {
         self.extern_enums = enums;
     }
+
+    /// Set the graphql client codegen options's fragments other variant.
+    pub fn set_fragments_other_variant(&mut self, fragments_other_variant: bool) {
+        self.fragments_other_variant = fragments_other_variant;
+    }
+
+    /// Get a reference to the graphql client codegen options's fragments other variant.
+    pub fn fragments_other_variant(&self) -> &bool {
+        &self.fragments_other_variant
+    }
 }

graphql_client_codegen/src/tests/foobars_query.graphql

@@ -0,0 +1,16 @@
+query FooBarsQuery {
+    fooBars {
+        fooBars {
+            __typename
+            ... on Foo {
+                fooField
+            }
+            ... on Bar {
+                barField
+            }
+            ... on FooBar {
+                fooBarField
+            }
+        }
+    }
+}

graphql_client_codegen/src/tests/foobars_schema.graphql

@@ -0,0 +1,28 @@
+schema {
+    query: Query
+    mutation: Mutation
+}
+
+directive @defer on FIELD
+
+type Query {
+    fooBars: Self
+}
+
+type Self {
+    fooBars: Result
+}
+
+union Result = Foo | Bar | FooBar
+
+type Foo {
+    fooField: String!
+}
+
+type Bar {
+    barField: String!
+}
+
+type FooBar {
+    fooBarField: String!
+}

graphql_client_codegen/src/tests/mod.rs

@@ -1,7 +1,7 @@
+use crate::{generated_module, schema::Schema, CodegenMode, GraphQLClientCodegenOptions};
+
 #[test]
 fn schema_with_keywords_works() {
-    use crate::{generated_module, schema::Schema, CodegenMode, GraphQLClientCodegenOptions};
-
     let query_string = include_str!("keywords_query.graphql");
     let query = graphql_parser::parse_query(query_string).expect("Parse keywords query");
     let schema = graphql_parser::parse_schema(include_str!("keywords_schema.graphql"))
@@ -37,3 +37,80 @@ fn schema_with_keywords_works() {
         };
     }
 }
+
+#[test]
+fn fragments_other_variant_should_generate_unknown_other_variant() {
+    let query_string = include_str!("foobars_query.graphql");
+    let query = graphql_parser::parse_query(query_string).expect("Parse foobars query");
+    let schema = graphql_parser::parse_schema(include_str!("foobars_schema.graphql"))
+        .expect("Parse foobars schema");
+    let schema = Schema::from(schema);
+
+    let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Cli);
+
+    options.set_fragments_other_variant(true);
+    let query = crate::query::resolve(&schema, &query).unwrap();
+
+    for (_id, operation) in query.operations() {
+        let generated_tokens = generated_module::GeneratedModule {
+            query_string,
+            schema: &schema,
+            operation: &operation.name,
+            resolved_query: &query,
+            options: &options,
+        }
+        .to_token_stream()
+        .expect("Generate foobars module");
+        let generated_code = generated_tokens.to_string();
+
+        let r: syn::parse::Result<proc_macro2::TokenStream> = syn::parse2(generated_tokens);
+        match r {
+            Ok(_) => {
+                // Rust keywords should be escaped / renamed now
+                assert!(generated_code.contains("# [serde (other)] Unknown"));
+                assert!(generated_code.contains("Unknown"));
+            }
+            Err(e) => {
+                panic!("Error: {}\n Generated content: {}\n", e, &generated_code);
+            }
+        };
+    }
+}
+
+#[test]
+fn fragments_other_variant_false_should_not_generate_unknown_other_variant() {
+    let query_string = include_str!("foobars_query.graphql");
+    let query = graphql_parser::parse_query(query_string).expect("Parse foobars query");
+    let schema = graphql_parser::parse_schema(include_str!("foobars_schema.graphql"))
+        .expect("Parse foobars schema");
+    let schema = Schema::from(schema);
+
+    let options = GraphQLClientCodegenOptions::new(CodegenMode::Cli);
+
+    let query = crate::query::resolve(&schema, &query).unwrap();
+
+    for (_id, operation) in query.operations() {
+        let generated_tokens = generated_module::GeneratedModule {
+            query_string,
+            schema: &schema,
+            operation: &operation.name,
+            resolved_query: &query,
+            options: &options,
+        }
+        .to_token_stream()
+        .expect("Generate foobars module");
+        let generated_code = generated_tokens.to_string();
+
+        let r: syn::parse::Result<proc_macro2::TokenStream> = syn::parse2(generated_tokens);
+        match r {
+            Ok(_) => {
+                // Rust keywords should be escaped / renamed now
+                assert!(!generated_code.contains("# [serde (other)] Unknown"));
+                assert!(!generated_code.contains("Unknown"));
+            }
+            Err(e) => {
+                panic!("Error: {}\n Generated content: {}\n", e, &generated_code);
+            }
+        };
+    }
+}

graphql_query_derive/src/attributes.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use graphql_client_codegen::deprecation::DeprecationStrategy;
 use graphql_client_codegen::normalization::Normalization;
 
@@ -94,6 +96,13 @@ pub fn extract_normalization(ast: &syn::DeriveInput) -> Result<Normalization, sy
         .map_err(|_| syn::Error::new_spanned(ast, NORMALIZATION_ERROR))
 }
 
+pub fn extract_fragments_other_variant(ast: &syn::DeriveInput) -> bool {
+    extract_attr(&ast, "fragments_other_variant")
+        .ok()
+        .and_then(|s| FromStr::from_str(s.as_str()).ok())
+        .unwrap_or(false)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -151,4 +160,63 @@ mod test {
             Err(e) => assert_eq!(&format!("{}", e), DEPRECATION_ERROR),
         };
     }
+
+    #[test]
+    fn test_fragments_other_variant_set_to_true() {
+        let input = "
+        #[derive(GraphQLQuery)]
+        #[graphql(
+            schema_path = \"x\",
+            query_path = \"x\",
+            fragments_other_variant = \"true\",
+        )]
+        struct MyQuery;
+        ";
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(extract_fragments_other_variant(&parsed));
+    }
+
+    #[test]
+    fn test_fragments_other_variant_set_to_false() {
+        let input = "
+        #[derive(GraphQLQuery)]
+        #[graphql(
+            schema_path = \"x\",
+            query_path = \"x\",
+            fragments_other_variant = \"false\",
+        )]
+        struct MyQuery;
+        ";
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(!extract_fragments_other_variant(&parsed));
+    }
+
+    #[test]
+    fn test_fragments_other_variant_set_to_invalid() {
+        let input = "
+        #[derive(GraphQLQuery)]
+        #[graphql(
+            schema_path = \"x\",
+            query_path = \"x\",
+            fragments_other_variant = \"invalid\",
+        )]
+        struct MyQuery;
+        ";
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(!extract_fragments_other_variant(&parsed));
+    }
+
+    #[test]
+    fn test_fragments_other_variant_unset() {
+        let input = "
+        #[derive(GraphQLQuery)]
+        #[graphql(
+            schema_path = \"x\",
+            query_path = \"x\",
+        )]
+        struct MyQuery;
+        ";
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(!extract_fragments_other_variant(&parsed));
+    }
 }

graphql_query_derive/src/lib.rs

@@ -63,9 +63,11 @@ fn build_graphql_client_derive_options(
     let response_derives = attributes::extract_attr(input, "response_derives").ok();
     let custom_scalars_module = attributes::extract_attr(input, "custom_scalars_module").ok();
     let extern_enums = attributes::extract_attr_list(input, "extern_enums").ok();
+    let fragments_other_variant: bool = attributes::extract_fragments_other_variant(input);
 
     let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Derive);
     options.set_query_file(query_path);
+    options.set_fragments_other_variant(fragments_other_variant);
 
     if let Some(variables_derives) = variables_derives {
         options.set_variables_derives(variables_derives);