use quote::quote;
use crate::{emit::leading, interface::InterfaceModel, method::Member, unit};
#[cfg(test)]
mod tests;
impl InterfaceModel {
pub(crate) fn wire(&self) -> proc_macro2::TokenStream {
if !self.projects() {
return quote!();
}
let filter = self.filter();
let arguments = self.arguments();
let faces = self.input_faces();
quote! {
#filter
#arguments
#faces
}
}
fn input_faces(&self) -> proc_macro2::TokenStream {
let interface = &self.name;
let gate = self.framework(&["gate"], "if_async_graphql");
let filter_name = super::default_filter_name(interface);
let order_name = super::default_order_by_name(interface);
let filter_sdl = filter_name.to_string();
let order_sdl = order_name.to_string();
let fields: Vec<unit::wire::FilterField> = self
.stored()
.map(|field| unit::wire::FilterField {
gate: proc_macro2::TokenStream::new(),
field: crate::emit::wire::wire_member(&field.name),
member: field.name.clone(),
filter: self.filter_of(field),
})
.collect();
let terms: Vec<unit::wire::OrderField> = self
.stored()
.map(|field| unit::wire::OrderField {
gate: proc_macro2::TokenStream::new(),
field: crate::emit::wire::wire_member(&field.name),
variant: crate::emit::upper_camel(&field.name.to_string()),
published: true,
})
.collect();
let filter = unit::wire::filter_face(
&unit::wire::InputFace {
krate: &self.krate,
name: &filter_name,
sdl: &filter_sdl,
},
&fields,
&[],
);
let order = unit::wire::order_by_face(
&unit::wire::InputFace {
krate: &self.krate,
name: &order_name,
sdl: &order_sdl,
},
&terms,
);
quote! {
#gate! {
#filter
#order
}
}
}
fn filter(&self) -> proc_macro2::TokenStream {
let interface = &self.name;
let rows: Vec<unit::FilterColumn> = self
.stored()
.map(|field| unit::FilterColumn {
gate: proc_macro2::TokenStream::new(),
member: field.name.clone(),
name: format!("shared `{}` column", field.name),
filter: self.filter_of(field),
})
.collect();
let header = unit::UnitHeader {
vis: &self.vis,
name: super::default_filter_name(interface),
subject: format!("[`{interface}`]"),
note: Some(
"One per interface where the page's own predicate is one per database: a client writes the \
CONTRACT's names at the contract's types, and which database answers is a deployment's \
business. A COMPUTED field is not here at all — it is derived from a member's wire output \
and is a column nowhere."
.to_owned(),
),
};
let (declaration, builders) = unit::filter(&header, &rows);
quote! {
#declaration
#builders
}
}
fn arguments(&self) -> proc_macro2::TokenStream {
let vis = &self.vis;
let interface = &self.name;
let name = super::default_input_name(interface);
let filter = super::default_filter_name(interface);
let order_by = super::default_order_by_name(interface);
let optional: Vec<(syn::Ident, proc_macro2::TokenStream, &str)> = vec![
(
quote::format_ident!("filter"),
quote!(#filter),
"The predicate this query is constrained by.",
),
(
quote::format_ident!("first"),
quote!(::core::primitive::u32),
"How many rows to take from the start of the order.",
),
(
quote::format_ident!("last"),
quote!(::core::primitive::u32),
"How many rows to take from the far end of the order.",
),
(
quote::format_ident!("after"),
quote!(::std::string::String),
"Resume after the row this cursor was minted at — the string `Cursor::encode` produced.",
),
(
quote::format_ident!("before"),
quote!(::std::string::String),
"Resume before the row this cursor was minted at — the string `Cursor::encode` produced.",
),
];
let members = optional
.iter()
.map(|(member, ty, _)| quote!(#member: ::core::option::Option<#ty>,));
let methods = optional.iter().map(|(member, ty, what)| {
let with = Member::With.name(member);
let borrow = Member::Borrow.name(member);
let with_doc = leading(&format!("The same arguments with `{member}` given. {what}"));
let borrow_doc = leading(&format!("`{member}`, where the client gave one. {what}"));
quote! {
#[doc = #with_doc]
#[must_use]
#[inline]
#vis fn #with(mut self, #member: #ty) -> Self {
self.#member = ::core::option::Option::Some(#member);
self
}
#[doc = #borrow_doc]
#[inline]
#vis const fn #borrow(&self) -> ::core::option::Option<&#ty> {
self.#member.as_ref()
}
}
});
let order = quote::format_ident!("order");
let with_order = Member::With.name(&order);
let order_slice = Member::Slice.name(&order);
let order_doc = leading(
"The same arguments with the order a client wrote — the terms in the sequence they run, \
which is the one structure the GraphQL specification calls ordered.",
);
let slice_doc = leading(
"The order as written, in the sequence its terms run. An EMPTY order is not a missing one: \
an interface's order completes with `(…, __ig_kind__, id)` whatever the client wrote, so \
the empty list is the page ordered by the tail alone.",
);
let doc = leading(&format!(
"A query's arguments over the [`{interface}`]s a client asks for — the interface's own lane, \
in the types a schema can name.\n\nThere is no ceiling and no skip: `InterfaceFind` offers \
neither, an interface's order never being absent, and a member no method could spend is an \
argument object promising a query the engine refuses."
));
quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::default::Default)]
#vis struct #name {
order: ::std::vec::Vec<#order_by>,
#(#members)*
}
impl #name {
#[doc = #order_doc]
#[must_use]
#[inline]
#vis fn #with_order(mut self, order: ::std::vec::Vec<#order_by>) -> Self {
self.order = order;
self
}
#[doc = #slice_doc]
#[inline]
#vis fn #order_slice(&self) -> &[#order_by] {
&self.order
}
#(#methods)*
}
}
}
}