WIP - Start working on recursive, lazy codegen

Author: tomhoule

graphql_query_derive/src/interfaces.rs

@@ -1,3 +1,27 @@
+use field_type::FieldType;
+use graphql_parser::query;
+use objects::GqlObjectField;
+use proc_macro2::{Ident, Span, TokenStream};
+use query::QueryContext;
+
+#[derive(Debug)]
 pub struct GqlInterface {
     pub implemented_by: Vec<String>,
+    pub name: String,
+    pub fields: Vec<GqlObjectField>,
+}
+
+impl GqlInterface {
+    pub fn response_for_selection(
+        &self,
+        query_context: &QueryContext,
+        selection: &query::SelectionSet,
+        prefix: &str,
+    ) -> TokenStream {
+        let name = Ident::new(&format!("{}{}", prefix, self.name), Span::call_site());
+        quote! {
+            #[derive(Debug, Deserialize)]
+            pub struct #name;
+        }
+    }
 }

graphql_query_derive/src/lib.rs

@@ -1,4 +1,5 @@
 #![recursion_limit = "128"]
+#![feature(nll)]
 
 #[macro_use]
 extern crate failure;
@@ -20,6 +21,7 @@ mod interfaces;
 mod objects;
 mod query;
 mod schema;
+mod unions;
 
 use heck::*;
 use proc_macro2::{Ident, Span};

graphql_query_derive/src/objects.rs

@@ -1,5 +1,6 @@
 use field_type::FieldType;
 use graphql_parser::query;
+use heck::SnakeCase;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 
@@ -20,17 +21,48 @@ impl GqlObject {
         &self,
         query_context: &QueryContext,
         selection: &query::SelectionSet,
+        prefix: &str,
     ) -> TokenStream {
-        let name = Ident::new(&self.name, Span::call_site());
+        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);
         quote! {
+            #(#field_impls)*
+
             #[derive(Debug, Deserialize)]
             pub struct #name {
                 #(#fields,)*
             }
         }
     }
 
