use quote::quote;
use crate::{
model::{DatabaseKind, Marker},
name::RustSafeName,
unit,
};
#[cfg(test)]
mod tests;
pub struct StandaloneModel {
pub vis: syn::Visibility,
pub subject: syn::Ident,
pub krate: syn::Path,
pub filter: RustSafeName,
pub order_by: RustSafeName,
pub comparison: RustSafeName,
pub databases: Vec<DatabaseKind>,
pub columns: Vec<StandaloneColumn>,
pub hook: Option<syn::Path>,
}
pub struct StandaloneColumn {
pub member: syn::Ident,
pub name: RustSafeName,
pub domain: syn::Type,
pub wire: Option<syn::Type>,
pub marker: Option<Marker>,
pub stored: Vec<StandaloneStored>,
}
pub struct StandaloneStored {
pub ty: Option<syn::Type>,
pub flatten: bool,
}
impl StandaloneModel {
fn framework(&self, module: &[&str], item: &str) -> proc_macro2::TokenStream {
crate::emit::framework(&self.krate, module, item)
}
fn subject(&self) -> String {
format!("[`{}`]", self.subject)
}
pub fn emit_filter(&self) -> proc_macro2::TokenStream {
let rows: Vec<unit::FilterColumn> = self
.columns
.iter()
.map(|column| unit::FilterColumn {
gate: proc_macro2::TokenStream::new(),
member: column.member.clone(),
name: format!("`{}` column", column.name),
filter: crate::emit::filter_of(
&self.krate,
column.wire.as_ref().unwrap_or(&column.domain),
column.marker.as_ref(),
crate::emit::FilterFace::Column,
),
})
.collect();
let header = unit::UnitHeader {
vis: &self.vis,
name: self.filter.safe().clone(),
subject: self.subject(),
note: None,
};
let (declaration, builders) = unit::filter(&header, &rows);
quote! { #declaration #builders }
}
pub fn emit_order_by(&self) -> proc_macro2::TokenStream {
let rows = self.order_rows();
let direction_ty = self.framework(&["graphql"], "OrderDirection");
let term_name = self.framework(&["cursor"], "TermName");
let to_subject_path = self.framework(&["graphql"], "ToSubjectPath");
let subject_path = self.framework(&["graphql"], "SubjectPath");
let name = self.order_by.safe();
let header = unit::UnitHeader {
vis: &self.vis,
name: name.clone(),
subject: self.subject(),
note: None,
};
let (declaration, direction) = unit::order_by(&header, &direction_ty, &rows);
let identity = unit::order_identity(&self.vis, &term_name, &rows);
let subject =
unit::order_subject_path(name, &to_subject_path, &subject_path, &term_name, &rows);
quote! {
#declaration
impl #name {
#direction
#identity
}
#subject
}
}
fn order_rows(&self) -> Vec<unit::OrderColumn> {
self
.columns
.iter()
.map(|column| unit::OrderColumn::of(&column.member, format!("`{}` column", column.name)))
.collect()
}
pub fn emit_comparison(&self) -> proc_macro2::TokenStream {
if self.databases.is_empty() {
let name = RustSafeName::from_ident(&crate::model::default_comparison_name(
self.comparison.safe(),
));
let comparison = self.one_comparison(&name, None);
let pair = self.generic_pair(&name, None);
return quote! { #comparison #pair };
}
let each = self.databases.iter().enumerate().map(|(at, kind)| {
let row = crate::model::default_row_name(self.comparison.safe(), *kind);
let name = RustSafeName::from_ident(&crate::model::default_comparison_name(&row));
let comparison = self.one_comparison(&name, Some(at));
let pair = self.generic_pair(&name, Some(at));
quote! { #comparison #pair }
});
quote! { #(#each)* }
}
fn one_comparison(&self, name: &RustSafeName, at: Option<usize>) -> proc_macro2::TokenStream {
let db = crate::emit::parameter("DB");
let crossings = self.assumptions(&db, at);
let rows: Vec<unit::ComparisonColumn> = self
.columns
.iter()
.map(|column| unit::ComparisonColumn {
gate: proc_macro2::TokenStream::new(),
member: column.member.clone(),
name: format!("`{}` column", column.name),
held: self.held(column, &db, at),
})
.collect();
let header = unit::UnitHeader {
vis: &self.vis,
name: name.safe().clone(),
subject: self.subject(),
note: None,
};
let (declaration, methods) = unit::comparison(&header, &db, &crossings, &rows);
let seats = unit::LoweringSeats {
backend: self.framework(&["comparison"], "Backend"),
complex: self.framework(&["comparison"], "ComplexComparison"),
frame: self.framework(&["comparison"], "Frame"),
at: self.framework(&["comparison"], "At"),
field_name: self.framework(&["field"], "FieldName"),
};
let lowered: Vec<unit::LoweringColumn> = self
.columns
.iter()
.map(|column| unit::LoweringColumn {
gate: proc_macro2::TokenStream::new(),
member: column.member.clone(),
rendered: column.name.to_string(),
flatten: at
.and_then(|at| column.stored.get(at))
.is_some_and(|stored| stored.flatten),
through: None,
})
.collect();
let lowering = unit::comparison_lowering(name.safe(), &db, &crossings, &seats, &lowered);
let crossing = self.crossing(name, &db, at);
quote! { #declaration #methods #lowering #crossing }
}
fn held(
&self,
column: &StandaloneColumn,
db: &syn::Ident,
at: Option<usize>,
) -> proc_macro2::TokenStream {
let to_comparison = self.framework(&["comparison"], "ToDatabaseComparison");
let filter = crate::emit::filter_of(
&self.krate,
&column.domain,
column.marker.as_ref(),
crate::emit::FilterFace::Column,
);
let stored = self.stored(column, at);
quote!(<#filter as #to_comparison<#stored, #db>>::Comparison)
}
fn stored(&self, column: &StandaloneColumn, at: Option<usize>) -> proc_macro2::TokenStream {
let domain = &column.domain;
at.and_then(|at| column.stored.get(at))
.and_then(|stored| stored.ty.as_ref())
.map_or_else(|| quote!(#domain), |ty| quote!(#ty))
}
fn assumptions(&self, db: &syn::Ident, at: Option<usize>) -> proc_macro2::TokenStream {
let backend = self.framework(&["comparison"], "Backend");
let to_comparison = self.framework(&["comparison"], "ToDatabaseComparison");
let to_flattened = self.framework(&["comparison"], "ToFlattenedComparison");
let crossings = self.columns.iter().map(|column| {
let filter = crate::emit::filter_of(
&self.krate,
&column.domain,
column.marker.as_ref(),
crate::emit::FilterFace::Column,
);
let stored = self.stored(column, at);
let flatten = at
.and_then(|at| column.stored.get(at))
.is_some_and(|stored| stored.flatten);
let crossing = if flatten {
&to_flattened
} else {
&to_comparison
};
quote!(#filter: #crossing<#stored, #db>,)
});
quote! {
#db: #backend,
#(#crossings)*
}
}
fn crossing(
&self,
name: &RustSafeName,
db: &syn::Ident,
at: Option<usize>,
) -> proc_macro2::TokenStream {
let Some(hook) = self.hook.as_ref() else {
return proc_macro2::TokenStream::new();
};
let subject = &self.subject;
let to_comparison = self.framework(&["comparison"], "ToDatabaseComparison");
let crossings = self.assumptions(db, at);
let name = name.safe();
quote! {
#[automatically_derived]
impl<#db> #to_comparison<#subject, #db> for #hook
where
#crossings
{
type Comparison = #name<#db>;
}
}
}
fn crossing_of(
&self,
column: &StandaloneColumn,
at: Option<usize>,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
(
self.stored(column, at),
crate::emit::filter_of(
&self.krate,
&column.domain,
column.marker.as_ref(),
crate::emit::FilterFace::Column,
),
)
}
fn crossings(&self, db: &syn::Ident, at: Option<usize>) -> proc_macro2::TokenStream {
let backend = self.framework(&["comparison"], "Backend");
let to_crossed = self.framework(&["comparison"], "ToCrossedComparison");
let to_flattened = self.framework(&["comparison"], "ToFlattenedComparison");
let mut seen: Vec<String> = Vec::new();
let mut rows = proc_macro2::TokenStream::new();
for column in &self.columns {
let (stored, slot) = self.crossing_of(column, at);
let flatten = at
.and_then(|at| column.stored.get(at))
.is_some_and(|stored| stored.flatten);
let mut row = quote!(#slot: #to_crossed<#stored, #db>,);
if flatten {
row.extend(quote!(#slot: #to_flattened<#stored, #db>,));
}
let spelling = row.to_string();
if seen.iter().any(|kept| kept == &spelling) {
continue;
}
seen.push(spelling);
rows.extend(row);
}
quote! {
#db: #backend,
#rows
}
}
fn generic_pair(&self, name: &RustSafeName, at: Option<usize>) -> proc_macro2::TokenStream {
let Some(hook) = self.hook.as_ref() else {
return proc_macro2::TokenStream::new();
};
let db = crate::emit::parameter("DB");
let comparison = name.safe();
let try_from_filter = self.framework(&["comparison"], "TryFromFilter");
let to_crossed = self.framework(&["comparison"], "ToCrossedComparison");
let boxed = crate::model::boxed_error();
let clause = self.crossings(&db, at);
let doc = crate::emit::leading(&format!(
"Cross a wire filter into the predicate this {subject}'s comparison compares by — every \
column through its own crossing, and the empty comparison wherever the client asked \
nothing.\n\nONE impl for every backend: this {subject}'s comparison is generic in its dialect \
even where the declaration names a database, so its crossing carries each column's row rather \
than discharging it.\n\n# Errors\nWhatever a column's crossing into its stored form refused \
with.",
subject = self.subject(),
));
let members: Vec<proc_macro2::TokenStream> = self
.columns
.iter()
.map(|column| {
let member = &column.member;
quote!(#member,)
})
.collect();
let empty: Vec<proc_macro2::TokenStream> = self
.columns
.iter()
.map(|column| {
let (stored, slot) = self.crossing_of(column, at);
quote!(<#slot as #to_crossed<#stored, #db>>::empty(),)
})
.collect();
let legs = self.columns.iter().map(|column| {
let member = &column.member;
let (stored, slot) = self.crossing_of(column, at);
quote! {
let #member = match __ingraph_filter.#member {
::core::option::Option::Some(__ingraph_held) => {
match <#slot as #to_crossed<#stored, #db>>::cross(__ingraph_held) {
::core::result::Result::Ok(__ingraph_crossed) => __ingraph_crossed,
::core::result::Result::Err(__ingraph_why) => {
return ::core::result::Result::Err(::core::convert::Into::into(__ingraph_why));
}
}
}
::core::option::Option::None => <#slot as #to_crossed<#stored, #db>>::empty(),
};
}
});
quote! {
#[automatically_derived]
impl<#db> ::core::default::Default for #comparison<#db>
where
#clause
{
#[inline]
fn default() -> Self {
Self::new(#(#empty)*)
}
}
#[automatically_derived]
impl<#db> #try_from_filter<#hook> for #comparison<#db>
where
#clause
{
type Error = #boxed;
#[doc = #doc]
fn try_from_filter(
__ingraph_filter: #hook,
) -> ::core::result::Result<Self, Self::Error> {
#(#legs)*
::core::result::Result::Ok(Self::new(#(#members)*))
}
}
}
}
}