feat: add directive support to generator (#1139)

In #900 I added directives support to the QueryFragment derive. However
I didn't add support to the generator. This adds that support.

Fixes #1137

Author: obmarg

Cargo.toml

@@ -40,13 +40,15 @@ version = "3.10.0"
 rust-version = "1.80"
 
 [workspace.dependencies]
-cynic-parser = { path = "cynic-parser", version = "0.9" }
-cynic-parser-deser-macros = { path = "cynic-parser-deser-macros", version = "0.9" }
 darling = "0.20"
-graphql-mocks.path = "graphql-mocks"
+insta = { version = "1", features = ["yaml", "json"] }
 rstest = "0.23"
 syn = "2"
 
+cynic-parser = { path = "cynic-parser", version = "0.9" }
+cynic-parser-deser-macros = { path = "cynic-parser-deser-macros", version = "0.9" }
+graphql-mocks.path = "graphql-mocks"
+
 [profile.dev]
 # Disabling debug info speeds up builds a bunch,
 # and we don't rely on it for debugging that much.

cynic-codegen/Cargo.toml

@@ -26,14 +26,14 @@ ouroboros = "0.18"
 proc-macro2 = "1.0"
 quote = "1.0"
 strsim = "0.10.0"
-syn = { workspace = true , features = ["visit-mut"] }
+syn = { workspace = true, features = ["visit-mut"] }
 thiserror = "1"
 
 rkyv = { version = "0.7.41", features = ["validation"], optional = true }
 
 [dev-dependencies]
 assert_matches = "1.4.0"
-insta = "1.17"
+insta.workspace = true
 maplit = "1.0.2"
 rstest.workspace = true
 

cynic-introspection/Cargo.toml

@@ -28,7 +28,7 @@ version = "3"
 [dev-dependencies]
 assert_matches = "1.4"
 graphql-mocks.workspace = true
-insta = "1.4"
+insta.workspace = true
 maplit = "1.0.2"
 tokio = { version = "1", features = ["macros"] }
 reqwest = "0.12"

cynic-parser/Cargo.toml

@@ -32,7 +32,7 @@ ariadne = { version = "0.4", optional = true }
 pretty = { version = "0.12", optional = true }
 
 [dev-dependencies]
-insta = "1.29"
+insta.workspace = true
 similar-asserts = "1.5"
 
 # Tests need the `pretty` functionality so enable it here

cynic-querygen/Cargo.toml

@@ -23,5 +23,5 @@ cynic-parser.workspace = true
 
 [dev-dependencies]
 assert_matches = "1.4"
-insta = "1.17.1"
+insta.workspace = true
 rstest.workspace = true

cynic-querygen/src/lib.rs

@@ -29,6 +29,9 @@ pub enum Error {
     #[error("could not find type `{0}`")]
     UnknownType(String),
 
+    #[error("could not find directive `{0}`")]
+    UnknownDirective(String),
+
     #[error("expected type `{0}` to be an object")]
     ExpectedObject(String),
 

cynic-querygen/src/output/query_fragment.rs

@@ -3,7 +3,7 @@ use std::fmt::Write;
 use crate::{
     casings::CasingExt,
     output::{attr_output::Attributes, field::rust_field_name},
-    query_parsing::LiteralContext,
+    query_parsing::{Directive, LiteralContext},
     schema::{InputType, TypeSpec},
 };
 
@@ -56,6 +56,7 @@ pub struct OutputField<'query, 'schema> {
     pub field_type: RustOutputFieldType,
 
     pub arguments: Vec<FieldArgument<'query, 'schema>>,
+    pub directives: Vec<Directive<'query, 'schema>>,
 }
 
 impl std::fmt::Display for OutputField<'_, '_> {
@@ -72,6 +73,35 @@ impl std::fmt::Display for OutputField<'_, '_> {
 
             writeln!(f, "#[arguments({})]", arguments_string)?;
         }
+        if !self.directives.is_empty() {
+            let directive_string = self
+                .directives
+                .iter()
+                .map(|directive| {
+                    let Directive { name, arguments } = directive;
+                    if arguments.is_empty() {
+                        return name.to_string();
+                    }
+                    let argument_strings = arguments
+                        .iter()
+                        .map(|argument| {
+                            Ok(format!(
+                                "{}: {}",
+                                argument.name,
+                                argument.value.to_literal(LiteralContext::Argument)?
+                            ))
+                        })
+                        .collect::<Result<Vec<_>, Error>>()
+                        .unwrap()
+                        .join(", ");
+
+                    format!("{name}({argument_strings})")
+                })
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            writeln!(f, "#[directives({directive_string})]")?;
+        }
 
         let name = self.name.to_snake_case();
         let type_spec = TypeSpec {

cynic-querygen/src/query_parsing/mod.rs

@@ -9,7 +9,7 @@ mod variables;
 
 use variables::VariableStructDetails;
 
-pub use normalisation::Variable;
+pub use normalisation::{Directive, Variable};
 pub use value::{LiteralContext, TypedValue};
 
 use cynic_parser::{executable as parser, ExecutableDocument};
@@ -121,11 +121,12 @@ fn make_query_fragment<'text>(
                     arguments: field
                         .arguments
                         .iter()
-                        .map(|(name, value)| -> Result<FieldArgument, Error> {
-                            Ok(FieldArgument::new(name, value.clone()))
+                        .map(|argument| -> Result<FieldArgument, Error> {
+                            Ok(FieldArgument::new(argument.name, argument.value.clone()))
                         })
                         .collect::<Result<Vec<_>, _>>()
                         .unwrap(),
+                    directives: field.directives.clone(),
                 }
             })
             .collect(),

cynic-querygen/src/query_parsing/normalisation.rs

@@ -57,11 +57,25 @@ pub struct FieldSelection<'query, 'schema> {
 
     pub schema_field: OutputField<'schema>,
 
-    pub arguments: Vec<(&'schema str, TypedValue<'query, 'schema>)>,
+    pub arguments: Vec<Argument<'query, 'schema>>,
+
+    pub directives: Vec<Directive<'query, 'schema>>,
 
     pub field: Field<'query, 'schema>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Argument<'query, 'schema> {
+    pub name: &'schema str,
+    pub value: TypedValue<'query, 'schema>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Directive<'query, 'schema> {
+    pub name: &'schema str,
+    pub arguments: Vec<Argument<'query, 'schema>>,
+}
+
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Field<'query, 'schema> {
     /// A composite field contains another selection set.
@@ -94,14 +108,16 @@ impl<'query, 'schema> FieldSelection<'query, 'schema> {
     fn new(
         name: &'query str,
         alias: Option<&'query str>,
-        arguments: Vec<(&'schema str, TypedValue<'query, 'schema>)>,
+        arguments: Vec<Argument<'query, 'schema>>,
+        directives: Vec<Directive<'query, 'schema>>,
         schema_field: OutputField<'schema>,
         field: Field<'query, 'schema>,
     ) -> FieldSelection<'query, 'schema> {
         FieldSelection {
             name,
             alias,
             arguments,
+            directives,
             schema_field,
             field,
         }
@@ -278,29 +294,43 @@ impl<'a, 'docs> Normaliser<'a, 'docs> {
 
                 let mut arguments = Vec::new();
                 for argument in field.arguments() {
-                    let name = argument.name();
-                    let value = argument.value();
-
-                    let schema_arg = schema_field
-                        .arguments
-                        .iter()
-                        .find(|arg| arg.name == name)
-                        .ok_or_else(|| dbg!(Error::UnknownArgument(name.to_string())))?;
-
-                    arguments.push((
-                        schema_arg.name,
-                        TypedValue::from_query_value(
-                            value,
-                            schema_arg.value_type.clone(),
-                            &self.variables,
-                        )?,
-                    ));
+                    arguments.push(self.convert_argument(&schema_field, argument)?);
                 }
 
+                let directives = field
+                    .directives()
+                    .map(|directive| {
+                        let name = directive.name();
+                        let schema_directive = self.type_index.directive(name)?;
+
+                        let mut arguments = Vec::new();
+                        for argument in directive.arguments() {
+                            let name = argument.name();
+                            let schema_arg = schema_directive
+                                .arguments()
+                                .find(|arg| arg.name() == name)
+                                .ok_or_else(|| Error::UnknownArgument(name.to_string()))?;
+
+                            arguments.push(Argument {
+                                name,
+                                value: TypedValue::from_query_value(
+                                    argument.value(),
+                                    InputFieldType::from_parser(schema_arg.ty(), self.type_index),
+                                    &self.variables,
+                                )?,
+                            });
+                        }
+
+                        dbg!(&arguments);
+                        Ok(Directive { name, arguments })
+                    })
+                    .collect::<Result<_, Error>>()?;
+
                 Ok(vec![Selection::Field(FieldSelection::new(
                     field.name(),
                     field.alias(),
                     arguments,
+                    directives,
                     schema_field,
                     inner_field,
                 ))])
@@ -343,6 +373,29 @@ impl<'a, 'docs> Normaliser<'a, 'docs> {
         }
     }
 
+    fn convert_argument(
+        &self,
+        schema_field: &OutputField<'docs>,
+        argument: parser::Argument<'docs>,
+    ) -> Result<Argument<'docs, 'docs>, Error> {
+        let name = argument.name();
+        let value = argument.value();
+        let schema_arg = schema_field
+            .arguments
+            .iter()
+            .find(|arg| arg.name == name)
+            .ok_or_else(|| dbg!(Error::UnknownArgument(name.to_string())))?;
+
+        Ok(Argument {
+            name: schema_arg.name,
+            value: TypedValue::from_query_value(
+                value,
+                schema_arg.value_type.clone(),
+                &self.variables,
+            )?,
+        })
+    }
+
     fn normalise_abstract_selection_set(
         &mut self,
         selection_set: Iter<'docs, parser::Selection<'docs>>,
@@ -489,7 +542,7 @@ impl<'schema> SelectionSet<'_, 'schema> {
                 field
                     .arguments
                     .iter()
-                    .map(|(_, arg)| arg.value_type().inner_ref().clone())
+                    .map(|arg| arg.value.value_type().inner_ref().clone())
                     .collect::<Vec<_>>()
             })
             .collect()

cynic-querygen/src/query_parsing/snapshots/cynic_querygen__query_parsing__normalisation__tests__check_fragment_spread_output.snap

@@ -1,7 +1,7 @@
 ---
 source: cynic-querygen/src/query_parsing/normalisation.rs
-assertion_line: 700
-expression: film_selections.get(0).unwrap().selections
+expression: film_selections.first().unwrap().selections
+snapshot_kind: text
 ---
 [
     Field(
@@ -20,6 +20,7 @@ expression: film_selections.get(0).unwrap().selections
                 arguments: [],
             },
             arguments: [],
+            directives: [],
             field: Leaf,
         },
     ),
@@ -37,6 +38,7 @@ expression: film_selections.get(0).unwrap().selections
                 arguments: [],
             },
             arguments: [],
+            directives: [],
             field: Leaf,
         },
     ),