use quote::quote;
use crate::{
emit::leading,
model::{Conversion, Crossing, DatabaseBackend, RecordModel},
};
impl DatabaseBackend {
fn relation_legs(&self, model: &RecordModel) -> Vec<proc_macro2::TokenStream> {
let backend = self.backend_type(model);
let related_filter = model.framework(&["graphql"], "RelatedFilter");
let derived = model.framework(&["comparison", "sql"], "SqlDerivedComparison");
let related_row = model.framework(&["comparison", "sql"], "RelatedRow");
let try_from_filter = model.framework(&["comparison"], "TryFromFilter");
let stored_column = model.framework(&["column"], "stored_column");
let field_name = model.framework(&["field"], "FieldName");
let record_of = model.framework(&["transform"], "Record");
let sql_query = model.framework(&["query", "sql"], "SqlQuery");
self
.relations(model)
.into_iter()
.map(|row| {
let (member, source, declared) = (&row.member, &row.path, &row.declared);
let nested = quote!(<#source as #record_of<#backend>>::Comparison);
let far_row = quote!(<#source as #record_of<#backend>>::Row);
let why = format!(
"`{source}` stores no single column for the field the `{position}` reverse position \
points back through. A relation joins ONE column to one column, so the field has to be \
in this database's `persist(…)` block and has to span one column there — a field spanning \
several has no single name to be a join's side.",
source = quote!(#source).to_string().replace(' ', ""),
position = member,
);
let cross = |bound: &proc_macro2::TokenStream| {
quote! {
match #try_from_filter::try_from_filter(#bound) {
::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));
}
}
}
};
let quantifier = cross("e!(__ingraph_nested));
let cardinality = cross("e!(__ingraph_count));
quote! {
let #member = {
const __INGRAPH_POINTS_BACK__: &'static #field_name = {
const __INGRAPH_DECLARED__: &'static ::core::primitive::str = #declared;
match #stored_column(
<#far_row as #sql_query<#backend>>::COLUMNS,
__INGRAPH_DECLARED__,
) {
::core::option::Option::Some(__ingraph_stored) => __ingraph_stored,
::core::option::Option::None => ::core::panic!(#why),
}
};
let __ingraph_position = <#derived<#nested, #backend>>::new(
#related_row::of::<#far_row, #backend>(),
__INGRAPH_POINTS_BACK__,
);
match __ingraph_filter.#member {
::core::option::Option::Some(__ingraph_held) => match *__ingraph_held {
#related_filter::Any(__ingraph_nested) =>
__ingraph_position.with_any(#quantifier),
#related_filter::All(__ingraph_nested) =>
__ingraph_position.with_all(#quantifier),
#related_filter::None(__ingraph_nested) =>
__ingraph_position.with_none(#quantifier),
#related_filter::Count(__ingraph_count) =>
__ingraph_position.with_count(#cardinality),
},
::core::option::Option::None => __ingraph_position,
}
};
}
})
.collect()
}
fn forward_leg(
&self,
model: &RecordModel,
row: &crate::emit::graphql::ForwardRow,
) -> proc_macro2::TokenStream {
let backend = self.backend_type(model);
let target = &row.target;
let reference = model.framework(&["comparison", "sql"], "SqlRefComparison");
let related_row = model.framework(&["comparison", "sql"], "RelatedRow");
let try_from_filter = model.framework(&["comparison"], "TryFromFilter");
let record_of = model.framework(&["transform"], "Record");
let nested = quote!(<#target as #record_of<#backend>>::Comparison);
let far_row = quote!(<#target as #record_of<#backend>>::Row);
quote! {
match __ingraph_related {
::core::option::Option::Some(__ingraph_nested) => {
let __ingraph_crossed: #nested =
match #try_from_filter::try_from_filter(*__ingraph_nested) {
::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::Some(<#reference<::std::boxed::Box<#nested>, #backend>>::new(
#related_row::of::<#far_row, #backend>(),
::std::boxed::Box::new(__ingraph_crossed),
))
}
::core::option::Option::None => ::core::option::Option::None,
}
}
}
fn unstored_leg(
&self,
model: &RecordModel,
row: &crate::emit::graphql::FilterRow,
) -> proc_macro2::TokenStream {
let sent = &row.member;
let condition = model.gate(sent);
let not_stored = model.framework(&["query"], "ColumnNotStored");
let term_name = model.framework(&["cursor"], "TermName");
let identity = crate::name::RustSafeName::from_ident(sent)
.external()
.to_owned();
let database = self.kind().as_str();
quote! {
#condition
if ::core::option::Option::is_some(&__ingraph_filter.#sent) {
return ::core::result::Result::Err(::core::convert::Into::into(
#not_stored::new(#term_name::new(#identity), #database),
));
}
}
}
pub(crate) fn filter_crossing(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let Some(graphql) = model.graphql.as_ref() else {
return proc_macro2::TokenStream::new();
};
if !model.wire_filters()
|| model
.wire_query_row()
.is_none_or(|served| served.kind() != self.kind())
{
return proc_macro2::TokenStream::new();
}
let rows = graphql.filter_rows(model);
if rows.is_empty() {
return proc_macro2::TokenStream::new();
}
let kind = self.kind();
let filter = graphql.filter.safe();
let comparison = self.comparison_name();
let backend = self.backend_type(model);
let error = model.error(Crossing::Comparison, kind);
let try_from_filter = model.framework(&["comparison"], "TryFromFilter");
let to_comparison = model.framework(&["comparison"], "ToDatabaseComparison");
let gate = model.framework(&["gate"], &kind.gate().to_string());
let mut members: Vec<proc_macro2::TokenStream> = self
.compared(model)
.into_iter()
.map(|column| {
let (condition, member) = (model.gate(&column.source), column.member());
quote!(#condition #member,)
})
.collect();
members.extend(self.relations(model).into_iter().map(|row| {
let member = row.member;
quote!(#member,)
}));
members.extend(self.forwards(model).into_iter().map(|row| {
let position = row.position;
quote!(#position,)
}));
let forwards = self.forwards(model);
let legs = rows.iter().map(|row| {
let sent = &row.member;
let Some(column) = self.stores(sent) else {
return self.unstored_leg(model, row);
};
let member = column.member();
let wire = &row.operators;
let stored = column.ty();
let domain = super::filter_of(
&model.krate,
&column.domain,
model.marker_of(&column.source),
super::FilterFace::Column,
);
let held = quote!(<#domain as #to_comparison<#stored, #backend>>::Comparison);
let crossed = match model.operand(&column.source, kind) {
Some(Conversion::Fallible(convert)) => {
let path = &convert.path;
let absorb = convert.escape.as_ref().map_or_else(
|| quote!(::core::convert::Into::into(__ingraph_why)),
|escape| quote!(#escape(__ingraph_why)),
);
quote! {
match <#held>::try_from_filter_with(__ingraph_held, #path) {
::core::result::Result::Ok(__ingraph_crossed) => __ingraph_crossed,
::core::result::Result::Err(__ingraph_why) => {
return ::core::result::Result::Err(#absorb);
}
}
}
}
Some(Conversion::Infallible(path)) => quote! {
match <#held>::try_from_filter_with(
__ingraph_held,
|__ingraph_operand| ::core::result::Result::<_, ::core::convert::Infallible>::Ok(
#path(__ingraph_operand),
),
) {
::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));
}
}
},
Some(Conversion::Default) | None => quote! {
match <#held as #try_from_filter<#wire>>::try_from_filter(__ingraph_held) {
::core::result::Result::Ok(__ingraph_crossed) => __ingraph_crossed,
::core::result::Result::Err(__ingraph_why) => {
let __ingraph_why: <#held as #try_from_filter<#wire>>::Error = __ingraph_why;
return ::core::result::Result::Err(::core::convert::Into::into(__ingraph_why));
}
}
},
};
let condition = model.gate(&column.source);
let Some(forward) = forwards.iter().find(|row| row.column == *member) else {
return quote! {
#condition
let #member = match __ingraph_filter.#sent {
::core::option::Option::Some(__ingraph_held) => #crossed,
::core::option::Option::None => ::core::default::Default::default(),
};
};
};
let position = &forward.position;
let nested = self.forward_leg(model, forward);
quote! {
#condition
let (__ingraph_column, __ingraph_related) = match __ingraph_filter.#sent {
::core::option::Option::Some(__ingraph_widened) => {
let (__ingraph_column, __ingraph_related) = __ingraph_widened.into_parts();
(
::core::option::Option::Some(__ingraph_column),
__ingraph_related,
)
}
::core::option::Option::None => (
::core::option::Option::None,
::core::option::Option::None,
),
};
#condition
let #member = match __ingraph_column {
::core::option::Option::Some(__ingraph_held) => #crossed,
::core::option::Option::None => ::core::default::Default::default(),
};
#condition
let #position = #nested;
}
});
let relations = self.relation_legs(model);
let record = &model.record;
let doc = leading(&format!(
"Cross a wire filter into the predicate a [`{record}`] is queried by in this database — every \
operand through the crossing its declaration names, and the empty comparison wherever the \
client asked nothing.\n\n# Errors\nWhatever an operand's crossing into its stored form \
refused with, absorbed by the cell `graphql(input(comparison(…)))` names."
));
quote! {
#gate! {
#[automatically_derived]
impl #try_from_filter<#filter> for #comparison<#backend> {
type Error = #error;
#[doc = #doc]
fn try_from_filter(
__ingraph_filter: #filter,
) -> ::core::result::Result<Self, Self::Error> {
#(#legs)*
#(#relations)*
::core::result::Result::Ok(Self::new(#(#members)*))
}
}
}
}
}
}