fixed some more stuff

obmarg · obmarg · commit a7455aefa395 · 2025-02-17T11:05:35.000Z
diff --git a/cynic-codegen/src/fragment_derive/fragment_impl.rs b/cynic-codegen/src/fragment_derive/fragment_impl.rs
@@ -286,10 +286,10 @@ impl quote::ToTokens for FieldSelection<'_> {
                 }
             }
             FieldKind::Scalar if self.flatten => quote_spanned! { self.span =>
-                <#aligned_type as cynic::schema::IsScalar<#aligned_type>>::SchemaType
+                <#aligned_type as cynic::schema::IsOutputScalar<#aligned_type>>::SchemaType
             },
             FieldKind::Scalar => quote_spanned! { self.span =>
-                <#aligned_type as cynic::schema::IsScalar<
+                <#aligned_type as cynic::schema::IsOutputScalar<
                     <#field_marker_type_path as cynic::schema::Field>::Type
                 >>::SchemaType
             },
@@ -409,3 +409,12 @@ impl quote::ToTokens for SpreadSelection {
         })
     }
 }
+
+impl OutputType<'_> {
+    fn is_composite(&self) -> bool {
+        matches!(
+            self,
+            OutputType::Object(_) | OutputType::Interface(_) | OutputType::Union(_)
+        )
+    }
+}
diff --git a/cynic-codegen/src/scalar_derive/mod.rs b/cynic-codegen/src/scalar_derive/mod.rs
@@ -94,7 +94,9 @@ pub fn scalar_derive_impl(input: ScalarDeriveInput) -> Result<TokenStream, syn::
         }
 
         #[automatically_derived]
-        impl #impl_generics cynic::schema::ScalarDeser<#marker_ident> for #ident #ty_generics #where_clause {
+        impl #impl_generics cynic::schema::IsOutputScalar<#marker_ident> for #ident #ty_generics #where_clause {
+            type SchemaType = #marker_ident;
+
             fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
             where
                 D: cynic::serde::Deserializer<'de>
diff --git a/cynic/src/lib.rs b/cynic/src/lib.rs
@@ -247,7 +247,9 @@ macro_rules! impl_scalar {
         }
 
         #[automatically_derived]
