Add skip_none to codegen and query_derive

Author: Selyatin

graphql_client_codegen/src/codegen/inputs.rs

@@ -43,11 +43,20 @@ pub(super) fn generate_input_object_definitions(
                 quote!(#annotation pub #name_ident: #field_type)
             });
 
-            quote! {
-                #variable_derives
-                pub struct #struct_name {
-                    #(#fields,)*
-                }
+            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,)*
+                    }
+                },
             }
         })
         .collect()

graphql_client_codegen/src/codegen_options.rs

@@ -45,6 +45,8 @@ pub struct GraphQLClientCodegenOptions {
     extern_enums: Vec<String>,
     /// Flag to trigger generation of Other variant for fragments Enum
     fragments_other_variant: bool,
+    /// Skip Serialization of None values.
+    skip_none: bool,
 }
 
 impl GraphQLClientCodegenOptions {
@@ -65,6 +67,7 @@ impl GraphQLClientCodegenOptions {
             custom_scalars_module: Default::default(),
             extern_enums: Default::default(),
             fragments_other_variant: Default::default(),
+            skip_none: Default::default(),
         }
     }
 
@@ -214,4 +217,14 @@ impl GraphQLClientCodegenOptions {
     pub fn fragments_other_variant(&self) -> &bool {
         &self.fragments_other_variant
     }
+
+    /// Set the graphql client codegen option's skip none value.
+    pub fn set_skip_none(&mut self, skip_none: bool) {
+        self.skip_none = skip_none
+    }
+
+    /// Get a reference to the graphql client codegen option's skip none value.
+    pub fn skip_none(&self) -> &bool {
+        &self.skip_none
+    }
 }

graphql_query_derive/src/attributes.rs

@@ -103,6 +103,13 @@ pub fn extract_fragments_other_variant(ast: &syn::DeriveInput) -> bool {
         .unwrap_or(false)
 }
 
+pub fn extract_skip_none(ast: &syn::DeriveInput) -> bool {
+    extract_attr(ast, "skip_none")
+        .ok()
+        .and_then(|s| FromStr::from_str(s.as_str()).ok())
+        .unwrap_or(false)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -219,4 +226,63 @@ mod test {
         let parsed = syn::parse_str(input).unwrap();
         assert!(!extract_fragments_other_variant(&parsed));
     }
+
+    #[test]
+    fn test_skip_none_set_to_true() {
+        let input = r#"
+            #[derive(GraphQLQuery)]
+            #[graphql(
+                schema_path = "x",
+                query_path = "x",
+                skip_none = "true"
+            )]
+            struct MyQuery;
+        "#;
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(extract_skip_none(&parsed));
+    }
+
+    #[test]
+    fn test_skip_none_set_to_false() {
+        let input = r#"
+            #[derive(GraphQLQuery)]
+            #[graphql(
+                schema_path = "x",
+                query_path = "x",
+                skip_none = "false"
+            )]
+            struct MyQuery;
+        "#;
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(!extract_skip_none(&parsed));
+    }
+
+    #[test]
+    fn test_skip_none_set_to_invalid() {
+        let input = r#"
+            #[derive(GraphQLQuery)]
+            #[graphql(
+                schema_path = "x",
+                query_path = "x",
+                skip_none = "invalid"
+            )]
+            struct MyQuery;
+        "#;
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(!extract_skip_none(&parsed));
+    }
+
+    #[test]
+    fn test_skip_none_unset() {
+        let input = r#"
+            #[derive(GraphQLQuery)]
+            #[graphql(
+                schema_path = "x",
+                query_path = "x",
+            )]
+            struct MyQuery;
+        "#;
+        let parsed = syn::parse_str(input).unwrap();
+        assert!(!extract_skip_none(&parsed));
+    }
 }

graphql_query_derive/src/lib.rs

@@ -64,10 +64,12 @@ fn build_graphql_client_derive_options(
     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 skip_none: bool = attributes::extract_skip_none(input);
 
     let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Derive);
     options.set_query_file(query_path);
     options.set_fragments_other_variant(fragments_other_variant);
+    options.set_skip_none(skip_none);
 
     if let Some(variables_derives) = variables_derives {
         options.set_variables_derives(variables_derives);