WIP - derive from json

Author: tomhoule

graphql_query_derive/Cargo.toml

@@ -13,5 +13,6 @@ syn = "*"
 proc-macro2 = { version = "*", features = ["nightly"] }
 serde = "1.0"
 serde_derive = "1.0"
+serde_json = "1.0"
 heck = "*"
 graphql-parser = "*"

graphql_query_derive/src/interfaces.rs

@@ -3,7 +3,7 @@ use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct GqlInterface {
     pub implemented_by: Vec<String>,
     pub name: String,
@@ -14,7 +14,7 @@ impl GqlInterface {
     pub fn response_for_selection(
         &self,
         _query_context: &QueryContext,
-        selection: &query::SelectionSet,
+        _selection: &query::SelectionSet,
         prefix: &str,
     ) -> TokenStream {
         let name = Ident::new(&prefix, Span::call_site());

graphql_query_derive/src/introspection_response.rs

@@ -2,14 +2,8 @@
 
 use serde;
 
-struct IntrospectionQuery;
-
 type Boolean = bool;
 
-type Float = f64;
-
-type Int = i64;
-
 #[derive(Debug)]
 pub enum __DirectiveLocation {
     QUERY,
@@ -133,15 +127,16 @@ impl<'de> ::serde::Deserialize<'de> for __TypeKind {
 }
 
 #[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct FullType {
-    kind: Option<__TypeKind>,
-    name: Option<String>,
-    description: Option<String>,
-    fields: Option<Vec<Option<FullTypeFields>>>,
-    inputFields: Option<Vec<Option<FullTypeInputFields>>>,
-    interfaces: Option<Vec<Option<FullTypeInterfaces>>>,
-    enumValues: Option<Vec<Option<FullTypeEnumValues>>>,
-    possible_types: Option<Vec<Option<FullTypePossibleTypes>>>,
+    pub kind: Option<__TypeKind>,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub fields: Option<Vec<Option<FullTypeFields>>>,
+    pub input_fields: Option<Vec<Option<FullTypeInputFields>>>,
+    pub interfaces: Option<Vec<Option<FullTypeInterfaces>>>,
+    pub enum_values: Option<Vec<Option<FullTypeEnumValues>>>,
+    pub possible_types: Option<Vec<Option<FullTypePossibleTypes>>>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -167,7 +162,7 @@ pub struct FullTypeFields {
     #[serde(rename = "type")]
     type_: Option<FullTypeFieldsType>,
     is_deprecated: Option<Boolean>,
-    deprecationReason: Option<String>,
+    deprecation_reason: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -184,13 +179,13 @@ pub struct FullTypeInterfaces {
     type_ref: TypeRef,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FullTypeEnumValues {
-    name: Option<String>,
-    description: Option<String>,
-    is_deprecated: Option<Boolean>,
-    deprecation_reason: Option<String>,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub is_deprecated: Option<Boolean>,
+    pub deprecation_reason: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -302,7 +297,7 @@ pub struct RustIntrospectionQuerySchemaSubscriptionType {
 #[serde(rename_all = "camelCase")]
 pub struct RustIntrospectionQuerySchemaTypes {
     #[serde(flatten)]
-    full_type: FullType,
+    pub full_type: FullType,
 }
 
 #[derive(Debug, Deserialize)]
@@ -324,14 +319,20 @@ pub struct RustIntrospectionQuerySchemaDirectives {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RustIntrospectionQuerySchema {
-    query_type: Option<RustIntrospectionQuerySchemaQueryType>,
-    mutation_type: Option<RustIntrospectionQuerySchemaMutationType>,
-    subscription_type: Option<RustIntrospectionQuerySchemaSubscriptionType>,
-    types: Option<Vec<Option<RustIntrospectionQuerySchemaTypes>>>,
+    pub query_type: Option<RustIntrospectionQuerySchemaQueryType>,
+    pub mutation_type: Option<RustIntrospectionQuerySchemaMutationType>,
+    pub subscription_type: Option<RustIntrospectionQuerySchemaSubscriptionType>,
+    pub types: Option<Vec<Option<RustIntrospectionQuerySchemaTypes>>>,
     directives: Option<Vec<Option<RustIntrospectionQuerySchemaDirectives>>>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct Schema {
-    __Schema: Option<RustIntrospectionQuerySchema>,
+    #[serde(rename = "__schema")]
+    pub schema: Option<RustIntrospectionQuerySchema>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct IntrospectionResponse {
+    pub data: Schema
 }

graphql_query_derive/src/lib.rs

@@ -10,6 +10,7 @@ extern crate proc_macro2;
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;
+extern crate serde_json;
 extern crate syn;
 #[macro_use]
 extern crate quote;
@@ -28,6 +29,9 @@ mod schema;
 mod shared;
 mod unions;
 
+#[cfg(test)]
+mod tests;
+
 use heck::*;
 use proc_macro2::{Ident, Span};
 
@@ -55,11 +59,23 @@ fn impl_gql_query(input: &syn::DeriveInput) -> Result<TokenStream, failure::Erro
     let query = graphql_parser::parse_query(&query_string)?;
 
     // We need to qualify the schema with the path to the crate it is part of
-    let schema_path = format!("{}/{}", cargo_manifest_dir, schema_path);
+    let schema_path = ::std::path::Path::new(&cargo_manifest_dir).join(schema_path);
     let mut schema_string = String::new();
-    ::std::fs::File::open(schema_path)?.read_to_string(&mut schema_string)?;
-    let schema = graphql_parser::schema::parse_schema(&schema_string)?;
-    let schema = schema::Schema::from(schema);
+    ::std::fs::File::open(&schema_path)?.read_to_string(&mut schema_string)?;
+
+    let extension = schema_path.extension().and_then(|e| e.to_str()).unwrap_or("INVALID");
+
+    let schema = match extension {
+        "graphql" | "gql" => {
+            let s = graphql_parser::schema::parse_schema(&schema_string)?;
+            schema::Schema::from(s)
+        }
+        "json" => {
+            let parsed: introspection_response::IntrospectionResponse = ::serde_json::from_str(&schema_string)?;
+            schema::Schema::from(parsed)
+        }
+        extension => panic!("Unsupported extension for the GraphQL schema: {} (only .json and .graphql are supported)", extension)
+    };
 
     let module_name = Ident::new(&input.ident.to_string().to_snake_case(), Span::call_site());
     let struct_name = &input.ident;

graphql_query_derive/src/objects.rs

@@ -111,50 +111,3 @@ impl GqlObject {
         fields
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use graphql_parser::Pos;
-
-    #[test]
-    fn simple_object() {
-        let simple = GqlObject {
-            name: "SimpleObject".to_string(),
-            fields: vec![
-                GqlObjectField {
-                    name: "greeting".to_string(),
-                    type_: FieldType::Named(Ident::new("String", Span::call_site())),
-                },
-                GqlObjectField {
-                    name: "name".to_string(),
-                    type_: FieldType::Named(Ident::new("String", Span::call_site())),
-                },
-            ],
-        };
-
-        let pos = Pos { line: 0, column: 0 };
-
-        let selection_set = query::SelectionSet {
-            span: (pos.clone(), pos.clone()),
-            items: vec![query::Selection::Field(query::Field {
-                position: pos.clone(),
-                alias: None,
-                name: "name".to_string(),
-                arguments: vec![],
-                directives: vec![],
-                selection_set: query::SelectionSet {
-                    span: (pos.clone(), pos.clone()),
-                    items: vec![],
-                },
-            })],
-        };
-
-        assert_eq!(
-            simple
-                .response_for_selection(&mut QueryContext::new(), &selection_set)
-                .to_string(),
-            "# [ derive ( Debug , Deserialize ) ] pub struct SimpleObject { name : String , }"
-        )
-    }
-}

graphql_query_derive/src/query.rs

@@ -33,7 +33,7 @@ impl QueryContext {
         ty: &str,
         prefix: &str,
     ) -> Result<TokenStream, failure::Error> {
-        if let Some(enm) = self.schema.enums.get(ty) {
+        if let Some(_enm) = self.schema.enums.get(ty) {
             Ok(quote!()) // we already expand enums separately
         } else if let Some(obj) = self.schema.objects.get(ty) {
             obj.response_for_selection(self, &field.selection_set, prefix)

graphql_query_derive/src/schema.rs

@@ -13,7 +13,7 @@ use unions::GqlUnion;
 
 pub const DEFAULT_SCALARS: &[&'static str] = &["ID", "String", "Int", "Float", "Boolean"];
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct Schema {
     pub enums: BTreeMap<String, GqlEnum>,
     pub inputs: BTreeMap<String, GqlInput>,
@@ -257,6 +257,35 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
     }
 }
 
+impl ::std::convert::From<::introspection_response::IntrospectionResponse> for Schema {
+    fn from(src: ::introspection_response::IntrospectionResponse) -> Self {
+        use introspection_response::{__TypeKind};
+
+        let mut schema = Schema::new();
+        let root = src.data.schema.expect("__Schema is not null");
+
+        for ty in root.types.expect("types in schema").iter().filter_map(|t| t.as_ref().map(|t| &t.full_type)) {
+            match  ty.kind {
+                Some(__TypeKind::ENUM) => {
+                    let name = ty.name.clone().expect("enum name");
+                    let variants: Vec<String> = ty.enum_values.clone().expect("enum variants")
+                        .iter()
+                        .map(|t| t.clone().map(|t| t.name.expect("enum variant name")))
+                        .filter_map(|t| t)
+                        .collect();
+                    schema.enums.insert(name.clone(), GqlEnum {
+                        name,
+                        variants,
+                    });
+                }
+                _ => unimplemented!("unimplemented definition")
+            }
+        }
+
+        schema
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

graphql_query_derive/src/tests/github.rs

@@ -0,0 +1,16 @@
+use schema::Schema;
+use graphql_parser;
+use serde_json;
+
+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() {
+    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),
+    );
+}