fixed some more stuff

obmarg · obmarg · commit 5a35b9f4fcf6 · 2025-02-17T11:05:35.000Z
diff --git a/cynic-codegen/src/fragment_derive/deserialize_impl.rs b/cynic-codegen/src/fragment_derive/deserialize_impl.rs
@@ -113,7 +113,7 @@ impl quote::ToTokens for StandardDeserializeImpl<'_> {
             let mut trailer = quote! {};
 
             if matches!(f.inner_kind, Some(FieldKind::Scalar)) {
-                ty = quote! { cynic::__private::ScalarDeseralize<#ty, <#field_marker as cynic::schema::Field>::Type> };
+                ty = quote! { cynic::__private::ScalarDeserialize<#ty, <#field_marker as cynic::schema::Field>::Type> };
                 trailer.append_all(quote! { .into_inner() });
             }
 
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__argument_and_rename.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__argument_and_rename.snap
@@ -63,13 +63,13 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {
                             if post.is_some() {
                                 return Err(cynic::serde::de::Error::duplicate_field("post"));
                             }
-                            post = Some(__map.next_value()?);
+                            post = Some(__map.next_value::<Option<BlogPostOutput>>()?);
                         }
                         __FragmentDeriveField::posts => {
                             if posts.is_some() {
                                 return Err(cynic::serde::de::Error::duplicate_field("allPosts"));
                             }
-                            posts = Some(__map.next_value()?);
+                            posts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__argument_literals.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__argument_literals.snap
@@ -82,7 +82,7 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {
                                     "filteredPosts",
                                 ));
                             }
-                            filteredPosts = Some(__map.next_value()?);
+                            filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__feature_flagging.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__feature_flagging.snap
@@ -11,10 +11,7 @@ impl cynic::QueryFragment for MyQuery {
         mut builder: cynic::queries::SelectionBuilder<'_, Self::SchemaType, Self::VariablesFields>,
     ) {
         #![allow(unused_mut)]
-        let mut field_builder = builder
-            .select_field::<schema::__fields::Query::__typename, <String as cynic::schema::IsScalar<
-                <schema::__fields::Query::__typename as cynic::schema::Field>::Type,
-            >>::SchemaType>();
+        let mut field_builder = builder . select_field :: < schema :: __fields :: Query :: __typename , < String as cynic :: schema :: IsOutputScalar < < schema :: __fields :: Query :: __typename as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
         if builder.is_feature_enabled("2018") {
             let mut field_builder = builder . select_field :: < schema :: __fields :: Query :: filteredPosts , < Vec < BlogPostOutput > as cynic :: QueryFragment > :: SchemaType > () ;
             <Vec<BlogPostOutput> as cynic::QueryFragment>::query(field_builder.select_children());
@@ -62,15 +59,15 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {
                             if __typename.is_some() {
                                 return Err(cynic::serde::de::Error::duplicate_field("__typename"));
                             }
-                            __typename = Some(__map.next_value()?);
+                            __typename = Some (__map . next_value :: < cynic :: __private :: ScalarDeserialize < String , < schema :: __fields :: Query :: __typename as cynic :: schema :: Field > :: Type > > () ? . into_inner ()) ;
                         }
                         __FragmentDeriveField::filteredPosts => {
                             if filteredPosts.is_some() {
                                 return Err(cynic::serde::de::Error::duplicate_field(
                                     "filteredPosts",
                                 ));
                             }
-                            filteredPosts = Some(__map.next_value()?);
+                            filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__flatten_attr.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__flatten_attr.snap
@@ -11,7 +11,7 @@ impl cynic::QueryFragment for Film {
         mut builder: cynic::queries::SelectionBuilder<'_, Self::SchemaType, Self::VariablesFields>,
     ) {
         #![allow(unused_mut)]
-        let mut field_builder = builder . select_flattened_field :: < schema :: __fields :: Film :: producers , < Vec < String > as cynic :: schema :: IsScalar < Vec < String > >> :: SchemaType , < schema :: __fields :: Film :: producers as cynic :: schema :: Field > :: Type , > () ;
+        let mut field_builder = builder . select_flattened_field :: < schema :: __fields :: Film :: producers , < Vec < String > as cynic :: schema :: IsOutputScalar < Vec < String > >> :: SchemaType , < schema :: __fields :: Film :: producers as cynic :: schema :: Field > :: Type , > () ;
     }
     fn name() -> Option<std::borrow::Cow<'static, str>> {
         Some(std::borrow::Cow::Borrowed("Film"))
@@ -52,11 +52,7 @@ impl<'de> cynic::serde::Deserialize<'de> for Film {
                             if producers.is_some() {
                                 return Err(cynic::serde::de::Error::duplicate_field("producers"));
                             }
-                            producers = Some(
-                                __map
-                                    .next_value::<cynic::__private::Flattened<Vec<String>>>()?
-                                    .into_inner(),
-                            );
+                            producers = Some (__map . next_value :: < cynic :: __private :: Flattened < cynic :: __private :: ScalarDeserialize < Vec < String > , < schema :: __fields :: Film :: producers as cynic :: schema :: Field > :: Type > > > () ? . into_inner () . into_inner ()) ;
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__not_sure.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__not_sure.snap
@@ -92,7 +92,7 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {
                                     "filteredPosts",
                                 ));
                             }
-                            filteredPosts = Some(__map.next_value()?);
+                            filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__simple_struct.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__simple_struct.snap
@@ -11,7 +11,7 @@ impl cynic::QueryFragment for BlogPostOutput {
         mut builder: cynic::queries::SelectionBuilder<'_, Self::SchemaType, Self::VariablesFields>,
     ) {
         #![allow(unused_mut)]
-        let mut field_builder = builder . select_field :: < schema :: __fields :: BlogPost :: hasMetadata , < Option < bool > as cynic :: schema :: IsScalar < < schema :: __fields :: BlogPost :: hasMetadata as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
+        let mut field_builder = builder . select_field :: < schema :: __fields :: BlogPost :: hasMetadata , < Option < bool > as cynic :: schema :: IsOutputScalar < < schema :: __fields :: BlogPost :: hasMetadata as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
         let mut field_builder = builder . select_field :: < schema :: __fields :: BlogPost :: author , < AuthorOutput as cynic :: QueryFragment > :: SchemaType > () ;
         <AuthorOutput as cynic::QueryFragment>::query(field_builder.select_children());
     }
@@ -59,13 +59,13 @@ impl<'de> cynic::serde::Deserialize<'de> for BlogPostOutput {
                                     "hasMetadata",
                                 ));
                             }
-                            has_metadata = Some(__map.next_value()?);
+                            has_metadata = Some (__map . next_value :: < cynic :: __private :: ScalarDeserialize < Option < bool > , < schema :: __fields :: BlogPost :: hasMetadata as cynic :: schema :: Field > :: Type > > () ? . into_inner ()) ;
                         }
                         __FragmentDeriveField::author => {
                             if author.is_some() {
                                 return Err(cynic::serde::de::Error::duplicate_field("author"));
                             }
-                            author = Some(__map.next_value()?);
+                            author = Some(__map.next_value::<AuthorOutput>()?);
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__spread_attr_multi_field1.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__spread_attr_multi_field1.snap
@@ -11,7 +11,7 @@ impl cynic::QueryFragment for Film {
         mut builder: cynic::queries::SelectionBuilder<'_, Self::SchemaType, Self::VariablesFields>,
     ) {
         #![allow(unused_mut)]
-        let mut field_builder = builder . select_field :: < schema :: __fields :: Film :: releaseDate , < Option < String > as cynic :: schema :: IsScalar < < schema :: __fields :: Film :: releaseDate as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
+        let mut field_builder = builder . select_field :: < schema :: __fields :: Film :: releaseDate , < Option < String > as cynic :: schema :: IsOutputScalar < < schema :: __fields :: Film :: releaseDate as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
         <FilmDetails as cynic::QueryFragment>::query(
             builder
                 .inline_fragment()
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__spread_attr_multi_field2.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__spread_attr_multi_field2.snap
@@ -16,7 +16,7 @@ impl cynic::QueryFragment for Film {
                 .inline_fragment()
                 .select_children::<<FilmDetails as cynic::QueryFragment>::VariablesFields>(),
         );
-        let mut field_builder = builder . select_field :: < schema :: __fields :: Film :: releaseDate , < Option < String > as cynic :: schema :: IsScalar < < schema :: __fields :: Film :: releaseDate as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
+        let mut field_builder = builder . select_field :: < schema :: __fields :: Film :: releaseDate , < Option < String > as cynic :: schema :: IsOutputScalar < < schema :: __fields :: Film :: releaseDate as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;
     }
     fn name() -> Option<std::borrow::Cow<'static, str>> {
         Some(std::borrow::Cow::Borrowed("Film"))
diff --git a/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__variable_in_argument.snap b/cynic-codegen/src/fragment_derive/snapshots/cynic_codegen__fragment_derive__tests__variable_in_argument.snap
@@ -60,7 +60,7 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {
                                     "filteredPosts",
                                 ));
                             }
