Provide helpful feedback when a struct name does not match any operation

Author: tomhoule

graphql_client/tests/interfaces/interface_not_on_everything_query.rs

@@ -1,5 +1,7 @@
 use failure;
-use graphql_client_codegen::{generate_module_token_stream, GraphQLClientCodegenOptions};
+use graphql_client_codegen::{
+    generate_module_token_stream, CodegenMode, GraphQLClientCodegenOptions,
+};
 use std::fs::File;
 use std::io::Write as _;
 use std::path::PathBuf;
@@ -21,7 +23,7 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> Result<(), failure::Err
         .as_ref()
         .and_then(|s| s.parse().ok());
 
-    let mut options = GraphQLClientCodegenOptions::new_default();
+    let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Cli);
 
     options.set_module_visibility(
         syn::VisPublic {

graphql_client/tests/unions/union_query.rs

@@ -7,7 +7,7 @@ use query::QueryContext;
 use schema;
 use selection::Selection;
 
-/// Selects the first operation matching `struct_name` or the first one. Returns `None` when the query document defines no operation.
+/// Selects the first operation matching `struct_name`. Returns `None` when the query document defines no operation, or when the selected operation does not match any defined operation.
 pub(crate) fn select_operation<'query>(
     query: &'query query::Document,
     struct_name: &str,
@@ -18,7 +18,6 @@ pub(crate) fn select_operation<'query>(
         .iter()
         .find(|op| op.name == struct_name)
         .map(|i| i.to_owned())
-        .or_else(|| operations.iter().next().map(|i| i.to_owned()))
 }
 
 pub(crate) fn all_operations(query: &query::Document) -> Vec<Operation> {

graphql_client_cli/src/generate.rs

@@ -3,9 +3,20 @@ use proc_macro2::Ident;
 use std::path::{Path, PathBuf};
 use syn::Visibility;
 
+/// Which context is this code generation effort taking place.
+#[derive(Debug)]
+pub enum CodegenMode {
+    /// The graphql-client CLI.
+    Cli,
+    /// The derive macro defined in graphql_query_derive.
+    Derive,
+}
+
 /// Used to configure code generation.
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct GraphQLClientCodegenOptions {
+    /// Which context is this code generation effort taking place.
+    pub mode: CodegenMode,
     /// Name of the operation we want to generate code for. If it does not match, we use all queries.
     pub operation_name: Option<String>,
     /// The name of implemention target struct.
@@ -28,8 +39,20 @@ pub struct GraphQLClientCodegenOptions {
 
 impl GraphQLClientCodegenOptions {
     /// Creates an empty options object with default params. It probably wants to be configured.
-    pub fn new_default() -> GraphQLClientCodegenOptions {
-        std::default::Default::default()
+    pub fn new(mode: CodegenMode) -> GraphQLClientCodegenOptions {
+        use std::default::Default;
+
+        GraphQLClientCodegenOptions {
+            mode,
+            additional_derives: Default::default(),
+            deprecation_strategy: Default::default(),
+            module_visibility: Default::default(),
+            operation_name: Default::default(),
+            struct_ident: Default::default(),
+            struct_name: Default::default(),
+            query_file: Default::default(),
+            schema_file: Default::default(),
+        }
     }
 
     /// The visibility (public/private) to apply to the target module.

graphql_client_codegen/src/codegen.rs

@@ -51,7 +51,7 @@ mod variables;
 #[cfg(test)]
 mod tests;
 
-pub use codegen_options::GraphQLClientCodegenOptions;
+pub use codegen_options::{CodegenMode, GraphQLClientCodegenOptions};
 
 use std::collections::HashMap;
 
@@ -88,8 +88,21 @@ pub fn generate_module_token_stream(
         .operation_name
         .as_ref()
         .and_then(|operation_name| codegen::select_operation(&query, &operation_name))
-        .map(|op| vec![op])
-        .unwrap_or_else(|| codegen::all_operations(&query));
+        .map(|op| vec![op]);
+
+    let operations = match (operations, &options.mode) {
+        (Some(ops), _) => ops,
+        (None, &CodegenMode::Cli) => codegen::all_operations(&query),
+        (None, &CodegenMode::Derive) => {
+            return Err(
+                format_err!("The struct name does not match any defined operation in the query file.\nStruct name: {}\nDefined operations: {}", options.struct_ident().map(|i| i.to_string()).as_ref().map(String::as_str).unwrap_or(""), query.definitions.iter().filter_map(|definition| match definition { graphql_parser::query::Definition::Operation(op) => match op { graphql_parser::query::OperationDefinition::Mutation(m) => Some(m.name.as_ref().unwrap()),
+graphql_parser::query::OperationDefinition::Query(m) => Some(m.name.as_ref().unwrap()),
+graphql_parser::query::OperationDefinition::Subscription(m) => Some(m.name.as_ref().unwrap()),
+graphql_parser::query::OperationDefinition::SelectionSet(_) => panic!("Bare selection sets are not supported"),
+        }, _ => None }).fold(String::new(), |mut acc, item| { acc.push_str(&item); acc.push_str(", "); acc }).trim_end_matches(", ")),
+            )
+        }
+    };
 
     let schema_extension = schema_path
         .extension()

graphql_client_codegen/src/codegen_options.rs

@@ -9,7 +9,9 @@ extern crate syn;
 mod attributes;
 
 use failure::ResultExt;
-use graphql_client_codegen::{generate_module_token_stream, GraphQLClientCodegenOptions};
+use graphql_client_codegen::{
+    generate_module_token_stream, CodegenMode, GraphQLClientCodegenOptions,
+};
 use std::path::{Path, PathBuf};
 
 use proc_macro2::TokenStream;
@@ -18,7 +20,15 @@ use proc_macro2::TokenStream;
 pub fn graphql_query_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     match graphql_query_derive_inner(input) {
         Ok(ts) => ts,
-        Err(err) => panic!("{:?}", err),
+        Err(err) => panic!(
+            "{}",
+            err.iter_chain()
+                .fold(String::new(), |mut acc, item| {
+                    acc.push_str(&format!("{}\n", item));
+                    acc
+                })
+                .trim_end_matches("\n")
+        ),
     }
 }
 
@@ -29,7 +39,11 @@ fn graphql_query_derive_inner(
     let ast = syn::parse2(input).context("Derive input parsing.")?;
     let (query_path, schema_path) = build_query_and_schema_path(&ast)?;
     let options = build_graphql_client_derive_options(&ast, query_path.to_path_buf())?;
-    generate_module_token_stream(query_path, &schema_path, options).map(|module| module.into())
+    Ok(
+        generate_module_token_stream(query_path, &schema_path, options)
+            .map(|module| module.into())
+            .context("Code generation failed.")?,
+    )
 }
 
 fn build_query_and_schema_path(
@@ -54,7 +68,7 @@ fn build_graphql_client_derive_options(
 ) -> Result<GraphQLClientCodegenOptions, failure::Error> {
     let response_derives = attributes::extract_attr(input, "response_derives").ok();
 
-    let mut options = GraphQLClientCodegenOptions::new_default();
+    let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Derive);
     options.set_query_file(query_path);
 
     if let Some(response_derives) = response_derives {