Finish implementing skip_none

Author: Selyatin

graphql_client_codegen/src/codegen/inputs.rs

@@ -3,6 +3,7 @@ use crate::{
     codegen_options::GraphQLClientCodegenOptions,
     query::{BoundQuery, UsedTypes},
     schema::input_is_recursive_without_indirection,
+    type_qualifiers::GraphqlTypeQualifier,
 };
 use heck::ToSnakeCase;
 use proc_macro2::{Ident, Span, TokenStream};
@@ -28,6 +29,11 @@ pub(super) fn generate_input_object_definitions(
                 let normalized_field_type_name = options
                     .normalization()
                     .field_type(field_type.id.name(query.schema));
+                let optional_skip_none = if *options.skip_none() && field_type.is_optional() {
+                    Some(quote!(#[serde(skip_serializing_if = "Option::is_none")]))
+                } else {
+                    None
+                };
                 let type_name = Ident::new(normalized_field_type_name.as_ref(), Span::call_site());
                 let field_type_tokens = super::decorate_type(&type_name, &field_type.qualifiers);
                 let field_type = if field_type
@@ -40,23 +46,18 @@ pub(super) fn generate_input_object_definitions(
                 } else {
                     field_type_tokens
                 };
-                quote!(#annotation pub #name_ident: #field_type)
+
+                quote!(
+                    #optional_skip_none
+                    #annotation pub #name_ident: #field_type
+                )
             });
 
-            match *options.skip_none() {
-                true => quote! {
-                    #[serde(skip_serializing_if = "Option::is_none")]
-                    #variable_derives
-                    pub struct #struct_name{
-                        #(#fields,)*
-                    }
-                },
-                false => quote! {
-                    #variable_derives
-                    pub struct #struct_name{
-                        #(#fields,)*
-                    }
-                },
+            quote! {
+                #variable_derives
+                pub struct #struct_name{
+                    #(#fields,)*
+                }
             }
         })
         .collect()

graphql_client_codegen/src/codegen/selection.rs

@@ -405,6 +405,18 @@ impl<'a> ExpandedField<'a> {
             qualified_type
         };
 
+        let optional_skip_none = if *options.skip_none()
+            && self
+                .field_type_qualifiers
+                .get(0)
+                .map(|qualifier| !qualifier.is_required())
+                .unwrap_or(false)
+        {
+            Some(quote!(#[serde(skip_serializing_if = "Option::is_none")]))
+        } else {
+            None
+        };
+
         let optional_rename = self
             .graphql_name
             .as_ref()
@@ -427,6 +439,7 @@ impl<'a> ExpandedField<'a> {
             };
 
         let tokens = quote! {
+            #optional_skip_none
             #optional_flatten
             #optional_rename
             #optional_deprecation_annotation

graphql_client_codegen/src/tests/mod.rs

@@ -117,3 +117,45 @@ fn fragments_other_variant_false_should_not_generate_unknown_other_variant() {
         };
     }
 }
+
+#[test]
+fn skip_none_should_generate_serde_skip_serializing() {
+    let query_string = include_str!("keywords_query.graphql");
+    let query = graphql_parser::parse_query::<&str>(query_string).expect("Parse keywords query");
+    let schema = graphql_parser::parse_schema(include_str!("keywords_schema.graphql"))
+        .expect("Parse keywords schema")
+        .into_static();
+    let schema = Schema::from(schema);
+
+    let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Cli);
+
+    options.set_skip_none(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 keywords module");
+
+        let generated_code = generated_tokens.to_string();
+
+        let r: syn::parse::Result<proc_macro2::TokenStream> = syn::parse2(generated_tokens);
+
+        match r {
+            Ok(_) => {
+                println!("{}", generated_code);
+                assert!(generated_code.contains("skip_serializing_if"));
+            }
+            Err(e) => {
+                panic!("Error: {}\n Generated content: {}\n", e, &generated_code);
+            }
+        };
+    }
+}