-        impl $crate::schema::ScalarDeser<$schema_module$(::$schema_module_rest)*::$type_lock> for $type {
+        impl $crate::schema::IsOutputScalar<$schema_module$(::$schema_module_rest)*::$type_lock> for $type {
+            type SchemaType = $schema_module$(::$schema_module_rest)*::$type_lock;
+
             fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
             where
                 D: $crate::serde::Deserializer<'de>
diff --git a/cynic/src/private/scalar_de.rs b/cynic/src/private/scalar_de.rs
@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use serde::Deserialize;
 
-use crate::schema::{IsScalar, ScalarDeser};
+use crate::schema::{IsOutputScalar, IsScalar};
 
 pub struct ScalarDeseralize<T, U> {
     inner: T,
@@ -17,13 +17,13 @@ impl<T, U> ScalarDeseralize<T, U> {
 
 impl<'de, T, U> Deserialize<'de> for ScalarDeseralize<T, U>
 where
-    T: ScalarDeser<U>,
+    T: IsOutputScalar<U>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        let inner = <T as ScalarDeser<U>>::deserialize(deserializer)?;
+        let inner = <T as IsOutputScalar<U>>::deserialize(deserializer)?;
 
         Ok(ScalarDeseralize {
             inner,
diff --git a/cynic/src/schema.rs b/cynic/src/schema.rs
@@ -63,13 +63,18 @@ pub trait IsScalar<SchemaType> {
     /// The schema marker type this scalar represents.
     type SchemaType;
 
+    // TODO: serialize should maybe be on an OutputScalar trait
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer;
 }
 
-// TODO: better name on this
-pub trait ScalarDeser<SchemaType>: IsScalar<SchemaType> + Sized {
+// TODO: serialize should maybe be on an InputScalar trait
+// or maybe just ScalarSerialize/ScalarDeserialize?  not sure...
+pub trait IsOutputScalar<SchemaType>: Sized {
+    /// The schema marker type this scalar represents.
+    type SchemaType;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>;
@@ -103,10 +108,12 @@ where
     }
 }
 
-impl<T, U> ScalarDeser<Option<T>> for Option<U>
+impl<T, U> IsOutputScalar<Option<T>> for Option<U>
 where
-    U: ScalarDeser<T>,
+    U: IsOutputScalar<T>,
 {
+    type SchemaType = Option<U::SchemaType>;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -129,10 +136,12 @@ where
     }
 }
 
-impl<T, U> ScalarDeser<Vec<T>> for Vec<U>
+impl<T, U> IsOutputScalar<Vec<T>> for Vec<U>
 where
-    U: ScalarDeser<T>,
+    U: IsOutputScalar<T>,
 {
+    type SchemaType = Vec<U::SchemaType>;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -183,10 +192,12 @@ where
     }
 }
 
-impl<T, U: ?Sized> ScalarDeser<Box<T>> for Box<U>
+impl<T, U: ?Sized> IsOutputScalar<Box<T>> for Box<U>
 where
-    U: ScalarDeser<T>,
+    U: IsOutputScalar<T>,
 {
+    type SchemaType = Box<U::SchemaType>;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -209,10 +220,12 @@ where
     }
 }
 
-impl<T, U: ?Sized> ScalarDeser<T> for std::borrow::Cow<'_, U>
+impl<T, U: ?Sized> IsOutputScalar<T> for std::borrow::Cow<'_, U>
 where
-    U: ScalarDeser<T> + ToOwned,
+    U: IsOutputScalar<T> + ToOwned,
 {
+    type SchemaType = U::SchemaType;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -232,7 +245,9 @@ impl IsScalar<bool> for bool {
     }
 }
 
-impl ScalarDeser<bool> for bool {
+impl IsOutputScalar<bool> for bool {
+    type SchemaType = bool;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -252,7 +267,9 @@ impl IsScalar<String> for String {
     }
 }
 
-impl ScalarDeser<String> for String {
+impl IsOutputScalar<String> for String {
+    type SchemaType = String;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -283,7 +300,9 @@ impl IsScalar<i32> for i32 {
     }
 }
 
-impl ScalarDeser<i32> for i32 {
+impl IsOutputScalar<i32> for i32 {
+    type SchemaType = i32;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -303,7 +322,9 @@ impl IsScalar<f64> for f64 {
     }
 }
 
-impl ScalarDeser<f64> for f64 {
+impl IsOutputScalar<f64> for f64 {
+    type SchemaType = f64;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -323,7 +344,9 @@ impl IsScalar<crate::Id> for crate::Id {
     }
 }
 
-impl ScalarDeser<crate::Id> for crate::Id {
+impl IsOutputScalar<crate::Id> for crate::Id {
+    type SchemaType = crate::Id;
+
     fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
diff --git a/cynic/tests/mutation_generics.rs b/cynic/tests/mutation_generics.rs
@@ -40,9 +40,9 @@ pub struct SignIn {
     variables = "SignInVariablesMoreGeneric",
     schema_path = "../schemas/raindancer.graphql"
 )]
-pub struct SignInMoreGeneric<SI: cynic::schema::IsScalar<String>>
+pub struct SignInMoreGeneric<SI: cynic::schema::IsOutputScalar<String>>
 where
-    <SI as cynic::schema::IsScalar<String>>::SchemaType: cynic::queries::IsFieldType<String>,
+    <SI as cynic::schema::IsOutputScalar<String>>::SchemaType: cynic::queries::IsFieldType<String>,
 {
     #[arguments(input: $input)]
     pub sign_in: SI,
diff --git a/cynic/tests/scalars.rs b/cynic/tests/scalars.rs
@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{de::DeserializeOwned, Serialize};
 
 mod schema {
     cynic::use_schema!("tests/test-schema.graphql");
@@ -13,7 +13,7 @@ cynic::impl_scalar!(chrono::DateTime<chrono::Utc>, schema::DateTime);
 
 #[derive(cynic::Scalar)]
 #[cynic(graphql_type = "DateTime")]
-pub struct DateTimeInner<DT: Serialize>(pub DT);
+pub struct DateTimeInner<DT: Serialize + DeserializeOwned>(pub DT);
 
 // Make sure we can use impl scalar on built in types
 pub struct MyString(#[allow(dead_code)] String);

Original file line number	Diff line number	Diff line change
`@@ -63,13 +63,18 @@ pub trait IsScalar<SchemaType> {`
`63`	`63`	`/// The schema marker type this scalar represents.`
`64`	`64`	`type SchemaType;`
`65`	`65`
	`66`	`+ // TODO: serialize should maybe be on an OutputScalar trait`
`66`	`67`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`67`	`68`	`where`
`68`	`69`	`S: Serializer;`
`69`	`70`	`}`
`70`	`71`
`71`		`-// TODO: better name on this`
`72`		`-pub trait ScalarDeser<SchemaType>: IsScalar<SchemaType> + Sized {`
	`72`	`+// TODO: serialize should maybe be on an InputScalar trait`
	`73`	`+// or maybe just ScalarSerialize/ScalarDeserialize? not sure...`
	`74`	`+pub trait IsOutputScalar<SchemaType>: Sized {`
	`75`	`+ /// The schema marker type this scalar represents.`
	`76`	`+ type SchemaType;`
	`77`	`+`
`73`	`78`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`74`	`79`	`where`
`75`	`80`	`D: Deserializer<'de>;`
`@@ -103,10 +108,12 @@ where`
`103`	`108`	`}`
`104`	`109`	`}`
`105`	`110`
`106`		`-impl<T, U> ScalarDeser<Option<T>> for Option<U>`
	`111`	`+impl<T, U> IsOutputScalar<Option<T>> for Option<U>`
`107`	`112`	`where`
`108`		`- U: ScalarDeser<T>,`
	`113`	`+ U: IsOutputScalar<T>,`
`109`	`114`	`{`
	`115`	`+ type SchemaType = Option<U::SchemaType>;`
	`116`	`+`
`110`	`117`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`111`	`118`	`where`
`112`	`119`	`D: Deserializer<'de>,`
`@@ -129,10 +136,12 @@ where`
`129`	`136`	`}`
`130`	`137`	`}`
`131`	`138`
`132`		`-impl<T, U> ScalarDeser<Vec<T>> for Vec<U>`
	`139`	`+impl<T, U> IsOutputScalar<Vec<T>> for Vec<U>`
`133`	`140`	`where`
`134`		`- U: ScalarDeser<T>,`
	`141`	`+ U: IsOutputScalar<T>,`
`135`	`142`	`{`
	`143`	`+ type SchemaType = Vec<U::SchemaType>;`
	`144`	`+`
`136`	`145`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`137`	`146`	`where`
`138`	`147`	`D: Deserializer<'de>,`
`@@ -183,10 +192,12 @@ where`
`183`	`192`	`}`
`184`	`193`	`}`
`185`	`194`
`186`		`-impl<T, U: ?Sized> ScalarDeser<Box<T>> for Box<U>`
	`195`	`+impl<T, U: ?Sized> IsOutputScalar<Box<T>> for Box<U>`
`187`	`196`	`where`
`188`		`- U: ScalarDeser<T>,`
	`197`	`+ U: IsOutputScalar<T>,`
`189`	`198`	`{`
	`199`	`+ type SchemaType = Box<U::SchemaType>;`
	`200`	`+`
`190`	`201`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`191`	`202`	`where`
`192`	`203`	`D: Deserializer<'de>,`
`@@ -209,10 +220,12 @@ where`
`209`	`220`	`}`
`210`	`221`	`}`
`211`	`222`
`212`		`-impl<T, U: ?Sized> ScalarDeser<T> for std::borrow::Cow<'_, U>`
	`223`	`+impl<T, U: ?Sized> IsOutputScalar<T> for std::borrow::Cow<'_, U>`
`213`	`224`	`where`
`214`		`- U: ScalarDeser<T> + ToOwned,`
	`225`	`+ U: IsOutputScalar<T> + ToOwned,`
`215`	`226`	`{`
	`227`	`+ type SchemaType = U::SchemaType;`
	`228`	`+`
`216`	`229`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`217`	`230`	`where`
`218`	`231`	`D: Deserializer<'de>,`
`@@ -232,7 +245,9 @@ impl IsScalar<bool> for bool {`
`232`	`245`	`}`
`233`	`246`	`}`
`234`	`247`
`235`		`-impl ScalarDeser<bool> for bool {`
	`248`	`+impl IsOutputScalar<bool> for bool {`
	`249`	`+ type SchemaType = bool;`
	`250`	`+`
`236`	`251`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`237`	`252`	`where`
`238`	`253`	`D: Deserializer<'de>,`
`@@ -252,7 +267,9 @@ impl IsScalar<String> for String {`
`252`	`267`	`}`
`253`	`268`	`}`
`254`	`269`
`255`		`-impl ScalarDeser<String> for String {`
	`270`	`+impl IsOutputScalar<String> for String {`
	`271`	`+ type SchemaType = String;`
	`272`	`+`
`256`	`273`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`257`	`274`	`where`
`258`	`275`	`D: Deserializer<'de>,`
`@@ -283,7 +300,9 @@ impl IsScalar<i32> for i32 {`
`283`	`300`	`}`
`284`	`301`	`}`
`285`	`302`
`286`		`-impl ScalarDeser<i32> for i32 {`
	`303`	`+impl IsOutputScalar<i32> for i32 {`
	`304`	`+ type SchemaType = i32;`
	`305`	`+`
`287`	`306`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`288`	`307`	`where`
`289`	`308`	`D: Deserializer<'de>,`
`@@ -303,7 +322,9 @@ impl IsScalar<f64> for f64 {`
`303`	`322`	`}`
`304`	`323`	`}`
`305`	`324`
`306`		`-impl ScalarDeser<f64> for f64 {`
	`325`	`+impl IsOutputScalar<f64> for f64 {`
	`326`	`+ type SchemaType = f64;`
	`327`	`+`
`307`	`328`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`308`	`329`	`where`
`309`	`330`	`D: Deserializer<'de>,`
`@@ -323,7 +344,9 @@ impl IsScalar<crate::Id> for crate::Id {`
`323`	`344`	`}`
`324`	`345`	`}`
`325`	`346`
`326`		`-impl ScalarDeser<crate::Id> for crate::Id {`
	`347`	`+impl IsOutputScalar<crate::Id> for crate::Id {`
	`348`	`+ type SchemaType = crate::Id;`
	`349`	`+`
`327`	`350`	`fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error>`
`328`	`351`	`where`
`329`	`352`	`D: Deserializer<'de>,`