-                            filteredPosts = Some(__map.next_value()?);
+                            filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);
                         }
                         __FragmentDeriveField::__Other => {
                             __map.next_value::<cynic::serde::de::IgnoredAny>()?;
diff --git a/cynic-codegen/src/scalar_derive/snapshots/cynic_codegen__scalar_derive__tests__snapshot_scalar_derive.snap b/cynic-codegen/src/scalar_derive/snapshots/cynic_codegen__scalar_derive__tests__snapshot_scalar_derive.snap
@@ -23,6 +23,22 @@ impl<'de> cynic::serde::Deserialize<'de> for DateTime {
 #[automatically_derived]
 impl cynic::schema::IsScalar<schema::DateTime> for DateTime {
     type SchemaType = schema::DateTime;
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: cynic::serde::Serializer,
+    {
+        cynic::serde::Serialize::serialize(self, serializer)
+    }
+}
+#[automatically_derived]
+impl cynic::schema::IsOutputScalar<schema::DateTime> for DateTime {
+    type SchemaType = schema::DateTime;
+    fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: cynic::serde::Deserializer<'de>,
+    {
+        <Self as cynic::serde::Deserialize>::deserialize(deserializer)
+    }
 }
 #[automatically_derived]
 impl schema::variable::Variable for DateTime {
diff --git a/cynic/src/private/flatten_de.rs b/cynic/src/private/flatten_de.rs
@@ -1,5 +1,7 @@
 use serde::Deserialize;
 
+use crate::schema::IsOutputScalar;
+
 pub struct Flattened<T> {
     inner: T,
 }
@@ -39,3 +41,41 @@ where
         })
     }
 }
