use quote::quote;
pub struct InputFace<'a> {
pub krate: &'a syn::Path,
pub name: &'a syn::Ident,
pub sdl: &'a str,
}
impl InputFace<'_> {
fn ag(&self) -> proc_macro2::TokenStream {
crate::emit::framework(self.krate, &[], "async_graphql")
}
fn meta_input_value(
&self,
name: &str,
ty: &proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
let ag = self.ag();
quote! {
#ag::registry::MetaInputValue {
name: ::std::string::String::from(#name),
description: ::core::option::Option::None,
ty: <#ty as #ag::InputType>::create_type_info(__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(),
}
}
}
fn fields_block(
&self,
entries: impl Iterator<Item = proc_macro2::TokenStream>,
) -> proc_macro2::TokenStream {
let ag = self.ag();
let entries: Vec<proc_macro2::TokenStream> = entries.collect();
quote! {
{
let mut __ingraph_fields = #ag::indexmap::IndexMap::new();
#(#entries)*
__ingraph_fields
}
}
}
fn type_info(
&self,
input_fields: &proc_macro2::TokenStream,
oneof: bool,
) -> proc_macro2::TokenStream {
let ag = self.ag();
let sdl = self.sdl;
quote! {
#[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: #input_fields,
visible: ::core::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
rust_typename: ::core::option::Option::Some(::core::any::type_name::<Self>()),
oneof: #oneof,
directive_invocations: ::std::vec::Vec::new(),
},
)
}
}
}
}
pub struct FilterField {
pub field: String,
pub member: syn::Ident,
pub filter: proc_macro2::TokenStream,
pub gate: proc_macro2::TokenStream,
}
pub struct OrderField {
pub field: String,
pub variant: syn::Ident,
pub published: bool,
pub gate: proc_macro2::TokenStream,
}
pub struct RelationPosition {
pub field: String,
pub member: syn::Ident,
pub held: proc_macro2::TokenStream,
}
#[must_use]
pub fn filter_face(
face: &InputFace<'_>,
fields: &[FilterField],
positions: &[RelationPosition],
) -> proc_macro2::TokenStream {
let (ag, name) = (face.ag(), face.name);
let entries = fields.iter().map(|row| {
let (field, filter, gate) = (&row.field, &row.filter, &row.gate);
let value = face.meta_input_value(field, "e!(::core::option::Option<#filter>));
quote!(#gate __ingraph_fields.insert(::std::string::String::from(#field), #value);)
});
let parses = fields.iter().map(|row| {
let (field, member, filter, gate) = (&row.field, &row.member, &row.filter, &row.gate);
quote! {
#gate
#member: <::core::option::Option<#filter> as #ag::InputType>::parse(
#ag::indexmap::IndexMap::get(&__ingraph_object, #field).cloned(),
)
.map_err(#ag::InputValueError::propagate)?,
}
});
let renders = fields.iter().map(|row| {
let (field, member, gate) = (&row.field, &row.member, &row.gate);
quote! {
#gate
__ingraph_map.insert(
#ag::Name::new(#field),
#ag::InputType::to_value(&self.#member),
);
}
});
let position_entries = positions.iter().map(|row| {
let (field, held) = (&row.field, &row.held);
let value = face.meta_input_value(field, "e!(::core::option::Option<#held>));
quote!(__ingraph_fields.insert(::std::string::String::from(#field), #value);)
});
let position_parses = positions.iter().map(|row| {
let (field, member, held) = (&row.field, &row.member, &row.held);
quote! {
#member: ::core::option::Option::map(
<::core::option::Option<#held> as #ag::InputType>::parse(
#ag::indexmap::IndexMap::get(&__ingraph_object, #field).cloned(),
)
.map_err(#ag::InputValueError::propagate)?,
::std::boxed::Box::new,
),
}
});
let position_renders = positions.iter().map(|row| {
let (field, member) = (&row.field, &row.member);
quote! {
__ingraph_map.insert(
#ag::Name::new(#field),
match &self.#member {
::core::option::Option::Some(__ingraph_position) => {
#ag::InputType::to_value(&**__ingraph_position)
}
::core::option::Option::None => #ag::Value::Null,
},
);
}
});
let nullable_face = crate::emit::framework(face.krate, &["graphql"], "NullableFace");
let fields = face.fields_block(entries.chain(position_entries));
let info = face.type_info(
"e!(<Self as #nullable_face>::bare_fields(__ingraph_registry)),
false,
);
let sent = crate::emit::framework(face.krate, &["graphql", "filter"], "sent");
let sent_ty = crate::emit::framework(face.krate, &["graphql", "filter"], "Sent");
quote! {
#[automatically_derived]
impl #ag::InputType for #name {
type RawValueType = Self;
#info
fn parse(
value: ::core::option::Option<#ag::Value>,
) -> #ag::InputValueResult<Self> {
match #sent(value) {
#sent_ty::Longhand(__ingraph_object) => {
::core::result::Result::Ok(Self { #(#parses)* #(#position_parses)* })
}
#sent_ty::Bare(__ingraph_sent) => {
::core::result::Result::Err(#ag::InputValueError::expected_type(__ingraph_sent))
}
#sent_ty::Null => {
::core::result::Result::Err(#ag::InputValueError::expected_type(#ag::Value::Null))
}
#sent_ty::Refused(__ingraph_sent) => {
::core::result::Result::Err(#ag::InputValueError::expected_type(__ingraph_sent))
}
}
}
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)
}
}
#[automatically_derived]
impl #ag::InputObjectType for #name {}
#[automatically_derived]
impl #nullable_face for #name {
fn bare_fields(
__ingraph_registry: &mut #ag::registry::Registry,
) -> #ag::indexmap::IndexMap<::std::string::String, #ag::registry::MetaInputValue> {
#fields
}
fn bare_values(&self) -> #ag::indexmap::IndexMap<#ag::Name, #ag::Value> {
let mut __ingraph_map = #ag::indexmap::IndexMap::new();
#(#renders)*
#(#position_renders)*
__ingraph_map
}
}
}
}
#[must_use]
pub fn order_by_face(face: &InputFace<'_>, terms: &[OrderField]) -> proc_macro2::TokenStream {
let (ag, name) = (face.ag(), face.name);
let direction = crate::emit::framework(face.krate, &["graphql"], "OrderDirection");
let published = || terms.iter().filter(|term| term.published);
let entries = published().map(|term| {
let (field, gate) = (&term.field, &term.gate);
let value = face.meta_input_value(field, "e!(::core::option::Option<#direction>));
quote!(#gate __ingraph_fields.insert(::std::string::String::from(#field), #value);)
});
let parses = published().map(|term| {
let (field, variant, gate) = (&term.field, &term.variant, &term.gate);
quote! {
#gate
if #ag::indexmap::IndexMap::contains_key(&__ingraph_object, #field)
&& #ag::indexmap::IndexMap::len(&__ingraph_object) == 1
{
let __ingraph_direction = #ag::InputType::parse(
#ag::indexmap::IndexMap::swap_remove(&mut __ingraph_object, #field),
)
.map_err(#ag::InputValueError::propagate)?;
return ::core::result::Result::Ok(Self::#variant(__ingraph_direction));
}
}
});
let renders = terms.iter().map(|term| {
let (variant, field, gate) = (&term.variant, &term.field, &term.gate);
quote! {
#gate
Self::#variant(__ingraph_direction) => {
__ingraph_map.insert(
#ag::Name::new(#field),
#ag::InputType::to_value(__ingraph_direction),
);
}
}
});
let info = face.type_info(&face.fields_block(entries), true);
quote! {
#[automatically_derived]
impl #ag::InputType for #name {
type RawValueType = Self;
#info
fn parse(
value: ::core::option::Option<#ag::Value>,
) -> #ag::InputValueResult<Self> {
if let ::core::option::Option::Some(#ag::Value::Object(mut __ingraph_object)) = value {
#(#parses)*
return ::core::result::Result::Err(#ag::InputValueError::expected_type(
#ag::Value::Object(__ingraph_object),
));
}
::core::result::Result::Err(#ag::InputValueError::expected_type(
::core::option::Option::unwrap_or_default(value),
))
}
fn to_value(&self) -> #ag::Value {
let mut __ingraph_map = #ag::indexmap::IndexMap::new();
match self {
#(#renders)*
}
#ag::Value::Object(__ingraph_map)
}
#[inline]
fn as_raw_value(&self) -> ::core::option::Option<&Self::RawValueType> {
::core::option::Option::Some(self)
}
}
#[automatically_derived]
impl #ag::InputObjectType for #name {}
#[automatically_derived]
impl #ag::OneofObjectType for #name {}
}
}