Bring schema building from json and graphql to feature equivalence

Author: tomhoule

graphql_query_derive/src/field_type.rs

@@ -1,9 +1,9 @@
 use enums::ENUMS_PREFIX;
 use graphql_parser::schema;
+use introspection_response;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 use schema::DEFAULT_SCALARS;
-use introspection_response;
 
 #[derive(Debug, PartialEq)]
 pub enum FieldType {
@@ -98,15 +98,13 @@ fn from_json_type_inner(inner: &introspection_response::TypeRef, non_null: bool)
             from_json_type_inner(&inner.of_type.expect("inner type is missing"), true)
         }
         Some(__TypeKind::LIST) => {
-            from_json_type_inner(&inner.of_type.expect("inner type is missing"), false)
-        }
-        Some(_) => {
-            FieldType::Named(Ident::new(&inner.name.expect("type name"), Span::call_site()))
+            FieldType::Vector(Box::new(from_json_type_inner(&inner.of_type.expect("inner type is missing"), false)))
         }
-        None => {
-            unreachable!("non-convertible type")
-        }
-
+        Some(_) => FieldType::Named(Ident::new(
+            &inner.name.expect("type name"),
+            Span::call_site(),
+        )),
+        None => unreachable!("non-convertible type"),
     };
 
     if non_null {

graphql_query_derive/src/introspection_response.rs

@@ -176,7 +176,7 @@ pub struct FullTypeInputFields {
 #[serde(rename_all = "camelCase")]
 pub struct FullTypeInterfaces {
     #[serde(flatten)]
-    type_ref: TypeRef,
+    pub type_ref: TypeRef,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -310,10 +310,10 @@ pub struct RustIntrospectionQuerySchemaDirectivesArgs {
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RustIntrospectionQuerySchemaDirectives {
-    name: Option<String>,
-    description: Option<String>,
-    locations: Option<Vec<Option<__DirectiveLocation>>>,
-    args: Option<Vec<Option<RustIntrospectionQuerySchemaDirectivesArgs>>>,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub locations: Option<Vec<Option<__DirectiveLocation>>>,
+    pub args: Option<Vec<Option<RustIntrospectionQuerySchemaDirectivesArgs>>>,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -332,7 +332,4 @@ pub struct Schema {
     pub schema: Option<RustIntrospectionQuerySchema>,
 }
 
-#[derive(Clone, Debug, Deserialize)]
-pub struct IntrospectionResponse {
-    pub data: Schema,
-}
+pub type IntrospectionResponse = Schema;

graphql_query_derive/src/schema.rs

@@ -10,7 +10,6 @@ use proc_macro2::TokenStream;
 use query::QueryContext;
 use std::collections::{BTreeMap, BTreeSet};
 use unions::GqlUnion;
-use introspection_response;
 
 pub const DEFAULT_SCALARS: &[&'static str] = &["ID", "String", "Int", "Float", "Boolean"];
 
@@ -221,7 +220,8 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                         schema.scalars.insert(scalar.name);
                     }
                     schema::TypeDefinition::Union(union) => {
-                        schema.unions.insert(union.name, GqlUnion(union.types));
+                        let tys: BTreeSet<String> = union.types.into_iter().collect();
+                        schema.unions.insert(union.name, GqlUnion(tys));
                     }
                     schema::TypeDefinition::Interface(interface) => {
                         schema.interfaces.insert(
@@ -263,7 +263,11 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
         use introspection_response::__TypeKind;
 
         let mut schema = Schema::new();
-        let root = src.data.schema.expect("__Schema is not null");
+        let root = src.schema.expect("__Schema is not null");
+
+        // Holds which objects implement which interfaces so we can populate GqlInterface#implemented_by later.
+        // It maps interface names to a vec of implementation names.
+        let mut interface_implementations: BTreeMap<String, Vec<String>> = BTreeMap::new();
 
         for ty in root
             .types
@@ -288,10 +292,12 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                         .insert(name.clone(), GqlEnum { name, variants });
                 }
                 Some(__TypeKind::SCALAR) => {
-                    schema.scalars.insert(name);
+                    if DEFAULT_SCALARS.iter().find(|s| s == &&name.as_str()).is_none() {
+                        schema.scalars.insert(name);
+                    }
                 }
                 Some(__TypeKind::UNION) => {
-                    let variants: Vec<String> = ty
+                    let variants: BTreeSet<String> = ty
                         .possible_types
                         .clone()
                         .unwrap()
@@ -301,25 +307,57 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                     schema.unions.insert(name.clone(), GqlUnion(variants));
                 }
                 Some(__TypeKind::OBJECT) => {
+                    for implementing in ty
+                        .interfaces
+                        .clone()
+                        .unwrap_or_else(|| Vec::new())
+                        .into_iter()
+                        .filter_map(|t| t)
+                        .map(|t| t.type_ref.name)
+                    {
+                        interface_implementations
+                            .entry(implementing.expect("interface name"))
+                            .and_modify(|objects| objects.push(name.clone()))
+                            .or_insert_with(|| vec![name.clone()]);
+                    }
+
                     let fields: Vec<GqlObjectField> = ty
                         .fields
                         .clone()
                         .unwrap()
                         .into_iter()
-                        .filter_map(|t| t.map(|t| GqlObjectField {
-                            name: t.name.expect("field name"),
-                            type_: FieldType::from(t.type_.expect("field type"))
-                        }))
+                        .filter_map(|t| {
+                            t.map(|t| GqlObjectField {
+                                name: t.name.expect("field name"),
+                                type_: FieldType::from(t.type_.expect("field type")),
+                            })
+                        })
                         .collect();
-                    schema.objects.insert(name.clone(), GqlObject {
-                        name,
-                        fields,
-                    });
+                    schema
+                        .objects
+                        .insert(name.clone(), GqlObject { name, fields });
                 }
                 Some(__TypeKind::INTERFACE) => {
-                },
+                    let iface = GqlInterface {
+                        name: name.clone(),
+                        implemented_by: Vec::new(),
+                        fields: ty
+                            .fields
+                            .clone()
+                            .expect("interface fields")
+                            .into_iter()
+                            .filter_map(|f| f)
+                            .map(|f| GqlObjectField {
+                                name: f.name.expect("field name"),
+                                type_: FieldType::from(f.type_.expect("field type")),
+                            })
+                            .collect(),
+                    };
+                    schema.interfaces.insert(name, iface);
+                }
                 Some(__TypeKind::INPUT_OBJECT) => {
-                },
+                    schema.inputs.insert(name, GqlInput);
+                }
                 _ => unimplemented!("unimplemented definition"),
             }
         }

graphql_query_derive/src/tests/github.rs

@@ -1,14 +1,36 @@
 use graphql_parser;
 use schema::Schema;
 use serde_json;
+use std::collections::HashSet;
 
 const SCHEMA_JSON: &'static str = include_str!("github_schema.json");
 const SCHEMA_GRAPHQL: &'static str = include_str!("github_schema.graphql");
 
 #[test]
 fn ast_from_graphql_and_json_produce_the_same_schema() {
+    use ::std::iter::FromIterator;
     let json: ::introspection_response::IntrospectionResponse =
         serde_json::from_str(SCHEMA_JSON).unwrap();
     let graphql_parser_schema = graphql_parser::parse_schema(SCHEMA_GRAPHQL).unwrap();
-    assert_eq!(Schema::from(graphql_parser_schema), Schema::from(json),);
+    let json = Schema::from(json);
+    let gql = Schema::from(graphql_parser_schema);
+    assert_eq!(json.scalars, gql.scalars);
+    for (json, gql) in json.objects.iter().zip(gql.objects.iter()) {
+        assert_eq!(json, gql)
+    }
+    for (json, gql) in json.unions.iter().zip(gql.unions.iter()) {
+        assert_eq!(json, gql)
+    }
+    assert_eq!(json.interfaces, gql.interfaces);
+    assert_eq!(json.query_type, gql.query_type);
+    assert_eq!(json.mutation_type, gql.mutation_type);
+    assert_eq!(json.subscription_type, gql.subscription_type);
+    assert_eq!(json.inputs, gql.inputs);
+    for ((json_name, json_value), (gql_name, gql_value)) in json.enums.iter().zip(gql.enums.iter()) {
+        assert_eq!(json_name, gql_name);
+        assert_eq!(
+            HashSet::<&String>::from_iter(json_value.variants.iter()),
+            HashSet::<&String>::from_iter(gql_value.variants.iter()),
+        );
+    }
 }