+
+impl<'de, T, U> Deserialize<'de> for Flattened<super::ScalarDeserialize<Vec<T>, U>>
+where
+    Option<Vec<Option<T>>>: IsOutputScalar<U>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        super::ScalarDeserialize::<Option<Vec<Option<T>>>, U>::deserialize(deserializer).map(
+            |opt_vec| Flattened {
+                inner: todo!(
+                    "opt_vec
+                    .map(|vec| vec.into_iter().flatten().collect::<Vec<_>>())
+                    .unwrap_or_default(),"
+                ),
+            },
+        )
+    }
+}
+
+impl<'de, T, U> Deserialize<'de> for Flattened<super::ScalarDeserialize<Option<Vec<T>>, U>>
+where
+    Option<Vec<Option<T>>>: IsOutputScalar<U>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        super::ScalarDeserialize::<Option<Vec<Option<T>>>, U>::deserialize(deserializer).map(
+            |scalar_deser| Flattened {
+                inner: scalar_deser.map(|opt_vec| {
+                    opt_vec.map(|vec| vec.into_iter().flatten().collect::<Vec<_>>())
+                }),
+            },
+        )
+    }
+}
diff --git a/cynic/src/private/mod.rs b/cynic/src/private/mod.rs
@@ -8,10 +8,10 @@ mod cow_str;
 mod flatten_de;
 mod inline_fragment_de;
 mod key_de;
-mod scalar_de;
+mod scalar_serde;
 mod spread_de;
 
 pub use flatten_de::Flattened;
 pub use inline_fragment_de::InlineFragmentVisitor;
