Option for externally defined enums

Allow to deserialize GraphQL enums into user defined Rust enums.

Author: jakmeier

graphql_client_codegen/src/codegen/enums.rs

@@ -23,7 +23,9 @@ pub(super) fn generate_enum_definitions<'a, 'schema: 'a>(
     );
     let normalization = options.normalization();
 
-    all_used_types.enums(query.schema).map(move |(_id, r#enum)| {
+    all_used_types.enums(query.schema)
+        .filter(move |(_id, r#enum)| !options.extern_enums().contains(&r#enum.name))
+        .map(move |(_id, r#enum)| {
         let variant_names: Vec<TokenStream> = r#enum
             .variants
             .iter()

graphql_client_codegen/src/codegen_options.rs

@@ -41,6 +41,8 @@ pub struct GraphQLClientCodegenOptions {
     normalization: Normalization,
     /// Custom scalar definitions module path
     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>,
 }
 
 impl GraphQLClientCodegenOptions {
@@ -59,6 +61,7 @@ impl GraphQLClientCodegenOptions {
             schema_file: Default::default(),
             normalization: Normalization::None,
             custom_scalars_module: Default::default(),
+            extern_enums: Default::default(),
         }
     }
 
@@ -187,4 +190,14 @@ impl GraphQLClientCodegenOptions {
     pub fn set_custom_scalars_module(&mut self, module: syn::Path) {
         self.custom_scalars_module = Some(module)
     }
+
+    /// Get the externally defined enums type names
+    pub fn extern_enums(&self) -> &[String] {
+        &self.extern_enums
+    }
+
+    /// Set the externally defined enums type names
+    pub fn set_extern_enums(&mut self, enums: Vec<String>) {
+        self.extern_enums = enums;
+    }
 }

graphql_query_derive/src/attributes.rs

@@ -36,6 +36,42 @@ pub fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, syn::E
     Err(syn::Error::new_spanned(ast, "Attribute not found"))
 }
 
+/// Extract a list of configuration parameter values specified in the `graphql` attribute.
+pub fn extract_attr_list(ast: &syn::DeriveInput, attr: &str) -> Result<Vec<String>, syn::Error> {
+    let attributes = &ast.attrs;
+    let graphql_path = path_to_match();
+    let attribute = attributes
+        .iter()
+        .find(|attr| attr.path == graphql_path)
+        .ok_or_else(|| syn::Error::new_spanned(ast, "The graphql attribute is missing"))?;
+    if let syn::Meta::List(items) = &attribute.parse_meta().expect("Attribute is well formatted") {
+        for item in items.nested.iter() {
+            if let syn::NestedMeta::Meta(syn::Meta::List(value_list)) = item {
+                if let Some(ident) = value_list.path.get_ident() {
+                    if ident == attr {
+                        return value_list
+                            .nested
+                            .iter()
+                            .map(|lit| {
+                                if let syn::NestedMeta::Lit(syn::Lit::Str(lit)) = lit {
+                                    Ok(lit.value())
+                                } else {
+                                    Err(syn::Error::new_spanned(
+                                        lit,
+                                        "Attribute inside value list must be a literal",
+                                    ))
+                                }
+                            })
+                            .collect();
+                    }
+                }
+            }
+        }
+    }
+
+    Err(syn::Error::new_spanned(ast, "Attribute not found"))
+}
+
 /// Get the deprecation from a struct attribute in the derive case.
 pub fn extract_deprecation_strategy(
     ast: &syn::DeriveInput,

graphql_query_derive/src/lib.rs

@@ -71,6 +71,7 @@ fn build_graphql_client_derive_options(
     let variables_derives = attributes::extract_attr(input, "variables_derives").ok();
     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 mut options = GraphQLClientCodegenOptions::new(CodegenMode::Derive);
     options.set_query_file(query_path);
@@ -105,6 +106,11 @@ fn build_graphql_client_derive_options(
         options.set_custom_scalars_module(custom_scalars_module);
     }
 
+    // The user can specify a list of enums types that are defined externally, rather than generated by this library
+    if let Some(extern_enums) = extern_enums {
+        options.set_extern_enums(extern_enums);
+    }
+
     options.set_struct_ident(input.ident.clone());
     options.set_module_visibility(input.vis.clone());
     options.set_operation_name(input.ident.to_string());