use quote::quote;
use crate::name::RustSafeName;
#[cfg(test)]
mod tests;
#[must_use]
pub fn wire_name(member: &syn::Ident) -> String {
crate::emit::wire::wire_member(member)
}
pub enum ComposedKind {
Slot(String),
Spliced,
}
pub struct ComposedField {
pub member: syn::Ident,
pub ty: syn::Type,
pub kind: ComposedKind,
pub condition: crate::model::Condition,
}
pub struct ComposedModel {
pub subject: syn::Ident,
pub krate: syn::Path,
pub sdl: RustSafeName,
pub shorthand: bool,
pub fields: Vec<ComposedField>,
}
impl ComposedModel {
fn framework(&self, module: &[&str], item: &str) -> proc_macro2::TokenStream {
crate::emit::framework(&self.krate, module, item)
}
pub fn emit(&self) -> proc_macro2::TokenStream {
let emptiness = self.emptiness();
let gate = self.framework(&["gate"], "if_async_graphql");
let face = self.input_type();
let object = self.input_object();
let nullable = self.nullable_face();
quote! {
#emptiness
const _: () = {
#gate! {
#face
#object
#nullable
}
};
}
}
fn emptiness(&self) -> proc_macro2::TokenStream {
let subject = &self.subject;
let contract = self.framework(&["graphql"], "GraphqlFilter");
let slot = self.framework(&["graphql"], "FilterSlot");
let folded = self.fields.iter().map(|field| {
let (member, ty) = (&field.member, &field.ty);
let asked = match field.kind {
ComposedKind::Slot(_) => quote!(<#ty as #slot<_>>::is_empty(&self.#member)),
ComposedKind::Spliced => quote!(<#ty as #contract>::is_empty(&self.#member)),
};
field.condition.either(&asked, "e!(true))
});
quote! {
#[automatically_derived]
impl #contract for #subject {
fn is_empty(&self) -> bool {
#(#folded)&&*
}
}
}
}
fn input_type(&self) -> proc_macro2::TokenStream {
let subject = &self.subject;
let ag = self.framework(&[], "async_graphql");
let nullable_face = self.framework(&["graphql"], "NullableFace");
let face = self.framework(&["graphql"], "SlotFace");
let flat = self.framework(&["graphql"], "FlattenFace");
let sent = self.framework(&["graphql", "filter"], "sent");
let sent_ty = self.framework(&["graphql", "filter"], "Sent");
let sdl = self.sdl.external();
let slots = self.fields.iter().filter_map(|field| {
let (member, ty, gate) = (&field.member, &field.ty, field.condition.gate());
match &field.kind {
ComposedKind::Slot(wire) => {
Some(quote!(#gate #member: <#ty as #face<_>>::read::<Self>(&__ingraph_object, #wire)?))
}
ComposedKind::Spliced => None,
}
});
let splices = self.fields.iter().filter_map(|field| {
let (member, ty, gate) = (&field.member, &field.ty, field.condition.gate());
match &field.kind {
ComposedKind::Slot(_) => None,
ComposedKind::Spliced => {
Some(quote!(#gate #member: <#ty as #flat>::flat_read::<Self>(&__ingraph_object)?))
}
}
});
let reading = if self.shorthand {
let shorthand = self.framework(&["graphql", "filter"], "shorthand");
quote! {
#sent_ty::Longhand(__ingraph_object) => __ingraph_object,
#sent_ty::Bare(__ingraph_bare) => #shorthand::<Self>(__ingraph_bare),
#sent_ty::Null => {
return ::core::result::Result::Err(#ag::InputValueError::expected_type(
#ag::Value::Null,
));
}
#sent_ty::Refused(__ingraph_sent) => {
return ::core::result::Result::Err(#ag::InputValueError::expected_type(
__ingraph_sent,
));
}
}
} else {
let refuse_bare = self.framework(&["graphql", "filter"], "refuse_bare");
quote! {
#sent_ty::Longhand(__ingraph_object) => __ingraph_object,
#sent_ty::Null => {
return ::core::result::Result::Err(#ag::InputValueError::expected_type(
#ag::Value::Null,
));
}
#sent_ty::Bare(__ingraph_sent) | #sent_ty::Refused(__ingraph_sent) => {
return ::core::result::Result::Err(#refuse_bare::<Self>(&__ingraph_sent));
}
}
};
quote! {
#[automatically_derived]
impl #ag::InputType for #subject {
type RawValueType = Self;
#[inline]
fn type_name() -> ::std::borrow::Cow<'static, ::core::primitive::str> {
::std::borrow::Cow::Borrowed(#sdl)
}
fn create_type_info(
__ingraph_registry: &mut #ag::registry::Registry,
) -> ::std::string::String {
__ingraph_registry.create_input_type::<Self, _>(
#ag::registry::MetaTypeId::InputObject,
|__ingraph_registry| #ag::registry::MetaType::InputObject {
name: ::std::string::String::from(#sdl),
description: ::core::option::Option::None,
input_fields: <Self as #nullable_face>::bare_fields(__ingraph_registry),
visible: ::core::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
rust_typename: ::core::option::Option::Some(::core::any::type_name::<Self>()),
oneof: false,
directive_invocations: ::std::vec::Vec::new(),
},
)
}
fn parse(
__ingraph_value: ::core::option::Option<#ag::Value>,
) -> #ag::InputValueResult<Self> {
let __ingraph_object = match #sent(__ingraph_value) {
#reading
};
::core::result::Result::Ok(Self { #(#slots,)* #(#splices,)* })
}
fn to_value(&self) -> #ag::Value {
#ag::Value::Object(<Self as #nullable_face>::bare_values(self))
}
#[inline]
fn as_raw_value(&self) -> ::core::option::Option<&Self::RawValueType> {
::core::option::Option::Some(self)
}
}
}
}
fn input_object(&self) -> proc_macro2::TokenStream {
let subject = &self.subject;
let ag = self.framework(&[], "async_graphql");
quote! {
#[automatically_derived]
impl #ag::InputObjectType for #subject {}
}
}
fn nullable_face(&self) -> proc_macro2::TokenStream {
let subject = &self.subject;
let ag = self.framework(&[], "async_graphql");
let nullable_face = self.framework(&["graphql"], "NullableFace");
let face = self.framework(&["graphql"], "SlotFace");
let flat = self.framework(&["graphql"], "FlattenFace");
let table = self.framework(&["graphql", "filter", "flatten"], "table");
let sdl = self.sdl.external();
let entries = self.fields.iter().map(|field| {
let (ty, gate) = (&field.ty, field.condition.gate());
match &field.kind {
ComposedKind::Slot(wire) => quote! {
#gate
::std::vec::Vec::push(
&mut __ingraph_entries,
(
::std::string::String::from(#wire),
#ag::registry::MetaInputValue {
name: ::std::string::String::from(#wire),
description: ::core::option::Option::None,
ty: <#ty as #face<_>>::slot_type(__ingraph_registry),
deprecation: #ag::registry::Deprecation::NoDeprecated,
default_value: ::core::option::Option::None,
visible: ::core::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
is_secret: false,
directive_invocations: ::std::vec::Vec::new(),
},
),
);
},
ComposedKind::Spliced => quote! {
#gate
::core::iter::Extend::extend(
&mut __ingraph_entries,
<#ty as #flat>::flat_fields(__ingraph_registry),
);
},
}
});
let values = self.fields.iter().map(|field| {
let (member, ty, gate) = (&field.member, &field.ty, field.condition.gate());
match &field.kind {
ComposedKind::Slot(wire) => quote! {
#gate
#ag::indexmap::IndexMap::insert(
&mut __ingraph_map,
#ag::Name::new(#wire),
<#ty as #face<_>>::write(&self.#member),
);
},
ComposedKind::Spliced => quote! {
#gate
::core::iter::Extend::extend(
&mut __ingraph_map,
<#ty as #flat>::flat_values(&self.#member),
);
},
}
});
quote! {
#[automatically_derived]
impl #nullable_face for #subject {
fn bare_fields(
__ingraph_registry: &mut #ag::registry::Registry,
) -> #ag::indexmap::IndexMap<::std::string::String, #ag::registry::MetaInputValue> {
let mut __ingraph_entries = ::std::vec::Vec::new();
#(#entries)*
#table(#sdl, __ingraph_entries)
}
fn bare_values(
&self,
) -> #ag::indexmap::IndexMap<#ag::Name, #ag::Value> {
let mut __ingraph_map = #ag::indexmap::IndexMap::new();
#(#values)*
__ingraph_map
}
}
}
}
}
#[must_use]
pub fn default_sdl_name(subject: &syn::Ident) -> RustSafeName {
RustSafeName::from_ident(subject)
}