-pub use scalar_de::ScalarDeseralize;
+pub use scalar_serde::{ScalarDeserialize, ScalarSerialize};
 pub use spread_de::Spreadable;
diff --git a/cynic/src/private/scalar_de.rs b/cynic/src/private/scalar_de.rs
diff --git a/cynic/src/private/scalar_serde.rs b/cynic/src/private/scalar_serde.rs
@@ -0,0 +1,69 @@
+use std::marker::PhantomData;
+
+use serde::Deserialize;
+
+use crate::schema::{IsOutputScalar, IsScalar};
+
+pub struct ScalarDeserialize<T, U> {
+    inner: T,
+    phantom: PhantomData<fn() -> U>,
+}
+
+impl<T, U> ScalarDeserialize<T, U> {
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+
+    pub fn map<NewT, F>(self, fun: F) -> ScalarDeserialize<NewT, U>
+    where
+        F: FnOnce(T) -> NewT,
+    {
+        ScalarDeserialize {
+            inner: fun(self.inner),
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'de, T, U> Deserialize<'de> for ScalarDeserialize<T, U>
+where
+    T: IsOutputScalar<U>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let inner = <T as IsOutputScalar<U>>::deserialize(deserializer)?;
+
+        Ok(ScalarDeserialize {
+            inner,
+            phantom: PhantomData,
+        })
+    }
+}
+
+pub struct ScalarSerialize<'a, T, U> {
+    inner: &'a T,
+    phantom: PhantomData<fn(U) -> ()>,
+}
+
+impl<'a, T, U> ScalarSerialize<'a, T, U> {
+    pub fn new(inner: &'a T) -> Self {
+        ScalarSerialize {
+            inner,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<T, U> serde::Serialize for ScalarSerialize<'_, T, U>
+where
+    T: IsScalar<U>,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        IsScalar::serialize(self.inner, serializer)
+    }
+}
diff --git a/cynic/src/schema.rs b/cynic/src/schema.rs
diff --git a/cynic/tests/scalars.rs b/cynic/tests/scalars.rs

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ impl quote::ToTokens for StandardDeserializeImpl<'_> {`
`113`	`113`	`let mut trailer = quote! {};`
`114`	`114`
`115`	`115`	`if matches!(f.inner_kind, Some(FieldKind::Scalar)) {`
`116`		`- ty = quote! { cynic::__private::ScalarDeseralize<#ty, <#field_marker as cynic::schema::Field>::Type> };`
	`116`	`+ ty = quote! { cynic::__private::ScalarDeserialize<#ty, <#field_marker as cynic::schema::Field>::Type> };`
`117`	`117`	`trailer.append_all(quote! { .into_inner() });`
`118`	`118`	`}`
`119`	`119`
Original file line number	Diff line number	Diff line change
`@@ -63,13 +63,13 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {`
`63`	`63`	`if post.is_some() {`
`64`	`64`	`return Err(cynic::serde::de::Error::duplicate_field("post"));`
`65`	`65`	`}`
`66`		`- post = Some(__map.next_value()?);`
	`66`	`+ post = Some(__map.next_value::<Option<BlogPostOutput>>()?);`
`67`	`67`	`}`
`68`	`68`	`__FragmentDeriveField::posts => {`
`69`	`69`	`if posts.is_some() {`
`70`	`70`	`return Err(cynic::serde::de::Error::duplicate_field("allPosts"));`
`71`	`71`	`}`
`72`		`- posts = Some(__map.next_value()?);`
	`72`	`+ posts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);`
`73`	`73`	`}`
`74`	`74`	`__FragmentDeriveField::__Other => {`
`75`	`75`	`__map.next_value::<cynic::serde::de::IgnoredAny>()?;`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {`
`82`	`82`	`"filteredPosts",`
`83`	`83`	`));`
`84`	`84`	`}`
`85`		`- filteredPosts = Some(__map.next_value()?);`
	`85`	`+ filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);`
`86`	`86`	`}`
`87`	`87`	`__FragmentDeriveField::__Other => {`
`88`	`88`	`__map.next_value::<cynic::serde::de::IgnoredAny>()?;`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {`
`92`	`92`	`"filteredPosts",`
`93`	`93`	`));`
`94`	`94`	`}`
`95`		`- filteredPosts = Some(__map.next_value()?);`
	`95`	`+ filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);`
`96`	`96`	`}`
`97`	`97`	`__FragmentDeriveField::__Other => {`
`98`	`98`	`__map.next_value::<cynic::serde::de::IgnoredAny>()?;`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ impl cynic::QueryFragment for BlogPostOutput {`
`11`	`11`	`mut builder: cynic::queries::SelectionBuilder<'_, Self::SchemaType, Self::VariablesFields>,`
`12`	`12`	`) {`
`13`	`13`	`#![allow(unused_mut)]`
`14`		`- let mut field_builder = builder . select_field :: < schema :: __fields :: BlogPost :: hasMetadata , < Option < bool > as cynic :: schema :: IsScalar < < schema :: __fields :: BlogPost :: hasMetadata as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;`
	`14`	`+ let mut field_builder = builder . select_field :: < schema :: __fields :: BlogPost :: hasMetadata , < Option < bool > as cynic :: schema :: IsOutputScalar < < schema :: __fields :: BlogPost :: hasMetadata as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;`
`15`	`15`	`let mut field_builder = builder . select_field :: < schema :: __fields :: BlogPost :: author , < AuthorOutput as cynic :: QueryFragment > :: SchemaType > () ;`
`16`	`16`	`<AuthorOutput as cynic::QueryFragment>::query(field_builder.select_children());`
`17`	`17`	`}`
`@@ -59,13 +59,13 @@ impl<'de> cynic::serde::Deserialize<'de> for BlogPostOutput {`
`59`	`59`	`"hasMetadata",`
`60`	`60`	`));`
`61`	`61`	`}`
`62`		`- has_metadata = Some(__map.next_value()?);`
	`62`	`+ has_metadata = Some (__map . next_value :: < cynic :: __private :: ScalarDeserialize < Option < bool > , < schema :: __fields :: BlogPost :: hasMetadata as cynic :: schema :: Field > :: Type > > () ? . into_inner ()) ;`
`63`	`63`	`}`
`64`	`64`	`__FragmentDeriveField::author => {`
`65`	`65`	`if author.is_some() {`
`66`	`66`	`return Err(cynic::serde::de::Error::duplicate_field("author"));`
`67`	`67`	`}`
`68`		`- author = Some(__map.next_value()?);`
	`68`	`+ author = Some(__map.next_value::<AuthorOutput>()?);`
`69`	`69`	`}`
`70`	`70`	`__FragmentDeriveField::__Other => {`
`71`	`71`	`__map.next_value::<cynic::serde::de::IgnoredAny>()?;`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ impl cynic::QueryFragment for Film {`
`16`	`16`	`.inline_fragment()`
`17`	`17`	`.select_children::<<FilmDetails as cynic::QueryFragment>::VariablesFields>(),`
`18`	`18`	`);`
`19`		`- let mut field_builder = builder . select_field :: < schema :: __fields :: Film :: releaseDate , < Option < String > as cynic :: schema :: IsScalar < < schema :: __fields :: Film :: releaseDate as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;`
	`19`	`+ let mut field_builder = builder . select_field :: < schema :: __fields :: Film :: releaseDate , < Option < String > as cynic :: schema :: IsOutputScalar < < schema :: __fields :: Film :: releaseDate as cynic :: schema :: Field > :: Type >> :: SchemaType > () ;`
`20`	`20`	`}`
`21`	`21`	`fn name() -> Option<std::borrow::Cow<'static, str>> {`
`22`	`22`	`Some(std::borrow::Cow::Borrowed("Film"))`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ impl<'de> cynic::serde::Deserialize<'de> for MyQuery {`
`60`	`60`	`"filteredPosts",`
`61`	`61`	`));`
`62`	`62`	`}`
`63`		`- filteredPosts = Some(__map.next_value()?);`
	`63`	`+ filteredPosts = Some(__map.next_value::<Vec<BlogPostOutput>>()?);`
`64`	`64`	`}`
`65`	`65`	`__FragmentDeriveField::__Other => {`
`66`	`66`	`__map.next_value::<cynic::serde::de::IgnoredAny>()?;`