Make the simple star wars query example compile

Author: tomhoule

graphql_query_derive/src/enums.rs

@@ -31,7 +31,7 @@ impl GqlEnum {
                 fn serialize<S: serde::Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
                     ser.serialize_str(match *self {
                         #(#constructors => #variant_str,)*
-                        #name::Other(s) => s.as_str(),
+                        #name::Other(ref s) => s.as_str(),
                     })
                 }
             }

graphql_query_derive/src/field_type.rs

@@ -1,5 +1,6 @@
 use graphql_parser::schema;
 use proc_macro2::{Ident, Span, TokenStream};
+use query::QueryContext;
 
 #[derive(Debug, PartialEq)]
 pub enum FieldType {
@@ -9,15 +10,18 @@ pub enum FieldType {
 }
 
 impl FieldType {
-    pub fn to_rust(&self) -> TokenStream {
+    pub fn to_rust(&self, context: &QueryContext, prefix: &str) -> TokenStream {
         match &self {
-            FieldType::Named(name) => quote!(#name),
+            FieldType::Named(name) => {
+                let name = Ident::new(&format!("{}{}", prefix, name), Span::call_site());
+                quote!(#name)
+            }
             FieldType::Optional(inner) => {
-                let inner = inner.to_rust();
+                let inner = inner.to_rust(context, prefix);
                 quote!( Option<#inner>)
             }
             FieldType::Vector(inner) => {
-                let inner = inner.to_rust();
+                let inner = inner.to_rust(context, prefix);
                 quote!( Vec<#inner>)
             }
         }

graphql_query_derive/src/objects.rs

@@ -24,8 +24,9 @@ impl GqlObject {
         prefix: &str,
     ) -> TokenStream {
         let name = Ident::new(&format!("{}{}", prefix, self.name), Span::call_site());
-        let fields = self.response_fields_for_selection(query_context, selection);
-        let field_impls = self.field_impls_for_selection(query_context, selection, prefix);
+        let fields = self.response_fields_for_selection(query_context, selection, prefix);
+        let prefix = format!("{}{}", prefix, self.name);
+        let field_impls = self.field_impls_for_selection(query_context, selection, &prefix);
         quote! {
             #(#field_impls)*
 
@@ -42,7 +43,6 @@ impl GqlObject {
         selection: &query::SelectionSet,
         prefix: &str,
     ) -> Vec<TokenStream> {
-        let prefix = format!("{}{}", prefix, self.name);
         selection
             .items
             .iter()
@@ -67,6 +67,7 @@ impl GqlObject {
         &self,
         query_context: &QueryContext,
         selection: &query::SelectionSet,
+        prefix: &str,
     ) -> Vec<TokenStream> {
         let mut fields = Vec::new();
 
@@ -81,7 +82,7 @@ impl GqlObject {
                         .unwrap()
                         .type_;
                     let name = Ident::new(name, Span::call_site());
-                    let ty = ty.to_rust();
+                    let ty = ty.to_rust(query_context, prefix);
                     fields.push(quote!(#name: #ty));
                 }
                 query::Selection::FragmentSpread(fragment) => {

graphql_query_derive/src/schema.rs

@@ -51,13 +51,17 @@ impl Schema {
                         .clone()
                         .and_then(|query_type| context.schema.objects.get(&query_type))
                         .expect("query type is defined");
+                    let prefix = &q.name.expect("unnamed operation");
                     definitions.extend(definition.field_impls_for_selection(
                         &context,
                         &q.selection_set,
-                        "",
+                        prefix,
+                    ));
+                    context.query_root = Some(definition.response_fields_for_selection(
+                        &context,
+                        &q.selection_set,
+                        prefix,
                     ));
-                    context.query_root =
-                        Some(definition.response_fields_for_selection(&context, &q.selection_set));
                 }
                 query::Definition::Operation(query::OperationDefinition::Mutation(q)) => {
                     let definition = context
@@ -66,13 +70,18 @@ impl Schema {
                         .clone()
                         .and_then(|mutation_type| context.schema.objects.get(&mutation_type))
                         .expect("mutation type is defined");
+                    let prefix = &q.name.expect("unnamed operation");
+
                     definitions.extend(definition.field_impls_for_selection(
                         &context,
                         &q.selection_set,
-                        "",
+                        prefix,
+                    ));
+                    context.mutation_root = Some(definition.response_fields_for_selection(
+                        &context,
+                        &q.selection_set,
+                        prefix,
                     ));
-                    context.mutation_root =
-                        Some(definition.response_fields_for_selection(&context, &q.selection_set));
                 }
                 query::Definition::Operation(query::OperationDefinition::Subscription(q)) => {
                     let definition = context
@@ -83,13 +92,17 @@ impl Schema {
                             context.schema.objects.get(&subscription_type)
                         })
                         .expect("subscription type is defined");
+                    let prefix = &q.name.expect("unnamed operation");
                     definitions.extend(definition.field_impls_for_selection(
                         &context,
                         &q.selection_set,
-                        "",
+                        &prefix,
+                    ));
+                    context._subscription_root = Some(definition.response_fields_for_selection(
+                        &context,
+                        &q.selection_set,
+                        &prefix,
                     ));
-                    context._subscription_root =
-                        Some(definition.response_fields_for_selection(&context, &q.selection_set));
                 }
                 query::Definition::Operation(query::OperationDefinition::SelectionSet(_)) => {
                     unimplemented!()

src/lib.rs

@@ -21,8 +21,8 @@ pub struct GraphQLQueryBody<Variables>
 where
     Variables: serde::Serialize,
 {
-    variables: Variables,
-    query: &'static str,
+    pub variables: Variables,
+    pub query: &'static str,
 }
 
 #[derive(Debug, Serialize, Deserialize)]