Revert "create Unknow variant for fragment as default behaviour"

This reverts commit 20c8e6d.

Author: visd0m

graphql_client_cli/README.md

@@ -57,6 +57,9 @@ 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:
     <query_path>    Path to the GraphQL query file.

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

@@ -77,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,
     },
 }
 
@@ -109,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,
@@ -120,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)
+        }
     }
 }
 
@@ -538,14 +557,12 @@ impl<'a> ExpandedSelection<'a> {
             // of the variants.
             if fields.peek().is_none() {
                 let item = quote! {
-                        #response_derives
-                        #[serde(tag = "__typename")]
-                        pub enum #struct_name {
-                            #(#on_variants,)*
-                #[serde(other)]
-                Unknown,
-                        }
-                    };
+                    #response_derives
+                    #[serde(tag = "__typename")]
+                    pub enum #struct_name {
+                        #(#on_variants),*
+                    }
+                };
                 items.push(item);
                 continue;
             }

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/mod.rs

@@ -46,8 +46,9 @@ fn fragments_other_variant_should_generate_unknown_other_variant() {
         .expect("Parse foobars schema");
     let schema = Schema::from(schema);
 
-    let options = GraphQLClientCodegenOptions::new(CodegenMode::Cli);
+    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() {
@@ -67,6 +68,45 @@ fn fragments_other_variant_should_generate_unknown_other_variant() {
             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_eq!(extract_fragments_other_variant(&parsed), true);
+    }
+
+    #[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_eq!(extract_fragments_other_variant(&parsed), false);
+    }
+
+    #[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_eq!(extract_fragments_other_variant(&parsed), false);
+    }
+
+    #[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_eq!(extract_fragments_other_variant(&parsed), false);
+    }
 }

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