feat: add variable inlining to OperationBuilder (#1012)

#### Why are we making this change?

Now that a49710 is merged it's quite easy to extract an `InputLiteral`
from a `QueryVariables` struct by the name of the variable. This makes
it very easy to add variable inlining as a first class feature, rather
than recommending post-processing as in #1007.

#### What effects does this change have?

Adds a new `build_with_variables_inlined` function to `OperationBuilder`
that is available when `Variables` implements `QueryVariableLiterals`.
This will return an `Operation` with no variables entry and all the
variables added into the `query` string as arguments.

I had wanted to do this as a setting inside the builder, but getting the
types to work with that was tricky - so another build function seemed
the best option.

cynic/src/operation/builder.rs

@@ -3,7 +3,7 @@ use std::{borrow::Cow, collections::HashSet, marker::PhantomData};
 use crate::{
     queries::{build_executable_document, OperationType},
     schema::{MutationRoot, QueryRoot, SubscriptionRoot},
-    QueryFragment, QueryVariables,
+    QueryFragment, QueryVariableLiterals, QueryVariables,
 };
 
 use super::Operation;
@@ -104,12 +104,38 @@ where
                 self.operation_kind,
                 self.operation_name.as_deref(),
                 self.features.clone(),
+                None,
             ),
             variables: self.variables.ok_or(OperationBuildError::VariablesNotSet)?,
             operation_name: self.operation_name,
             phantom: PhantomData,
         })
     }
+
+    /// Builds an Operation with all of the current variables inlined into the executable document
+    /// as arguments.
+    ///
+    /// You should derive `QueryVariableLiterals` on your `QueryArguments` struct to use this
+    /// functionality.
+    pub fn build_with_variables_inlined(
+        self,
+    ) -> Result<super::Operation<Fragment, ()>, OperationBuildError>
+    where
+        Variables: QueryVariableLiterals,
+    {
+        let variables = self.variables.ok_or(OperationBuildError::VariablesNotSet)?;
+        Ok(Operation {
+            query: build_executable_document::<Fragment, Variables>(
+                self.operation_kind,
+                self.operation_name.as_deref(),
+                self.features.clone(),
+                Some(&variables),
+            ),
+            variables: (),
+            operation_name: self.operation_name,
+            phantom: PhantomData,
+        })
+    }
 }
 
 #[derive(thiserror::Error, Debug)]

cynic/src/queries/builders.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, collections::HashSet, marker::PhantomData, sync::mpsc::Sender};
 
-use crate::{coercions::CoercesTo, schema, variables::VariableDefinition};
+use crate::{coercions::CoercesTo, schema, variables::VariableDefinition, QueryVariableLiterals};
 
 use super::{ast::*, to_input_literal, FlattensInto, IsFieldType, Recursable};
 
@@ -43,6 +43,7 @@ impl<'a, SchemaType, VariablesFields> SelectionBuilder<'a, SchemaType, Variables
         selection_set: &'a mut SelectionSet,
         variables_used: &'a Sender<&'static str>,
         features_enabled: &'a HashSet<String>,
+        inline_variables: Option<&'a dyn QueryVariableLiterals>,
     ) -> Self {
         SelectionBuilder::private_new(
             selection_set,
@@ -51,6 +52,7 @@ impl<'a, SchemaType, VariablesFields> SelectionBuilder<'a, SchemaType, Variables
                 overall_depth: 0,
                 features_enabled,
                 variables_used,
+                inline_variables,
             },
         )
     }
@@ -273,12 +275,22 @@ impl<'a, SchemaType, VariablesFields> InputBuilder<'a, SchemaType, VariablesFiel
     where
         Type: CoercesTo<SchemaType>,
     {
-        self.context
-            .variables_used
-            .send(def.name)
-            .expect("the variables_used channel to be open");
-
-        self.destination.push(InputLiteral::Variable(def.name));
+        match &self.context.inline_variables {
+            None => {
+                self.context
+                    .variables_used
+                    .send(def.name)
+                    .expect("the variables_used channel to be open");
+
+                self.destination.push(InputLiteral::Variable(def.name));
+            }
+            Some(variables) => {
+                // If the variable returns None we assume it hit a skip_serializing_if and skip it
+                if let Some(literal) = variables.get(def.name) {
+                    self.destination.push(literal);
+                }
+            }
+        }
     }
 }
 
