fix: support &str for String input fields (#1160)

Previously this would cause a compile error as we generated a type
marker of `&Option<str>` rather than `Option<&str>` - which would fail
as the `Option<T>` has a `T: Sized` bound.

Author: obmarg

cynic-codegen/src/types/alignment.rs

@@ -5,6 +5,8 @@
 //! that are optional in rust but required in graphql - this is allowed,
 //! but we need to do a bit of work for rust to be ok with it.
 
+use std::borrow::Cow;
+
 use syn::parse_quote;
 
 use crate::schema::types::{InputType, OutputType, TypeRef};
@@ -71,11 +73,38 @@ fn align_input_type_impl<'a>(
     gql_field_has_default: bool,
 ) -> RustType<'a> {
     match (&ty, &gql_ty) {
-        (RustType::Ref { inner, .. }, _) => {
-            // Transform the inner types
-            let new_inner = align_input_type_impl(inner.as_ref(), gql_ty, gql_field_has_default);
-            ty.clone().replace_inner(new_inner)
+        (RustType::Ref { inner, syn, span }, _) => {
+            // We need to be careful with lifetimes - if we're doing any additional wrapping we need to
+            // make sure that the reference goes _inside_ the wrapper, as otherwise we might end up
+            // putting an unsized type inside an Option.  e.g. `&'a Option<str>` which won't compile...
+            match (inner.as_ref(), gql_ty) {
+                (RustType::SimpleType { .. }, TypeRef::List(_)) => {
+                    let syn = Cow::Owned(parse_quote! { ::std::vec::Vec<#syn> });
+                    let wrapped_rust_type = RustType::List {
+                        syn,
+                        inner: Box::new(ty.clone()),
+                        span: *span,
+                    };
+                    align_input_type_impl(&wrapped_rust_type, gql_ty, false)
+                }
+                (RustType::SimpleType { .. }, TypeRef::Nullable(_)) => {
+                    let syn = Cow::Owned(parse_quote! { ::core::option::Option<#syn> });
+                    let wrapped_rust_type = RustType::Optional {
+                        syn,
+                        inner: Box::new(ty.clone()),
+                        span: *span,
+                    };
+                    align_input_type_impl(&wrapped_rust_type, gql_ty, false)
+                }
+                _ => {
+                    // Transform the inner types, preserving the reference.
+                    let new_inner =
+                        align_input_type_impl(inner.as_ref(), gql_ty, gql_field_has_default);
+                    ty.clone().replace_inner(new_inner)
+                }
+            }
         }
+
         (RustType::List { inner, .. }, TypeRef::List(inner_gql)) => {
             // Transform the inner types
             let new_inner = align_input_type_impl(inner.as_ref(), inner_gql, false);
@@ -352,13 +381,41 @@ mod tests {
         let input_quote = quote! { #input };
         let result_quote = quote! { #result };
 
-        assert_eq!(input, result, "Expected {input_quote} got {result_quote}");
+        assert_eq!(input, result, "expected {input_quote} got {result_quote}");
+    }
+
+    #[test]
+    fn test_align_reference_types() {
+        let input = parse2(quote! { &'a str }).unwrap();
+
+        let result = align_input_type(&input, &nullable(string()), true);
+
+        let expected = quote! { ::core::option::Option<&'a str> }.to_string();
+        let result = quote! { #result }.to_string();
+
+        assert_eq!(expected, result, "expected {expected} got {result}");
+    }
+
+    #[test]
+    fn test_align_double_nested_reference_types() {
+        let input = parse2(quote! { &'a str }).unwrap();
+
+        let result = align_input_type(&input, &list(nullable(string())), true);
+
+        let result = quote! { #result }.to_string();
+        let expected = quote! { ::std::vec::Vec<::core::option::Option<&'a str> > }.to_string();
+
+        assert_eq!(expected, result, "expected {expected} got {result}");
     }
 
     fn integer<'a, Kind>() -> TypeRef<'a, Kind> {
         TypeRef::Named("Int".into(), PhantomData)
     }
 
+    fn string<'a, Kind>() -> TypeRef<'a, Kind> {
+        TypeRef::Named("String".into(), PhantomData)
+    }
+
     fn list<Kind>(inner: TypeRef<'_, Kind>) -> TypeRef<'_, Kind> {
         TypeRef::List(Box::new(inner))
     }

cynic-codegen/tests/snapshots/use_schema__test_cases.graphql.snap

@@ -1,6 +1,7 @@
 ---
 source: cynic-codegen/tests/use-schema.rs
 expression: "format_code(format!(\"{}\", tokens))"
+snapshot_kind: text
 ---
 impl cynic::schema::QueryRoot for Foo {}
 impl cynic::schema::MutationRoot for MutationRoot {}
@@ -104,6 +105,15 @@ pub mod __fields {
             const NAME: &'static ::core::primitive::str = "aString";
         }
         impl cynic::schema::HasInputField<aString, super::super::String> for super::super::Baz {}
+        pub struct anOptionalString;
+        impl cynic::schema::Field for anOptionalString {
+            type Type = Option<super::super::String>;
+            const NAME: &'static ::core::primitive::str = "anOptionalString";
+        }
+        impl cynic::schema::HasInputField<anOptionalString, Option<super::super::String>>
+            for super::super::Baz
+        {
+        }
     }
     pub mod FieldNameClashes {
         pub struct str;
@@ -426,4 +436,3 @@ pub mod variable {
         const TYPE: VariableType = VariableType::Named("ID");
     }
 }
-

cynic-parser/tests/snapshots/actual_schemas__test_cases__snapshot.snap

@@ -1,6 +1,7 @@
 ---
 source: cynic-parser/tests/actual_schemas.rs
 expression: parsed.to_sdl_pretty()
+snapshot_kind: text
 ---
 schema {
   query: Foo
@@ -70,5 +71,5 @@ type MutationRoot {
 input Baz {
   id: ID!
   aString: String!
+  anOptionalString: String
 }
-

cynic/tests/mutation_generics.rs

@@ -129,3 +129,51 @@ fn test_query_building_nested_generic_in_vec() {
 
     insta::assert_snapshot!(operation.query);
 }
+
+#[test]
+fn test_with_optional_string_type() {
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(
+        graphql_type = "MutationRoot",
+        variables = "SendManyBazVariables",
+        schema_path = "../schemas/test_cases.graphql",
+        schema_module = "test_cases"
+    )]
+    pub struct SendManyBaz {
+        #[arguments(many_baz: $many_baz)]
+        #[allow(dead_code)]
+        pub send_many_baz: Option<i32>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    #[cynic(schema_module = "test_cases")]
+    pub struct SendManyBazVariables<'a, Id: cynic::schema::IsScalar<cynic::Id>> {
+        #[cynic(graphql_type = "Vec<test_cases::Baz>")]
+        pub many_baz: Vec<Baz<'a, Id>>,
+    }
+
+    #[derive(cynic::InputObject, Debug)]
+    #[cynic(
+        schema_path = "../schemas/test_cases.graphql",
+        schema_module = "test_cases"
+    )]
+    pub struct Baz<'a, Id: cynic::schema::IsScalar<cynic::Id>> {
+        pub id: Id,
+        pub a_string: &'a str,
+        pub an_optional_string: &'a str,
+    }
+
+    let operation = SendManyBaz::build(SendManyBazVariables {
+        many_baz: vec![Baz {
+            id: cynic::Id::new("some-totally-correct-id"),
+            a_string: "baz",
+            an_optional_string: "baz",
+        }],
+    });
+
+    insta::assert_snapshot!(operation.query, @r"
+    mutation SendManyBaz($manyBaz: [Baz!]!) {
+      sendManyBaz(many_baz: $manyBaz)
+    }
+    ");
+}

schemas/test_cases.graphql

@@ -68,5 +68,6 @@ type MutationRoot {
 }
 input Baz {
   id: ID!
-  aString: String! # TODO fix the nullable string case here
+  aString: String!
+  anOptionalString: String
 }