docs(parser): example of modifying queries with parser + encoder (#346)

Co-authored-by: Renée Kooi <[email protected]>

Author: lrlna

crates/apollo-encoder/Cargo.toml

@@ -20,7 +20,7 @@ categories = [
 edition = "2021"
 
 [dependencies]
-apollo-parser = { version = "0.3.0", optional = true }
+apollo-parser = { path = "../apollo-parser", version = "0.3.0", optional = true }
 thiserror = "1.0.37"
 
 [features]

crates/apollo-parser/Cargo.toml

@@ -21,6 +21,8 @@ rowan = "0.15.5"
 
 [dev-dependencies]
 miette = { version = "3.2.0", features = ["fancy"] }
+apollo-encoder = { path = "../apollo-encoder", version = "0.3.3", features = ["apollo-parser"] }
+anyhow = "1.0.66"
 thiserror = "1.0.30"
 pretty_assertions = "0.7.1"
 annotate-snippets = "0.9.1"

crates/apollo-parser/examples/modify_query_using_parser_and_encoder.rs

@@ -0,0 +1,120 @@
+use apollo_parser::{ast, Parser};
+
+use anyhow::Result;
+
+// This example merges the two operation definitions into a single one.
+fn merge_queries() -> Result<apollo_encoder::Document> {
+    let query = r"#
+    query LaunchSite {
+      launches {
+        launches {
+          id
+          site
+        }
+      }
+    }
+
+    query AstronautInfo {
+      user
+      me
+    }
+    #";
+
+    let parser = Parser::new(query);
+    let ast = parser.parse();
+    assert_eq!(ast.errors().len(), 0);
+
+    let doc = ast.document();
+
+    let mut new_query = apollo_encoder::Document::new();
+    let mut sel_set = Vec::new();
+    for def in doc.definitions() {
+        // We want to combine all of our operations into a single one.
+        if let ast::Definition::OperationDefinition(op) = def {
+            let selections: Vec<apollo_encoder::Selection> = op
+                .selection_set()
+                .unwrap()
+                .selections()
+                .map(|sel| sel.try_into())
+                .collect::<Result<Vec<apollo_encoder::Selection>, _>>()?;
+            sel_set.extend(selections)
+        }
+    }
+
+    let op_def = apollo_encoder::OperationDefinition::new(
+        apollo_encoder::OperationType::Query,
+        apollo_encoder::SelectionSet::with_selections(sel_set),
+    );
+    new_query.operation(op_def);
+
+    Ok(new_query)
+}
+
+// This example only includes fields without the `@omitted` directive.
+fn omitted_fields() -> Result<apollo_encoder::Document> {
+    let query = r"#
+    query Products {
+      isbn @omitted
+      title
+      year @omitted
+      metadata @omitted
+      reviews
+      ...details
+    }
+
+    fragment details on ProductDetails {
+        country
+    }
+
+    #";
+
+    let parser = Parser::new(query);
+    let ast = parser.parse();
+    assert_eq!(ast.errors().len(), 0);
+
+    let doc = ast.document();
+
+    let mut new_query = apollo_encoder::Document::new();
+    for def in doc.definitions() {
+        if let ast::Definition::OperationDefinition(op) = def {
+            let mut selection_set = apollo_encoder::SelectionSet::new();
+            for selection in op.selection_set().unwrap().selections() {
+                if let ast::Selection::Field(field) = selection {
+                    if let Some(dir) = field.directives() {
+                        let omit = dir
+                            .directives()
+                            .any(|dir| dir.name().unwrap().text() == "omitted");
+                        if !omit {
+                            selection_set.selection(apollo_encoder::Selection::Field(
+                                field.clone().try_into()?,
+                            ))
+                        }
+                    } else {
+                        selection_set.selection(apollo_encoder::Selection::Field(field.try_into()?))
+                    }
+                } else {
+                    selection_set.selection(selection.try_into()?)
+                }
+            }
+            let op_def = apollo_encoder::OperationDefinition::new(
+                op.operation_type().unwrap().try_into()?,
+                selection_set,
+            );
+            new_query.operation(op_def)
+        } else if let ast::Definition::FragmentDefinition(fragment) = def {
+            new_query.fragment(fragment.try_into()?);
+        }
+    }
+
+    Ok(new_query)
+}
+
+fn main() -> Result<()> {
+    let merged = merge_queries()?;
+    println!("{}", merged);
+
+    let omitted_fields = omitted_fields()?;
+    println!("{}", omitted_fields);
+
+    Ok(())
+}