@@ -443,6 +455,7 @@ struct BuilderContext<'a> {
     variables_used: &'a Sender<&'static str>,
     recurse_depth: Option<u8>,
     overall_depth: u16,
+    inline_variables: Option<&'a dyn QueryVariableLiterals>,
 }
 
 impl BuilderContext<'_> {

cynic/src/queries/mod.rs

@@ -11,6 +11,8 @@ mod variables;
 
 use variables::VariableDefinitions;
 
+use crate::QueryVariableLiterals;
+
 pub use self::{
     ast::{Argument, InputLiteral, SelectionSet},
     builders::{SelectionBuilder, VariableMatch},
@@ -36,6 +38,7 @@ pub fn build_executable_document<Fragment, Variables>(
     r#type: OperationType,
     operation_name: Option<&str>,
     features_enabled: HashSet<String>,
+    inline_variables: Option<&dyn QueryVariableLiterals>,
 ) -> String
 where
     Fragment: crate::QueryFragment,
@@ -48,6 +51,7 @@ where
         &mut selection_set,
         &variable_tx,
         &features_enabled,
+        inline_variables,
     );
 
     Fragment::query(builder);

cynic/tests/variables.rs

@@ -1,6 +1,6 @@
 use serde_json::json;
 
-#[derive(cynic::QueryVariables)]
+#[derive(cynic::QueryVariables, cynic::QueryVariableLiterals)]
 struct TestArgs<'a> {
     #[cynic(skip_serializing_if = "Option::is_none")]
     a_str: Option<&'a str>,
@@ -54,6 +54,63 @@ fn test_unused_variables_not_rendered() {
     "###);
 }
 
+mod variable_inlining {
+    use cynic::OperationBuilder;
+
+    use super::{schema, TestArgs, TestArgsFields};
+
+    #[derive(cynic::QueryFragment, PartialEq, Debug)]
+    #[cynic(schema_path = "../schemas/simple.graphql", variables = "TestArgs")]
+    struct TestStruct {
+        #[arguments(x: 1, y: $a_str)]
+        field_one: String,
+    }
+
+    #[derive(cynic::QueryFragment, PartialEq, Debug)]
+    #[cynic(
+        schema_path = "../schemas/simple.graphql",
+        graphql_type = "Query",
+        variables = "TestArgs"
+    )]
+    struct QueryWithArguments {
+        test_struct: Option<TestStruct>,
+    }
+
+    #[test]
+    fn test_variable_inlining() {
+        let operation = OperationBuilder::<QueryWithArguments, TestArgs<'_>>::query()
+            .with_variables(TestArgs {
+                a_str: Some("boom, this is interpolated"),
+            })
+            .build_with_variables_inlined()
+            .unwrap();
+
+        insta::assert_display_snapshot!(operation.query, @r###"
+        query QueryWithArguments {
+          testStruct {
+            fieldOne(x: 1, y: "boom, this is interpolated")
+          }
+        }
+        "###);
+    }
+
+    #[test]
+    fn test_skip_serializing_if_none_for_inlines() {
+        let operation = OperationBuilder::<QueryWithArguments, TestArgs<'_>>::query()
+            .with_variables(TestArgs { a_str: None })
+            .build_with_variables_inlined()
+            .unwrap();
+
+        insta::assert_display_snapshot!(operation.query, @r###"
+        query QueryWithArguments {
+          testStruct {
+            fieldOne(x: 1)
+          }
+        }
+        "###);
+    }
+}
+
 mod schema {
     cynic::use_schema!("../schemas/simple.graphql");
 }