Merge pull request #6 from tomhoule/unions

Implement a local type for query selections

Author: tomhoule

graphql_query_derive/src/lib.rs

@@ -25,6 +25,7 @@ mod introspection_response;
 mod objects;
 mod query;
 mod schema;
+mod selection;
 mod shared;
 mod unions;
 

graphql_query_derive/src/query.rs

@@ -27,6 +27,19 @@ impl QueryContext {
         }
     }
 
+    /// For testing only. creates an empty QueryContext with an empty Schema.
+    #[cfg(test)]
+    pub fn new_empty() -> QueryContext {
+        QueryContext {
+            _subscription_root: None,
+            fragments: BTreeMap::new(),
+            mutation_root: None,
+            query_root: None,
+            schema: Schema::new(),
+            variables: BTreeMap::new(),
+        }
+    }
+
     pub fn maybe_expand_field(
         &self,
         field: &query::Field,

graphql_query_derive/src/selection.rs

@@ -0,0 +1,143 @@
+use graphql_parser::query::SelectionSet;
+
+#[derive(Debug, PartialEq)]
+pub struct SelectionField {
+    name: String,
+    fields: Selection,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SelectionFragmentSpread {
+    fragment_name: String,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SelectionInlineFragment {
+    on: String,
+    fields: Selection,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum SelectionItem {
+    Field(SelectionField),
+    FragmentSpread(SelectionFragmentSpread),
+    InlineFragment(SelectionInlineFragment),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Selection(Vec<SelectionItem>);
+
+impl<'a> ::std::convert::From<&'a SelectionSet> for Selection {
+    fn from(selection_set: &SelectionSet) -> Selection {
+        use graphql_parser::query::Selection;
+
+        let mut items = Vec::new();
+
+        for item in selection_set.items.iter() {
+            let converted = match item {
+                Selection::Field(f) => SelectionItem::Field(SelectionField {
+                    name: f.name.to_string(),
+                    fields: (&f.selection_set).into(),
+                }),
+                Selection::FragmentSpread(spread) => {
+                    SelectionItem::FragmentSpread(SelectionFragmentSpread {
+                        fragment_name: spread.fragment_name.to_string(),
+                    })
+                }
+                Selection::InlineFragment(inline) => {
+                    SelectionItem::InlineFragment(SelectionInlineFragment {
+                        on: inline
+                            .type_condition
+                            .clone()
+                            .expect("missing \"on\" clause")
+                            .to_string()
+                            .replace("on ", ""),
+                        fields: (&inline.selection_set).into(),
+                    })
+                }
+            };
+            items.push(converted);
+        }
+
+        Selection(items)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use graphql_parser;
+
+    #[test]
+    fn selection_from_graphql_parser_selection_set() {
+        let query = r##"
+        query {
+          animal {
+            isCat
+            isHorse
+            ...Timestamps
+            barks
+            ...on Dog {
+                rating
+            }
+            pawsCount
+          }
+        }
+        "##;
+        let parsed = graphql_parser::parse_query(query).unwrap();
+        let selection_set: &graphql_parser::query::SelectionSet = parsed
+            .definitions
+            .iter()
+            .filter_map(|def| {
+                if let graphql_parser::query::Definition::Operation(
+                    graphql_parser::query::OperationDefinition::Query(q),
+                ) = def
+                {
+                    Some(&q.selection_set)
+                } else {
+                    None
+                }
+            })
+            .next()
+            .unwrap();
+
+        let selection: Selection = selection_set.into();
+
+        assert_eq!(
+            selection,
+            Selection(vec![SelectionItem::Field(SelectionField {
+                name: "animal".to_string(),
+                fields: Selection(vec![
+                                  SelectionItem::Field(SelectionField {
+                                      name: "isCat".to_string(),
+                                      fields: Selection(Vec::new()),
+                                  }),
+                                  SelectionItem::Field(SelectionField {
+                                      name: "isHorse".to_string(),
+                                      fields: Selection(Vec::new()),
+                                  }),
+                                SelectionItem::FragmentSpread(SelectionFragmentSpread {
+                                      fragment_name: "Timestamps".to_string(),
+                                  }),
+                                  SelectionItem::Field(SelectionField {
+                                      name: "barks".to_string(),
+                                      fields: Selection(Vec::new()),
+                                  }),
+                                SelectionItem::InlineFragment(SelectionInlineFragment {
+                                      on: "Dog".to_string(),
+                                      fields: Selection(vec![
+                                  SelectionItem::Field(SelectionField {
+                                      name: "rating".to_string(),
+                                      fields: Selection(Vec::new()),
+                                  }),
+                                      ]),
+                                  }),
+                                  SelectionItem::Field(SelectionField {
+                                      name: "pawsCount".to_string(),
+                                      fields: Selection(Vec::new()),
+                                  }),
+                ]),
+            })])
+        );
+    }
+}

graphql_query_derive/src/unions.rs

@@ -16,3 +16,13 @@ impl GqlUnion {
         unimplemented!("union generation")
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn union_response_for_selection_works() {
+        // unimplemented!()
+    }
+
+}