feat: accept directives in schema

Author: gabotechs

graphqxl_parser/src/ast_schema.rs

@@ -1,14 +1,16 @@
 use crate::ast_description::{parse_description_and_continue, DescriptionAndNext};
+use crate::ast_directive::parse_directive;
 use crate::ast_identifier::{parse_identifier, Identifier};
 use crate::parser::Rule;
 use crate::utils::{unknown_rule_error, OwnedSpan};
+use crate::Directive;
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct Schema {
     pub span: OwnedSpan,
     pub description: String,
-    // TODO: add directives
+    pub directives: Vec<Directive>,
     pub query: Identifier,
     pub mutation: Identifier,
     pub subscription: Identifier,
@@ -38,6 +40,11 @@ impl Schema {
         self.description = description.to_string();
         self.clone()
     }
+
+    pub fn directive(&mut self, directive: Directive) -> Self {
+        self.directives.push(directive);
+        self.clone()
+    }
 }
 
 enum SchemaKey {
@@ -68,11 +75,16 @@ pub(crate) fn parse_schema(
         Rule::schema_def => {
             let span = OwnedSpan::from(pair.as_span(), file);
             let mut childs = pair.into_inner();
-            let DescriptionAndNext(description, next) =
+            let DescriptionAndNext(description, mut next) =
                 parse_description_and_continue(&mut childs, file);
             let mut query = Identifier::from("");
             let mut mutation = Identifier::from("");
             let mut subscription = Identifier::from("");
+            let mut directives = vec![];
+            while let Rule::directive = next.as_rule() {
+                directives.push(parse_directive(next, file)?);
+                next = childs.next().unwrap();
+            }
             for field in next.into_inner() {
                 let mut field_parts = field.into_inner();
                 let key = parse_schema_key(field_parts.next().unwrap(), file)?;
@@ -85,6 +97,7 @@ pub(crate) fn parse_schema(
             }
             Ok(Schema {
                 span,
+                directives,
                 description,
                 query,
                 mutation,
@@ -112,6 +125,27 @@ mod tests {
         )
     }
 
+    #[test]
+    fn test_accepts_directive() {
+        assert_eq!(
+            parse_input("schema @dir { query: Query }"),
+            Ok(Schema::build()
+                .query("Query")
+                .directive(Directive::build("dir")))
+        )
+    }
+
+    #[test]
+    fn test_accepts_two_directives() {
+        assert_eq!(
+            parse_input("schema @dir1 @dir2 { query: Query }"),
+            Ok(Schema::build()
+                .query("Query")
+                .directive(Directive::build("dir1"))
+                .directive(Directive::build("dir2")))
+        )
+    }
+
     #[test]
     fn test_parses_query_with_description() {
         assert_eq!(

graphqxl_parser/src/grammar.pest

@@ -5,7 +5,7 @@ filename = @{ "\"" ~ (!("\n" | "\r\n") ~ char_no_double_quote)* ~ "\"" }
 
 def = _{ schema_def | type_def | generic_type_def | input_def | generic_input_def | enum_def | interface_def | scalar_def | union_def | directive_def }
 
-schema_def = { description? ~ "schema" ~ schema_selection_set }
+schema_def = { description? ~ "schema" ~ directive* ~ schema_selection_set }
     schema_key = @{ "query" | "mutation" | "subscription" }
     schema_selection_set = { "{" ~ schema_field+ ~ "}"}
     schema_field = { schema_key ~ ":" ~ identifier }

graphqxl_synthesizer/src/synth_schema.rs

@@ -1,4 +1,5 @@
 use crate::synth_description::DescriptionSynth;
+use crate::synth_directive::DirectiveSynth;
 use crate::synths::{ChainSynth, MultilineListSynth, PairSynth, StringSynth};
 use crate::{Synth, SynthContext};
 use graphqxl_parser::Schema;
@@ -23,13 +24,16 @@ impl Synth for SchemaSynth {
         if to_include.is_empty() {
             return false;
         }
-        let pair_synth = PairSynth::top_level(
-            DescriptionSynth::text(&self.0.description),
-            ChainSynth(vec![
-                Box::new(StringSynth::from("schema ")),
-                Box::new(MultilineListSynth::no_suffix(("{", to_include, "}"))),
-            ]),
-        );
+        let mut v: Vec<Box<dyn Synth>> = vec![Box::new(StringSynth::from("schema "))];
+        for directive in self.0.directives.iter() {
+            v.push(Box::new(DirectiveSynth(directive.clone())));
+            v.push(Box::new(StringSynth::from(" ")));
+        }
+        v.push(Box::new(MultilineListSynth::no_suffix((
+            "{", to_include, "}",
+        ))));
+        let pair_synth =
+            PairSynth::top_level(DescriptionSynth::text(&self.0.description), ChainSynth(v));
         pair_synth.synth(context)
     }
 }
@@ -38,13 +42,28 @@ impl Synth for SchemaSynth {
 mod tests {
     use super::*;
     use crate::SynthConfig;
+    use graphqxl_parser::Directive;
 
     #[test]
     fn test_with_query() {
         let synth = SchemaSynth(Schema::build().query("Query"));
         assert_eq!(synth.synth_zero(), "schema {\n  query: Query\n}")
     }
 
+    #[test]
+    fn test_with_query_and_directives() {
+        let synth = SchemaSynth(
+            Schema::build()
+                .query("Query")
+                .directive(Directive::build("dir1"))
+                .directive(Directive::build("dir2")),
+        );
+        assert_eq!(
+            synth.synth_zero(),
+            "schema @dir1 @dir2 {\n  query: Query\n}"
+        )
+    }
+
     #[test]
     fn test_with_query_mutation_subscription() {
         let synth = SchemaSynth(