Allows to get the actual field name and alias in ResolveInfo. #551

derive/src/subscription.rs

@@ -365,6 +365,8 @@ pub fn generate(
                                     path_node: ctx_selection_set.path_node.as_ref().unwrap(),
                                     parent_type: #gql_typename,
                                     return_type: &<<#stream_ty as #crate_name::futures_util::stream::Stream>::Item as #crate_name::Type>::qualified_type_name(),
+                                    name: field.node.name.node.as_str(),
+                                    alias: field.node.alias.as_ref().map(|alias| alias.node.as_str()),
                                 };
                                 let resolve_fut = async {
                                     #crate_name::OutputType::resolve(&msg, &ctx_selection_set, &*field)

src/extensions/mod.rs

@@ -103,6 +103,12 @@ pub struct ResolveInfo<'a> {
 
     /// Current return type, is qualified name.
     pub return_type: &'a str,
+
+    /// Current field name
+    pub name: &'a str,
+
+    /// Current field alias
+    pub alias: Option<&'a str>,
 }
 
 type RequestFut<'a> = &'a mut (dyn Future<Output = Response> + Send + Unpin);

src/resolver_utils/container.rs

@@ -204,6 +204,12 @@ impl<'a> Fields<'a> {
                                             ));
                                         }
                                     },
+                                    name: field.node.name.node.as_str(),
+                                    alias: field
+                                        .node
+                                        .alias
+                                        .as_ref()
+                                        .map(|alias| alias.node.as_str()),
                                 };
 
                                 let resolve_fut = root.resolve_field(&ctx_field);

src/resolver_utils/list.rs

@@ -23,6 +23,8 @@ pub async fn resolve_list<'a, T: OutputType + 'a>(
                         path_node: ctx_idx.path_node.as_ref().unwrap(),
                         parent_type: &Vec::<T>::type_name(),
                         return_type: &T::qualified_type_name(),
+                        name: field.node.name.node.as_str(),
+                        alias: field.node.alias.as_ref().map(|alias| alias.node.as_str()),
                     };
                     let resolve_fut = async {
                         OutputType::resolve(&item, &ctx_idx, field)