Make graphql_object support derive resolvers for struct fields (gra…

…phql-rust#553)

integration_tests/juniper_tests/src/codegen/mod.rs

@@ -4,6 +4,7 @@ mod derive_object;
 mod derive_object_with_raw_idents;
 mod derive_union;
 mod impl_object;
+mod impl_object_with_derive_fields;
 mod impl_scalar;
 mod impl_union;
 mod scalar_value_transparent;

juniper/CHANGELOG.md

@@ -32,6 +32,10 @@ See [#618](https://github.com/graphql-rust/juniper/pull/618).
 - Better error messages for all proc macros (see
   [#631](https://github.com/graphql-rust/juniper/pull/631)
 
+- Procedural macro `graphql_object` supports deriving resolvers for fields in
+  struct (see [#553](https://github.com/graphql-rust/juniper/issues/553))
+  - requires derive macro `GraphQLObjectInfo`.
+
 ## Breaking Changes
 
 - `juniper::graphiql` has moved to `juniper::http::graphiql`

juniper/src/lib.rs

@@ -116,7 +116,7 @@ extern crate bson;
 // functionality automatically.
 pub use juniper_codegen::{
     graphql_object, graphql_scalar, graphql_subscription, graphql_union, GraphQLEnum,
-    GraphQLInputObject, GraphQLObject, GraphQLScalarValue, GraphQLUnion,
+    GraphQLInputObject, GraphQLObject, GraphQLObjectInfo, GraphQLScalarValue, GraphQLUnion,
 };
 // Internal macros are not exported,
 // but declared at the root to make them easier to use.
@@ -178,7 +178,7 @@ pub use crate::{
     },
     types::{
         async_await::GraphQLTypeAsync,
-        base::{Arguments, GraphQLType, TypeKind},
+        base::{Arguments, GraphQLType, GraphQLTypeInfo, TypeKind},
         marker,
         scalars::{EmptyMutation, EmptySubscription, ID},
         subscriptions::{GraphQLSubscriptionType, SubscriptionConnection, SubscriptionCoordinator},

juniper/src/types/base.rs

@@ -6,7 +6,7 @@ use crate::{
     ast::{Directive, FromInputValue, InputValue, Selection},
     executor::{ExecutionResult, Executor, Registry, Variables},
     parser::Spanning,
-    schema::meta::{Argument, MetaType},
+    schema::meta::{Argument, Field, MetaType},
     value::{DefaultScalarValue, Object, ScalarValue, Value},
 };
 
@@ -341,6 +341,54 @@ where
     }
 }
 
+/// `GraphQLTypeInfo` holds the meta information for the given type.
+///
+/// The macros remove duplicated definitions of fields and arguments, and add
+/// type checks on all resolve functions automatically.
+pub trait GraphQLTypeInfo<S = DefaultScalarValue>: Sized
+where
+    S: ScalarValue,
+{
+    /// The expected context type for this GraphQL type
+    ///
+    /// The context is threaded through query execution to all affected nodes,
+    /// and can be used to hold common data, e.g. database connections or
+    /// request session information.
+    type Context;
+
+    /// Type that may carry additional schema information
+    ///
+    /// This can be used to implement a schema that is partly dynamic,
+    /// meaning that it can use information that is not known at compile time,
+    /// for instance by reading it from a configuration file at start-up.
+    type TypeInfo;
+
+    /// The field definitions of fields for fields derived from the struct of
+    /// this GraphQL type.
+    fn fields<'r>(info: &Self::TypeInfo, registry: &mut Registry<'r, S>) -> Vec<Field<'r, S>>
+    where
+        S: 'r;
+
+    /// Resolve the value of a single field on this type.
+    ///
+    /// The arguments object contain all specified arguments, with default
+    /// values substituted for the ones not provided by the query.
+    ///
+    /// The executor can be used to drive selections into sub-objects.
+    ///
+    /// The default implementation panics.
+    #[allow(unused_variables)]
+    fn resolve_field(
+        &self,
+        info: &Self::TypeInfo,
+        field_name: &str,
+        arguments: &Arguments<S>,
+        executor: &Executor<Self::Context, S>,
+    ) -> ExecutionResult<S> {
+        panic!("resolve_field must be implemented by object types");
+    }
+}
+
 /// Resolver logic for queries'/mutations' selection set.
 /// Calls appropriate resolver method for each field or fragment found
 /// and then merges returned values into `result` or pushes errors to

juniper_codegen/src/derive_enum.rs

@@ -143,6 +143,7 @@ pub fn impl_enum(
         generics: syn::Generics::default(),
         interfaces: None,
         include_type_generics: true,
+        include_struct_fields: false,
         generic_scalar: true,
         no_async: attrs.no_async.is_some(),
     };

juniper_codegen/src/derive_input_object.rs

@@ -143,6 +143,7 @@ pub fn impl_input_object(
         generics: ast.generics,
         interfaces: None,
         include_type_generics: true,
+        include_struct_fields: false,
         generic_scalar: true,
         no_async: attrs.no_async.is_some(),
     };

juniper_codegen/src/derive_object.rs

@@ -1,11 +1,68 @@
 use crate::{
     result::{GraphQLScope, UnsupportedAttribute},
-    util::{self, span_container::SpanContainer},
+    util::{self, duplicate::Duplicate, span_container::SpanContainer},
 };
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{self, ext::IdentExt, spanned::Spanned, Data, Fields};
 
+pub fn create_field_definition(
+    field: syn::Field,
+    error: &GraphQLScope,
+) -> Option<util::GraphQLTypeDefinitionField> {
+    let span = field.span();
+    let field_attrs = match util::FieldAttributes::from_attrs(
+        &field.attrs,
+        util::FieldAttributeParseMode::Object,
+    ) {
+        Ok(attrs) => attrs,
+        Err(e) => {
+            proc_macro_error::emit_error!(e);
+            return None;
+        }
+    };
+
+    if field_attrs.skip.is_some() {
+        return None;
+    }
+
+    let field_name = &field.ident.unwrap();
+    let name = field_attrs
+        .name
+        .clone()
+        .map(SpanContainer::into_inner)
+        .unwrap_or_else(|| util::to_camel_case(&field_name.unraw().to_string()));
+
+    if name.starts_with("__") {
+        error.no_double_underscore(if let Some(name) = field_attrs.name {
+            name.span_ident()
+        } else {
+            field_name.span()
+        });
+    }
+
+    if let Some(default) = field_attrs.default {
+        error.unsupported_attribute_within(default.span_ident(), UnsupportedAttribute::Default);
+    }
+
+    let resolver_code = quote!(
+        &self . #field_name
+    );
+
+    Some(util::GraphQLTypeDefinitionField {
+        name,
+        _type: field.ty,
+        args: Vec::new(),
+        description: field_attrs.description.map(SpanContainer::into_inner),
+        deprecation: field_attrs.deprecation.map(SpanContainer::into_inner),
+        resolver_code,
+        default: None,
+        is_type_inferred: true,
+        is_async: false,
+        span,
+    })
+}
+
 pub fn build_derive_object(
     ast: syn::DeriveInput,
     is_internal: bool,
@@ -32,64 +89,17 @@ pub fn build_derive_object(
 
     let fields = struct_fields
         .into_iter()
-        .filter_map(|field| {
-            let span = field.span();
-            let field_attrs = match util::FieldAttributes::from_attrs(
-                &field.attrs,
-                util::FieldAttributeParseMode::Object,
-            ) {
-                Ok(attrs) => attrs,
-                Err(e) => {
-                    proc_macro_error::emit_error!(e);
-                    return None;
-                }
-            };
-
-            if field_attrs.skip.is_some() {
-                return None;
-            }
-
-            let field_name = &field.ident.unwrap();
-            let name = field_attrs
-                .name
-                .clone()
-                .map(SpanContainer::into_inner)
-                .unwrap_or_else(|| util::to_camel_case(&field_name.unraw().to_string()));
-
-            if name.starts_with("__") {
-                error.no_double_underscore(if let Some(name) = field_attrs.name {
-                    name.span_ident()
-                } else {
-                    field_name.span()
-                });
-            }
-
-            if let Some(default) = field_attrs.default {
-                error.unsupported_attribute_within(
-                    default.span_ident(),
-                    UnsupportedAttribute::Default,
-                );
-            }
-
-            let resolver_code = quote!(
-                &self . #field_name
-            );
-
-            Some(util::GraphQLTypeDefinitionField {
-                name,
-                _type: field.ty,
-                args: Vec::new(),
-                description: field_attrs.description.map(SpanContainer::into_inner),
-                deprecation: field_attrs.deprecation.map(SpanContainer::into_inner),
-                resolver_code,
-                default: None,
-                is_type_inferred: true,
-                is_async: false,
-                span,
-            })
-        })
+        .filter_map(|field| create_field_definition(field, &error))
         .collect::<Vec<_>>();
 
+    if let Some(duplicates) = Duplicate::find_by_key(&fields, |field| field.name.as_str()) {
+        error.duplicate(duplicates.iter());
+    }
+
+    if fields.is_empty() {
+        error.not_empty(ast_span);
+    }
+
     // Early abort after checking all fields
     proc_macro_error::abort_if_dirty();
 
@@ -99,12 +109,6 @@ pub fn build_derive_object(
         });
     }
 
-    if let Some(duplicates) =
-        crate::util::duplicate::Duplicate::find_by_key(&fields, |field| field.name.as_str())
-    {
-        error.duplicate(duplicates.iter());
-    }
-
     if name.starts_with("__") && !is_internal {
         error.no_double_underscore(if let Some(name) = attrs.name {
             name.span_ident()
@@ -113,10 +117,6 @@ pub fn build_derive_object(
         });
     }
 
-    if fields.is_empty() {
-        error.not_empty(ast_span);
-    }
-
     // Early abort after GraphQL properties
     proc_macro_error::abort_if_dirty();
 
@@ -130,10 +130,64 @@ pub fn build_derive_object(
         generics: ast.generics,
         interfaces: None,
         include_type_generics: true,
+        include_struct_fields: false,
         generic_scalar: true,
         no_async: attrs.no_async.is_some(),
     };
 
     let juniper_crate_name = if is_internal { "crate" } else { "juniper" };
     Ok(definition.into_tokens(juniper_crate_name))
 }
+
+pub fn build_derive_object_info(
+    ast: syn::DeriveInput,
+    is_internal: bool,
+    error: GraphQLScope,
+) -> syn::Result<TokenStream> {
+    let ast_span = ast.span();
+    let struct_fields = match ast.data {
+        Data::Struct(data) => match data.fields {
+            Fields::Named(fields) => fields.named,
+            _ => return Err(error.custom_error(ast_span, "only named fields are allowed")),
+        },
+        _ => return Err(error.custom_error(ast_span, "can only be applied to structs")),
+    };
+
+    // Parse attributes.
+    let attrs = util::ObjectInfoAttributes::from_attrs(&ast.attrs)?;
+
+    let ident = &ast.ident;
+    let fields = struct_fields
+        .into_iter()
+        .filter_map(|field| create_field_definition(field, &error))
+        .collect::<Vec<_>>();
+
+    if let Some(duplicates) = Duplicate::find_by_key(&fields, |field| field.name.as_str()) {
+        error.duplicate(duplicates.iter());
+    }
+
+    if fields.is_empty() {
+        error.not_empty(ast_span);
+    }
+
+    // Early abort after checking all fields
+    proc_macro_error::abort_if_dirty();
+
+    let definition = util::GraphQLTypeDefiniton {
+        name: ident.unraw().to_string(),
+        _type: syn::parse_str(&ast.ident.to_string()).unwrap(),
+        context: attrs.context.map(SpanContainer::into_inner),
+        scalar: attrs.scalar.map(SpanContainer::into_inner),
+        description: None,
+        fields,
+        generics: ast.generics,
+        interfaces: None,
+        include_type_generics: true,
+        include_struct_fields: false,
+        generic_scalar: true,
+        no_async: false,
+    };
+
+    let juniper_crate_name = if is_internal { "crate" } else { "juniper" };
+    Ok(definition.into_info_tokens(juniper_crate_name))
+}

juniper_codegen/src/derive_union.rs

@@ -173,6 +173,7 @@ pub fn build_derive_union(
         generics: ast.generics,
         interfaces: None,
         include_type_generics: true,
+        include_struct_fields: false,
         generic_scalar: true,
         no_async: attrs.no_async.is_some(),
     };

juniper_codegen/src/impl_object.rs

@@ -226,6 +226,7 @@ fn create(
             None
         },
         include_type_generics: false,
+        include_struct_fields: _impl.attrs.derive_fields.is_some(),
         generic_scalar: false,
         no_async: _impl.attrs.no_async.is_some(),
     };