+    pub fn field_impls_for_selection(
+        &self,
+        query_context: &QueryContext,
+        selection: &query::SelectionSet,
+        prefix: &str,
+    ) -> Vec<TokenStream> {
+        let prefix = format!("{}{}", prefix, self.name);
+        selection
+            .items
+            .iter()
+            .map(|selected| {
+                if let query::Selection::Field(selected) = selected {
+                    let ty = self
+                        .fields
+                        .iter()
+                        .find(|f| f.name == selected.name)
+                        .expect("field found")
+                        .type_
+                        .inner_name_string();
+                    query_context.maybe_expand_field(&selected, &ty, &prefix)
+                } else {
+                    quote!()
+                }
+            })
+            .collect()
+    }
+
     pub fn response_fields_for_selection(
         &self,
         query_context: &QueryContext,
@@ -52,8 +84,18 @@ impl GqlObject {
                     let ty = ty.to_rust();
                     fields.push(quote!(#name: #ty));
                 }
-                query::Selection::FragmentSpread(_) => (),
-                query::Selection::InlineFragment(_) => (),
+                query::Selection::FragmentSpread(fragment) => {
+                    let field_name =
+                        Ident::new(&fragment.fragment_name.to_snake_case(), Span::call_site());
+                    let type_name = Ident::new(&fragment.fragment_name, Span::call_site());
+                    fields.push(quote!{
+                        #[serde(flatten)]
+                        #field_name: #type_name
+                    })
+                }
+                query::Selection::InlineFragment(_) => {
+                    unreachable!("inline fragment on object field")
+                }
             }
         }
 

graphql_query_derive/src/query.rs

@@ -1,23 +1,41 @@
 use field_type::FieldType;
+use graphql_parser::query;
 use proc_macro2::TokenStream;
+use schema::Schema;
 use std::collections::BTreeMap;
 
 pub struct QueryContext {
     pub _subscription_root: Option<Vec<TokenStream>>,
     pub fragments: BTreeMap<String, BTreeMap<String, FieldType>>,
     pub mutation_root: Option<Vec<TokenStream>>,
     pub query_root: Option<Vec<TokenStream>>,
+    pub schema: Schema,
     pub variables: BTreeMap<String, FieldType>,
 }
 
 impl QueryContext {
-    pub fn new() -> QueryContext {
+    pub fn new(schema: Schema) -> QueryContext {
         QueryContext {
             _subscription_root: None,
             fragments: BTreeMap::new(),
             mutation_root: None,
             query_root: None,
+            schema,
             variables: BTreeMap::new(),
         }
     }
+
+    pub fn maybe_expand_field(&self, field: &query::Field, ty: &str, prefix: &str) -> TokenStream {
+        if let Some(enm) = self.schema.enums.get(ty) {
+            enm.to_rust()
+        } else if let Some(obj) = self.schema.objects.get(ty) {
+            obj.response_for_selection(self, &field.selection_set, prefix)
+        } else if let Some(iface) = self.schema.interfaces.get(ty) {
+            iface.response_for_selection(self, &field.selection_set, prefix)
+        } else if let Some(unn) = self.schema.unions.get(ty) {
+            unn.response_for_selection(self, &field.selection_set, prefix)
+        } else {
+            quote!()
+        }
+    }
 }

graphql_query_derive/src/schema.rs

@@ -3,19 +3,21 @@ use failure;
 use field_type::FieldType;
 use graphql_parser::{self, query, schema};
 use inputs::GqlInput;
+use interfaces::GqlInterface;
 use objects::{GqlObject, GqlObjectField};
 use proc_macro2::TokenStream;
 use query::QueryContext;
 use std::collections::{BTreeMap, BTreeSet};
+use unions::GqlUnion;
 
 #[derive(Debug)]
 pub struct Schema {
     pub enums: BTreeMap<String, GqlEnum>,
     pub inputs: BTreeMap<String, GqlInput>,
-    pub interfaces: BTreeMap<String, GqlObject>,
+    pub interfaces: BTreeMap<String, GqlInterface>,
     pub objects: BTreeMap<String, GqlObject>,
     pub scalars: BTreeSet<String>,
-    pub unions: BTreeMap<String, Vec<String>>,
+    pub unions: BTreeMap<String, GqlUnion>,
     pub query_type: Option<String>,
     pub mutation_type: Option<String>,
     pub subscription_type: Option<String>,
@@ -36,38 +38,56 @@ impl Schema {
         }
     }
 
-    pub fn response_for_query(
-        &self,
-        query: query::Document,
-    ) -> Result<TokenStream, failure::Error> {
-        let mut context = QueryContext::new();
+    pub fn response_for_query(self, query: query::Document) -> Result<TokenStream, failure::Error> {
+        let mut context = QueryContext::new(self);
+        let mut definitions = Vec::new();
 
         for definition in query.definitions {
             match definition {
                 query::Definition::Operation(query::OperationDefinition::Query(q)) => {
-                    let definition = self
+                    let definition = context
+                        .schema
                         .query_type
                         .clone()
-                        .and_then(|query_type| self.objects.get(&query_type))
+                        .and_then(|query_type| context.schema.objects.get(&query_type))
                         .expect("query type is defined");
+                    definitions.extend(definition.field_impls_for_selection(
+                        &context,
+                        &q.selection_set,
+                        "",
+                    ));
                     context.query_root =
                         Some(definition.response_fields_for_selection(&context, &q.selection_set));
                 }
                 query::Definition::Operation(query::OperationDefinition::Mutation(q)) => {
-                    let definition = self
+                    let definition = context
+                        .schema
                         .mutation_type
                         .clone()
-                        .and_then(|mutation_type| self.objects.get(&mutation_type))
+                        .and_then(|mutation_type| context.schema.objects.get(&mutation_type))
                         .expect("mutation type is defined");
+                    definitions.extend(definition.field_impls_for_selection(
+                        &context,
+                        &q.selection_set,
+                        "",
+                    ));
                     context.mutation_root =
                         Some(definition.response_fields_for_selection(&context, &q.selection_set));
                 }
                 query::Definition::Operation(query::OperationDefinition::Subscription(q)) => {
-                    let definition = self
+                    let definition = context
+                        .schema
                         .subscription_type
                         .clone()
-                        .and_then(|subscription_type| self.objects.get(&subscription_type))
+                        .and_then(|subscription_type| {
+                            context.schema.objects.get(&subscription_type)
+                        })
                         .expect("subscription type is defined");
+                    definitions.extend(definition.field_impls_for_selection(
+                        &context,
+                        &q.selection_set,
+                        "",
+                    ));
                     context._subscription_root =
                         Some(definition.response_fields_for_selection(&context, &q.selection_set));
                 }
@@ -80,7 +100,7 @@ impl Schema {
             }
         }
 
-        let enum_definitions = self.enums.values().map(|enm| enm.to_rust());
+        let enum_definitions = context.schema.enums.values().map(|enm| enm.to_rust());
         let variables_struct = quote!(#[derive(Serialize)]
         pub struct Variables;);
         let response_data_fields = context
@@ -90,17 +110,11 @@ impl Schema {
             .expect("no selection defined");
 
         use proc_macro2::{Ident, Span};
-        let object_definitions = self.objects.values().map(|obj| {
-            let name = Ident::new(&obj.name, Span::call_site());
-            quote! {
-                pub struct #name;
-            }
-        });
 
         Ok(quote! {
             #(#enum_definitions)*
 
-            #(#object_definitions)*
+            #(#definitions)*
 
             #variables_struct
 
@@ -161,13 +175,14 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                         schema.scalars.insert(scalar.name);
                     }
                     schema::TypeDefinition::Union(union) => {
-                        schema.unions.insert(union.name, union.types);
+                        schema.unions.insert(union.name, GqlUnion(union.types));
                     }
                     schema::TypeDefinition::Interface(interface) => {
                         schema.interfaces.insert(
                             interface.name.clone(),
-                            GqlObject {
+                            GqlInterface {
                                 name: interface.name,
+                                implemented_by: Vec::new(),
                                 fields: interface
                                     .fields
                                     .iter()

graphql_query_derive/src/unions.rs

@@ -0,0 +1,17 @@
+use graphql_parser::query;
+use proc_macro2::{Ident, Span, TokenStream};
+use query::QueryContext;
+
+#[derive(Debug)]
+pub struct GqlUnion(pub Vec<String>);
+
+impl GqlUnion {
+    pub fn response_for_selection(
+        &self,
+        query_context: &QueryContext,
+        selection: &query::SelectionSet,
+        prefix: &str,
+    ) -> TokenStream {
+        unimplemented!("union generation")
+    }
+}

src/lib.rs

@@ -1,12 +1,10 @@
-extern crate failure;
-extern crate graphql_parser;
-extern crate quote;
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 #[allow(unused_imports)]
 #[macro_use]
 extern crate graphql_query_derive;
+
 #[doc(hidden)]
 pub use graphql_query_derive::*;
 
@@ -18,7 +16,7 @@ pub trait GraphQLQuery<'de> {
     fn build_query(variables: Self::Variables) -> GraphQLQueryBody<Self::Variables>;
 }
 
-#[derive(Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct GraphQLQueryBody<Variables>
 where
     Variables: serde::Serialize,
@@ -27,37 +25,13 @@ where
     query: &'static str,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
 pub struct GraphQLError {
     pub path: String,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
 pub struct GraphQLResponse<Data> {
     pub data: Option<Data>,
     pub errors: Option<Vec<GraphQLError>>,
 }
-
-#[cfg(test)]
-mod tests {
-
-    macro_rules! assert_parses_to {
-        ($query:expr, $schema:expr => $expected:tt) => {
-            unimplemented!()
-        };
-    }
-
-    macro_rules! assert_mismatch {
-        ($query:expr, $schema:expr) => {
-            unimplemented!()
-        };
-    }
-
-    #[test]
-    fn queries_parse_properly() {
-        assert_eq!(2 + 2, 4);
-    }
-
-    #[test]
-    fn invalid_queries_are_rejected() {
-        unimplemented!();
-    }
-}