use quote::{format_ident, quote};
use crate::{
method::Member,
model::{
Crossing, DatabaseBackend, FrameworkMarker, Graphql, GraphqlBackend, Label, Marker,
PersistColumn, RecordModel, Reference,
},
name::RustSafeName,
};
fn filter_of(
model: &RecordModel,
ty: &syn::Type,
marker: Option<&Marker>,
) -> proc_macro2::TokenStream {
let face = if model.kind.holds_rows() {
super::FilterFace::Column
} else {
super::FilterFace::Full
};
super::filter_of(&model.krate, ty, marker, face)
}
fn written_option(ty: &syn::Type) -> Option<&syn::Type> {
let syn::Type::Path(path) = ty else {
return None;
};
let segment = path.path.segments.last()?;
if path.qself.is_some() || segment.ident != "Option" {
return None;
}
let syn::PathArguments::AngleBracketed(arguments) = &segment.arguments else {
return None;
};
let mut arguments = arguments.args.iter();
match (arguments.next(), arguments.next()) {
(Some(syn::GenericArgument::Type(inner)), None) => Some(inner),
_ => None,
}
}
impl Marker {
pub(crate) fn resolved(&self, krate: &syn::Path, ty: &syn::Type) -> proc_macro2::TokenStream {
let shelved = |module: &[&str], name: &str| super::framework(krate, module, name);
let Self::Framework(FrameworkMarker { label, element, .. }) = self else {
let Self::Path(path) = self else {
unreachable!("a marker is one of the framework's words or a declared path")
};
return quote!(#path<#ty>);
};
let subject = written_option(ty);
let core = subject.unwrap_or(ty);
let marker = shelved(&["marker"], label.item());
let applied = match element {
None => quote!(#marker<#core>),
Some(element) => {
let element = shelved(&["marker"], element.item());
let state = shelved(&["state"], "State");
let extracted = shelved(&["state"], "Extracted");
let inner = shelved(&["state"], "Inner");
quote!(#marker<#core, #element<<#core as #state<#extracted<#inner>>>::Output>>)
}
};
if subject.is_none() || label.collection() {
return applied;
}
let marker = shelved(&["marker"], "Marker");
quote!(<#applied as #marker>::UnderOption)
}
}
impl RecordModel {
pub(crate) fn wire_writes_id(&self) -> bool {
let id = &self.key.id.source;
!self
.graphql
.as_ref()
.and_then(|graphql| graphql.backends.first())
.is_some_and(|backend| backend.fields().iter().any(|field| field.source == *id))
}
pub(crate) fn wire_rows(&self) -> Vec<&DatabaseBackend> {
let exposed: &[crate::model::GraphqlField] = self
.graphql
.as_ref()
.and_then(|graphql| graphql.backends.first())
.map_or(&[], GraphqlBackend::fields);
self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.filter(|database| {
self.key_columns_stored(database).is_some()
&& exposed.iter().all(|field| database.supplies(&field.source))
})
.collect()
}
pub(crate) fn key_columns_stored(&self, database: &DatabaseBackend) -> Option<Vec<usize>> {
self
.key
.columns()
.map(|column| {
database
.columns()
.iter()
.position(|stored| stored.source == column.source)
})
.collect()
}
pub(super) fn marker_of(&self, source: &syn::Ident) -> Option<&Marker> {
self
.fields
.iter()
.find(|field| field.column.source == *source)?
.marker
.as_ref()
}
pub(super) fn reference_of(&self, source: &syn::Ident) -> Option<&Reference> {
self
.fields
.iter()
.find(|field| field.column.source == *source)?
.reference
.as_ref()
}
}
impl RecordModel {
pub(super) fn ordering(&self) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
if self.persist.is_none() {
return Default::default();
}
let vis = &self.vis;
let record = &self.record;
let stored = self.stored_columns();
let order_by = self.order_by.safe();
let direction_ty = self.framework(&["graphql"], "OrderDirection");
let ordered_columns = self.ordered_columns();
let order_rows: ::std::vec::Vec<crate::unit::OrderColumn> = ordered_columns
.iter()
.map(|(_, column)| {
crate::unit::OrderColumn::of(&column.source, format!("`{}` column", column.name))
.with_gate(self.gate(&column.source))
})
.collect();
let order_header = crate::unit::UnitHeader {
vis,
name: order_by.clone(),
subject: format!("[`{record}`]"),
note: None,
};
let (declaration, direction) = crate::unit::order_by(&order_header, &direction_ty, &order_rows);
let order_column = self.framework(&["field"], "FieldName");
let not_stored = self.framework(&["query"], "ColumnNotStored");
let term_name = self.framework(&["cursor"], "TermName");
let resolvers = self.persist.iter().flat_map(|persist| &persist.backends).map(|database: &DatabaseBackend| {
let method = database.kind().order_resolver();
let kind = database.kind().as_str();
let arms = ordered_columns.iter().map(|(_, column)| {
let variant = column.order_variant();
let gate = self.gate(&column.source);
let answer = match database.stores(&column.source) {
Some(mine) => {
let name = mine.name.to_string();
quote!(::core::result::Result::Ok(#order_column::new(#name)))
}
None => {
let identity = RustSafeName::from_ident(&column.source).external().to_owned();
quote! {
::core::result::Result::Err(#not_stored::new(#term_name::new(#identity), #kind))
}
}
};
quote!(#gate Self::#variant(_) => #answer,)
});
let doc = super::leading(&format!(
"The column this orders by IN {kind} — a plain name, quoted by the backend that renders it, which `persist({kind}(rename))` may make differ from another database's.\n\n# Errors\n\n`ColumnNotStored` where the declaration narrowed this term's column out of `{kind}`: the word is in the schema because the schema states the declaration's truth, and this deployment's database is what has not got the column."
));
quote! {
#[doc = #doc]
#[inline]
#vis const fn #method(
self,
) -> ::core::result::Result<&'static #order_column, #not_stored> {
match self {
#(#arms)*
}
}
}
});
let paged = self.id_column_stored().is_some()
&& self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.any(|backend| backend.kind().is_sql());
let identity = paged.then(|| crate::unit::order_identity(vis, &term_name, &order_rows));
let to_subject_path = self.framework(&["graphql"], "ToSubjectPath");
let subject_path = self.framework(&["graphql"], "SubjectPath");
let subject = crate::unit::order_subject_path(
order_by,
&to_subject_path,
&subject_path,
&term_name,
&order_rows,
);
let column_kind = self.framework(&["column"], "ColumnKind");
let order_term = self.framework(&["cursor"], "OrderTerm");
let terms = self
.persist
.iter()
.filter(|_| paged)
.flat_map(|persist| &persist.backends)
.filter(|backend| backend.kind().is_sql())
.map(|backend: &DatabaseBackend| {
let method = backend.kind().order_term();
let kind = backend.kind().as_str();
let arms = ordered_columns.iter().map(|(_, column)| {
let variant = column.order_variant();
let identity = RustSafeName::from_ident(&column.source).external().to_owned();
let gate = self.gate(&column.source);
let Some(per_db) = backend.stores(&column.source) else {
let name = column.name.to_string();
return quote! {
#gate
Self::#variant(direction) => #order_term::absent(
#term_name::new(#identity),
#order_column::new(#name),
direction,
#kind,
),
};
};
let name = per_db.name.to_string();
let build = if self.collects(&column.source) {
let mirrored = backend.mirrors(self, per_db);
let subject = match (backend.edge_stored(self, per_db), mirrored) {
(true, true) => quote!(#order_term::shadow),
(true, false) => quote!(#order_term::edge),
(false, _) => quote!(#order_term::array),
};
let rendered = if mirrored {
backend.sort_column(self, per_db)
} else {
name.clone()
};
quote! {
#subject(
#term_name::new(#identity),
#order_column::new(#rendered),
direction,
)
}
} else {
let ty = per_db.ty();
let width = if per_db.nullable {
quote!(#order_term::spanning_nullable)
} else {
quote!(#order_term::spanning)
};
quote! {
#width(
#term_name::new(#identity),
#order_column::new(#name),
<#ty as #column_kind>::SEGMENTS,
<#ty as #column_kind>::ORDER,
direction,
)
}
};
quote! {
#gate
Self::#variant(direction) => #build,
}
});
let body = if ordered_columns.is_empty() {
quote!(match self {})
} else {
quote! {
match self {
#(#arms)*
}
}
};
let doc = super::leading(&format!(
"This term as a page renders it IN {} — its rename-proof identity, this database's column \
name, the direction it runs in, and whether that column can hold `NULL`.",
backend.kind().as_str()
));
quote! {
#[doc = #doc]
#[inline]
#vis const fn #method(self) -> #order_term {
#body
}
}
});
let complete = self.id_column_stored().filter(|_| paged).map(|at| {
let variant = stored[at].order_variant();
let tail = quote! {
if !::core::iter::Iterator::any(&mut written.iter(), |__ingraph_term| {
::core::matches!(__ingraph_term, Self::#variant(_))
}) {
::std::vec::Vec::push(&mut order, Self::#variant(#direction_ty::Asc));
}
};
let doc = super::leading(
"This order completed into a TOTAL one: the written terms, then the id ascending where none \
of them named it. A term that already named the id moves it rather than repeating it, and \
the tail is what a keyset cursor pages without skipping or repeating a row.",
);
quote! {
#[doc = #doc]
#[must_use]
#vis fn complete(written: &[Self]) -> ::std::vec::Vec<Self> {
let mut order = ::std::vec::Vec::from(written);
#tail
order
}
}
});
let lowerings = self.orderings(&order_column);
let methods = quote! {
impl #order_by {
#(#resolvers)*
#direction
#identity
#(#terms)*
#complete
#(#lowerings)*
}
#subject
};
(declaration, methods)
}
fn orderings(&self, order_column: &proc_macro2::TokenStream) -> Vec<proc_macro2::TokenStream> {
let Some(id_at) = self.id_column_stored() else {
return Vec::new();
};
let stored = self.stored_columns();
let vis = &self.vis;
let builder = self.framework(&["comparison", "sql"], "QueryBuilder");
let ordered = self.framework(&["comparison", "sql"], "OrderByClause");
let transition = self.framework(&["comparison", "sql"], "ClauseTransition");
let quoting = self.framework(&["comparison", "sql"], "QuoteIdent");
let database = self.framework(&["sqlx"], "Database");
let held = self.framework(&["sqlx"], "QueryBuilder");
let not_stored = self.framework(&["query"], "ColumnNotStored");
let clause = super::parameter("CLAUSE");
let db = super::parameter("DB");
let holder = super::parameter("HOLDER");
let address = &stored[id_at].source;
self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.filter(|backend| backend.kind().is_sql())
.map(|backend: &DatabaseBackend| {
let method = backend.kind().order_lowering();
let resolver = backend.kind().order_resolver();
let column = backend
.stores(address)
.expect("an address step is a column of every database the record declares")
.name
.to_string();
let variant = stored[id_at].order_variant();
let tail = quote! {
if !::core::iter::once(__ingraph_first)
.chain(__ingraph_rest)
.any(|__ingraph_term| ::core::matches!(__ingraph_term, Self::#variant(_)))
{
__ingraph_builder =
__ingraph_builder.order_by(#order_column::new(#column), false);
}
};
let doc = super::leading(&format!(
"Order a statement by this term and the ones after it IN {kind}, and then by the id — \
the requested columns followed by `{column}` ascending, which is what a keyset cursor \
pages without skipping or repeating a row. A term naming the id moves it rather than \
repeating it. A query that wrote no term does not call this at all: it gets no \
`ORDER BY`, which is the answer SQL already has for an unordered query.\n\n# Errors\n\n\
`ColumnNotStored` where a term names a column the declaration narrowed out of `{kind}`. \
The word is in the schema because the schema states the declaration's truth; this \
deployment's database is what has not got the column, and the refusal names both. \
*A refusal leaves the accumulator exactly as it was found* does NOT hold here — the \
builder is taken by value and a refused order returns none of it.",
kind = backend.kind().as_str(),
));
quote! {
#[doc = #doc]
#vis fn #method<#clause, #db, #holder>(
__ingraph_first: &Self,
__ingraph_rest: &[Self],
__ingraph_builder: #builder<#clause, #db, #holder>,
) -> ::core::result::Result<#builder<#ordered, #db, #holder>, #not_stored>
where
#clause: #transition<#ordered>,
#db: #database + #quoting,
#holder: ::core::borrow::BorrowMut<#held<#db>>,
{
let mut __ingraph_builder = __ingraph_builder.order_by(
__ingraph_first.#resolver()?,
__ingraph_first.direction().is_descending(),
);
for __ingraph_term in __ingraph_rest {
__ingraph_builder = __ingraph_builder.order_by(
__ingraph_term.#resolver()?,
__ingraph_term.direction().is_descending(),
);
}
#tail
::core::result::Result::Ok(__ingraph_builder)
}
}
})
.collect()
}
}
pub(super) struct FilterRow {
pub(super) member: syn::Ident,
pub(super) column: String,
pub(super) declared: String,
pub(super) wire: syn::Type,
pub(super) filter: proc_macro2::TokenStream,
pub(super) operators: proc_macro2::TokenStream,
}
pub(super) struct RelationRow {
pub(super) member: syn::Ident,
pub(super) source: String,
pub(super) path: syn::Path,
pub(super) declared: proc_macro2::TokenStream,
pub(super) held: proc_macro2::TokenStream,
}
pub(super) struct ForwardRow {
pub(super) position: syn::Ident,
pub(super) column: syn::Ident,
pub(super) target: syn::Path,
pub(super) spelling: String,
pub(super) held: proc_macro2::TokenStream,
}
fn target_filter(model: &RecordModel, target: &syn::Path) -> proc_macro2::TokenStream {
let face = model.framework(&["transform"], "Graphql");
let input = model.framework(&["transform"], "GraphqlInput");
quote!(<<#target as #face>::Input as #input>::Filter)
}
impl Graphql {
pub(super) fn relation_rows(&self, model: &RecordModel) -> Vec<RelationRow> {
let related = model.framework(&["graphql"], "RelatedFilter");
let related_evidence = model.framework(&["transform"], "Related");
let record = &model.record;
model
.derived
.iter()
.map(|entry| {
let source = &entry.source;
let declared = entry.field.as_ref().map_or_else(
|| quote!(<#source as #related_evidence<#record>>::COLUMNS[0].as_str()),
|field| quote!(#field),
);
let filter = target_filter(model, source);
RelationRow {
member: entry.name.clone(),
source: quote!(#source).to_string().replace(' ', ""),
path: source.clone(),
declared,
held: quote!(#related<#filter>),
}
})
.collect()
}
pub(super) fn relation_columns(&self, model: &RecordModel) -> Vec<crate::unit::FilterColumn> {
self
.relation_rows(model)
.into_iter()
.map(|row| {
let held = &row.held;
crate::unit::FilterColumn {
name: format!("`{}` reverse position (`{}`)", row.member, row.source),
filter: quote!(::std::boxed::Box<#held>),
member: row.member,
gate: proc_macro2::TokenStream::new(),
}
})
.collect()
}
pub(super) fn filter_rows(&self, model: &RecordModel) -> Vec<FilterRow> {
let Some(backend) = self.backends.first() else {
return Vec::new();
};
model
.queried_columns()
.into_iter()
.map(|(_, column)| {
let (member, declared, ty) = backend.filter_field(column);
let column_filter = filter_of(model, &ty, model.marker_of(&column.source));
FilterRow {
member,
column: column.name.to_string(),
declared,
filter: match model.reference_of(&column.source) {
Some(reference) => self.widened(model, &column_filter, reference),
None => column_filter.clone(),
},
operators: column_filter,
wire: ty,
}
})
.collect()
}
fn widened(
&self,
model: &RecordModel,
column: &proc_macro2::TokenStream,
reference: &Reference,
) -> proc_macro2::TokenStream {
let widened = model.framework(&["graphql"], "RefFilter");
let nested = target_filter(model, &reference.target);
quote!(#widened<#column, #nested>)
}
pub(super) fn forward_rows(&self, model: &RecordModel) -> Vec<ForwardRow> {
let Some(backend) = self.backends.first() else {
return Vec::new();
};
model
.queried_columns()
.into_iter()
.filter_map(|(_, column)| {
let reference = model.reference_of(&column.source)?;
let (member, _, ty) = backend.filter_field(column);
let held = self.widened(
model,
&filter_of(model, &ty, model.marker_of(&column.source)),
reference,
);
let target = &reference.target;
Some(ForwardRow {
position: format_ident!("{member}_related"),
column: member,
spelling: quote!(#target).to_string().replace(' ', ""),
target: target.clone(),
held,
})
})
.collect()
}
pub(crate) fn faces(
&self,
model: &RecordModel,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let mut types = proc_macro2::TokenStream::new();
let mut impls = proc_macro2::TokenStream::new();
let Some(backend) = self.backends.first() else {
return (types, impls);
};
let vis = &model.vis;
let record = &model.record;
let (input_type, input_impl) = self.arguments(model);
types.extend(input_type);
let output_ty = self.output.safe();
let key_output = self.key_output.safe();
let id_ty = &model.key.id.ty;
let writes_id = model.wire_writes_id();
let substrate = super::substrate();
let id_member = writes_id.then(|| quote!(#substrate id: #id_ty,));
let members = backend.fields().iter().map(|field| {
let name = &field.source;
let ty = field.wire_ty();
let gate = model.gate(name);
quote!(#gate #substrate #name: #ty,)
});
let doc = super::leading(&format!(
"The wire face of a [`{record}`] — its id, its whole address, and every field the declaration \
exposes."
));
types.extend(quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone)]
#vis struct #output_ty {
#id_member
#substrate key: #key_output,
#(#members)*
}
});
let key_members = model.key.columns().map(|column| {
let name = &column.name;
let ty = &column.ty;
quote!(#substrate #name: #ty,)
});
let doc = super::leading(&format!(
"A [`{record}`]'s address, on the wire — what a search or knn hit renders into."
));
types.extend(quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone)]
#vis struct #key_output {
#(#key_members)*
}
});
let (key_input_ty, key_input_impl) = self.key_input(model);
types.extend(key_input_ty);
let filter = self.filter.safe();
let mut filter_rows: ::std::vec::Vec<crate::unit::FilterColumn> = self
.filter_rows(model)
.into_iter()
.map(|row| crate::unit::FilterColumn {
name: format!("`{}` column", row.column),
filter: row.filter,
gate: model.gate(&row.member),
member: row.member,
})
.collect();
filter_rows.extend(self.relation_columns(model));
let filter_header = crate::unit::UnitHeader {
vis,
name: filter.clone(),
subject: format!("[`{record}`]"),
note: None,
};
let (filter_type, filter_builders) = crate::unit::filter(&filter_header, &filter_rows);
types.extend(filter_type);
let id_borrow = Member::Borrow.name(&format_ident!("id"));
let key_borrow = Member::Borrow.name(&format_ident!("key"));
let id_doc = super::leading("The row's own id, by reference.");
let key_doc = super::leading("The row's whole address, by reference.");
let id_accessor = writes_id.then(|| {
quote! {
#[doc = #id_doc]
#[inline]
#vis const fn #id_borrow(&self) -> &#id_ty {
&self.id
}
}
});
let address_accessors = quote! {
#id_accessor
#[doc = #key_doc]
#[inline]
#vis const fn #key_borrow(&self) -> &#key_output {
&self.key
}
};
let accessors = backend.fields().iter().map(|field| {
let name = &field.source;
let borrow = Member::Borrow.name(field.accessor());
let ty = field.wire_ty();
let gate = model.gate(name);
let doc = super::leading(&format!("The `{name}` field, by reference."));
quote! {
#gate
#[doc = #doc]
#[inline]
#vis const fn #borrow(&self) -> &#ty {
&self.#name
}
}
});
let key_accessors = model.key.columns().map(|column| {
column.methods(
vis,
&model.krate,
&format!("`{}` step of the address", column.name),
false,
&proc_macro2::TokenStream::new(),
)
});
let key_name = &model.key.name;
let key_reads = model.key.columns().map(|column| {
let name = &column.name;
quote!(#name: key.#name,)
});
let key_doc = super::leading(&format!("Project a [`{key_name}`] onto the wire."));
let rows = self.row_crossings(model);
impls.extend(quote! {
impl #output_ty {
#address_accessors
#(#accessors)*
}
#input_impl
#filter_builders
impl #key_output {
#(#key_accessors)*
}
#rows
#[automatically_derived]
impl ::core::convert::From<#key_name> for #key_output {
#[doc = #key_doc]
#[inline]
fn from(key: #key_name) -> Self {
Self { #(#key_reads)* }
}
}
#key_input_impl
});
(types, impls)
}
fn key_input(&self, model: &RecordModel) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let vis = &model.vis;
let record = &model.record;
let key_name = &model.key.name;
let crossing = model.framework(&["graphql"], "ToGraphqlInput");
let substrate = super::substrate();
if !model.key.compound() {
let id = &model.key.id.name;
let id_ty = &model.key.id.ty;
return (
proc_macro2::TokenStream::new(),
quote! {
#[automatically_derived]
impl #crossing for #key_name {
type Input = <#id_ty as #crossing>::Input;
type Error = <#id_ty as #crossing>::Error;
#[inline]
fn cross(input: Self::Input) -> ::core::result::Result<Self, Self::Error> {
::core::result::Result::Ok(Self::new(<#id_ty as #crossing>::cross(input)?))
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
<#id_ty as #crossing>::carry(&operand.#id)
}
}
},
);
}
let input_ty = crate::model::default_key_input_name(record);
let members = model.key.columns().map(|column| {
let name = &column.name;
let ty = &column.ty;
let doc = super::leading(&format!(
"The `{name}` step of the address, in the declaration's own type — see the type's note for \
where the wire form is crossed."
));
quote! {
#[doc = #doc]
#substrate #name: #ty,
}
});
let names: Vec<&syn::Ident> = model.key.columns().map(|column| &column.name).collect();
let doc = super::leading(&format!(
"A [`{record}`]'s address, as a client SENDS it — one required field per step of \
[`{key_name}`], because an address with a step missing is not an address.\n\nEvery field \
crosses through the operand map, so a step whose declared type has no wire form of its own \
arrives as the carrier that type's row names."
));
let types = quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone)]
#vis struct #input_ty {
#(#members)*
}
};
let impls = quote! {
#[automatically_derived]
impl #crossing for #key_name {
type Input = #input_ty;
type Error = ::core::convert::Infallible;
#[inline]
fn cross(input: Self::Input) -> ::core::result::Result<Self, Self::Error> {
::core::result::Result::Ok(Self::new(#(input.#names,)*))
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
#input_ty {
#(#names: ::core::clone::Clone::clone(&operand.#names),)*
}
}
}
};
(types, impls)
}
fn arguments(&self, model: &RecordModel) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let vis = &model.vis;
let record = &model.record;
let input_ty = self.input.safe();
let filter = self.filter.safe();
let order_by = model.order_by.safe();
let paged: Vec<(syn::Ident, proc_macro2::TokenStream, &'static str)> = if model.orderable() {
vec![
(
format_ident!("first"),
quote!(::core::primitive::u32),
"How many rows to take from the start of the order.",
),
(
format_ident!("last"),
quote!(::core::primitive::u32),
"How many rows to take from the far end of the order.",
),
(
format_ident!("after"),
quote!(::std::string::String),
"Resume after the row this cursor was minted at — the string `Cursor::encode` produced.",
),
(
format_ident!("before"),
quote!(::std::string::String),
"Resume before the row this cursor was minted at — the string `Cursor::encode` produced.",
),
(
format_ident!("skip"),
quote!(::core::primitive::u64),
"How many rows of the walk to pass before the page begins.",
),
]
} else {
Vec::new()
};
let optional: Vec<(syn::Ident, proc_macro2::TokenStream, &'static str)> = core::iter::once((
format_ident!("filter"),
quote!(#filter),
"The predicate this query is constrained by.",
))
.chain(core::iter::once((
format_ident!("limit"),
quote!(::core::primitive::u32),
"A ceiling on an UNORDERED query — any this many rows, which is what a query with no order \
can honestly be asked for.",
)))
.chain(paged)
.collect();
let substrate = super::substrate();
let order = model
.orderable()
.then(|| quote!(#substrate order: ::std::vec::Vec<#order_by>,));
let members = optional
.iter()
.map(|(name, ty, _)| quote!(#substrate #name: ::core::option::Option<#ty>,));
let doc = super::leading(&format!(
"A query's arguments over the [`{record}`]s a client asks for — the engine's own find surface, \
in the types a schema can name."
));
let declaration = quote! {
#[doc = #doc]
#[derive(::core::fmt::Debug, ::core::clone::Clone, ::core::default::Default)]
#vis struct #input_ty {
#order
#(#members)*
}
};
let order_methods = model.orderable().then(|| {
let with = Member::With.name(&format_ident!("order"));
let slice = Member::Slice.name(&format_ident!("order"));
let with_doc = super::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 = super::leading("The order as written, in the sequence its terms run.");
quote! {
#[doc = #with_doc]
#[must_use]
#[inline]
#vis fn #with(mut self, order: ::std::vec::Vec<#order_by>) -> Self {
self.order = order;
self
}
#[doc = #slice_doc]
#[inline]
#vis fn #slice(&self) -> &[#order_by] {
&self.order
}
}
});
let methods = optional.iter().map(|(name, ty, what)| {
let with = Member::With.name(name);
let borrow = Member::Borrow.name(name);
let with_doc = super::leading(&format!("The same arguments with `{name}` given. {what}"));
let borrow_doc = super::leading(&format!("`{name}`, where the client gave one. {what}"));
quote! {
#[doc = #with_doc]
#[must_use]
#[inline]
#vis fn #with(mut self, #name: #ty) -> Self {
self.#name = ::core::option::Option::Some(#name);
self
}
#[doc = #borrow_doc]
#[inline]
#vis const fn #borrow(&self) -> ::core::option::Option<&#ty> {
self.#name.as_ref()
}
}
});
let implementation = quote! {
impl #input_ty {
#order_methods
#(#methods)*
}
};
(declaration, implementation)
}
fn row_crossings(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let Some(backend) = self.backends.first() else {
return proc_macro2::TokenStream::new();
};
let record = &model.record;
let output_ty = self.output.safe();
let key_output = self.key_output.safe();
let key_name = &model.key.name;
let writes_id = model.wire_writes_id();
let vocabulary = model.framework(&["transform"], "Record");
let mut emitted = proc_macro2::TokenStream::new();
for database in model.wire_rows() {
let kind = database.kind();
let columns = database.columns();
let Some(key_at) = model.key_columns_stored(database) else {
continue;
};
let mut fallible = false;
let shared: Vec<(syn::Ident, bool)> = model
.key
.columns()
.map(|column| {
let published = backend
.fields()
.iter()
.find(|field| field.source == column.source);
let same = published
.is_some_and(|field| field.output_crossing.leg(kind).is_none() && field.wire.is_none());
(column.source.clone(), same)
})
.collect();
let cloned_into_the_key = |source: &syn::Ident| {
shared
.iter()
.any(|(column, same)| column == source && *same)
};
let locals: Vec<proc_macro2::TokenStream> = model
.key
.columns()
.zip(&key_at)
.map(|(column, &at)| {
let stored = &columns[at];
let local = format_ident!("__ingraph_{}", column.source);
let field = stored.name.safe();
fallible |= stored.into.fallible();
let read = if backend
.fields()
.iter()
.any(|field| field.source == column.source)
&& !cloned_into_the_key(&column.source)
{
quote!(::core::clone::Clone::clone(&__ingraph_row.#field))
} else {
quote!(__ingraph_row.#field)
};
let value = stored.into.apply(read, stored.stored.is_some());
quote!(let #local = #value;)
})
.collect();
let arguments = model.key.columns().map(|column| {
let local = format_ident!("__ingraph_{}", column.source);
if (writes_id && column.source == model.key.id.source)
|| cloned_into_the_key(&column.source)
{
return quote!(::core::clone::Clone::clone(&#local));
}
quote!(#local)
});
let id_local = format_ident!("__ingraph_{}", model.key.id.source);
let id_read = writes_id.then(|| quote!(id: #id_local,));
let reads: Vec<proc_macro2::TokenStream> = backend
.fields()
.iter()
.map(|field| {
let member = &field.source;
let Some(stored) = database.stores(&field.source) else {
let fill = database
.storage()
.fills
.iter()
.find(|filled| filled.source == field.source)
.expect("`RecordModel::wire_rows` refuses a database that supplies no exposed field");
let ty = model
.fields
.iter()
.find(|declared| declared.column.source == field.source)
.map(|declared| &declared.column.ty)
.expect("a filled field is one the record declares");
let value = fill.fill.value(ty);
let value = if field.wire.is_some() {
quote!(::core::convert::Into::into(#value))
} else {
value
};
let condition = model.gate(&field.source);
return quote!(#condition #member: #value,);
};
let held = stored.name.safe();
if cloned_into_the_key(&field.source) {
let local = format_ident!("__ingraph_{}", field.source);
let condition = model.gate(&field.source);
return quote!(#condition #member: #local,);
}
let value = match field.output_crossing.leg(kind) {
Some(declared) => {
fallible |= declared.fallible();
declared.apply(quote!(__ingraph_row.#held), false)
}
None => {
fallible |= stored.into.fallible();
let raised = stored
.into
.apply(quote!(__ingraph_row.#held), stored.stored.is_some());
if field.wire.is_some() {
quote!(::core::convert::Into::into(#raised))
} else {
raised
}
}
};
let condition = model.gate(&field.source);
quote!(#condition #member: #value,)
})
.collect();
let backend_ty = database.backend_type(model);
let gate = model.framework(&["gate"], &kind.gate().to_string());
let error = fallible.then(|| model.error(Crossing::Output, kind));
let leg = super::conversion(
quote!(<#record as #vocabulary<#backend_ty>>::Row),
output_ty,
&format_ident!("__ingraph_row"),
quote! {
{
#(#locals)*
let __ingraph_key = <#key_output as ::core::convert::From<#key_name>>::from(
#key_name::new(#(#arguments,)*),
);
Self {
#id_read
key: __ingraph_key,
#(#reads)*
}
}
},
error.as_ref(),
&format!(
"Raise a stored {} row onto the wire — every column through the crossing its declaration \
names, and the address out of the columns that carry it.",
kind.as_str()
),
);
emitted.extend(quote! {
#gate! { #leg }
});
}
emitted
}
}
pub(crate) fn upper_camel(name: &str) -> syn::Ident {
let mut camel = String::with_capacity(name.len());
let mut upper = true;
for c in name.chars() {
if c == '_' {
upper = true;
} else if upper {
camel.extend(c.to_uppercase());
upper = false;
} else {
camel.push(c);
}
}
if camel.is_empty() || camel.starts_with(|c: char| c.is_ascii_digit()) {
camel.insert(0, 'X');
}
format_ident!("{camel}")
}
impl GraphqlBackend {
pub(crate) fn filter_field(&self, column: &PersistColumn) -> (syn::Ident, String, syn::Type) {
let exposed = self
.fields()
.iter()
.find(|field| field.source == column.source);
let sdl = exposed.map_or_else(
|| {
RustSafeName::from_ident(column.member())
.external()
.to_owned()
},
|field| field.input.name.to_string(),
);
let ty = exposed.map_or_else(|| column.domain.clone(), |field| field.wire_ty().clone());
(column.member().clone(), sdl, ty)
}
}
impl RecordModel {
pub(crate) fn stored_columns(&self) -> Vec<&PersistColumn> {
let Some(persist) = self.persist.as_ref() else {
return Vec::new();
};
self
.fields
.iter()
.filter_map(|field| {
persist
.backends
.iter()
.find_map(|database| database.stores(&field.column.source))
})
.collect()
}
pub(crate) fn queried_columns(&self) -> Vec<(usize, &PersistColumn)> {
self
.stored_columns()
.into_iter()
.enumerate()
.filter(|(_, column)| self.published(&column.source))
.collect()
}
pub(crate) fn published(&self, source: &syn::Ident) -> bool {
self
.graphql
.as_ref()
.is_none_or(|graphql| graphql.publishes(source))
}
pub(crate) fn ordered_columns(&self) -> Vec<(usize, &PersistColumn)> {
self
.stored_columns()
.into_iter()
.enumerate()
.filter(|(_, column)| !column.flatten)
.collect()
}
pub(crate) fn shape_of(&self, source: &syn::Ident) -> Option<Label> {
match self.marker_of(source) {
Some(Marker::Framework(marker)) if marker.label.collection() => Some(marker.label),
_ => None,
}
}
pub(crate) fn collects(&self, source: &syn::Ident) -> bool {
matches!(
self.marker_of(source),
Some(Marker::Framework(marker)) if marker.label.collection()
)
}
pub(crate) fn sortable(&self, source: &syn::Ident) -> bool {
self
.fields
.iter()
.find(|field| field.column.source == *source)
.is_some_and(|field| field.sortable)
}
pub(crate) fn indexed(&self, source: &syn::Ident) -> bool {
self
.fields
.iter()
.find(|field| field.column.source == *source)
.is_some_and(|field| field.indexed)
}
pub(crate) fn id_column_stored(&self) -> Option<usize> {
let id = &self.key.id;
self
.stored_columns()
.iter()
.position(|persisted| persisted.source == id.source)
}
}
impl PersistColumn {
pub(crate) const fn member(&self) -> &syn::Ident {
&self.source
}
pub(crate) fn order_variant(&self) -> syn::Ident {
upper_camel(&self.source.to_string())
}
}
impl DatabaseBackend {
pub(crate) fn comparison(
&self,
model: &RecordModel,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let vis = &model.vis;
let record = &model.record;
let name = self.comparison_name();
let db = super::parameter("DB");
let to_comparison = model.framework(&["comparison"], "ToDatabaseComparison");
let columns = self.compared(model);
let held = |column: &PersistColumn| {
let (filter, stored) = (
filter_of(model, &column.domain, model.marker_of(&column.source)),
column.ty(),
);
quote!(<#filter as #to_comparison<#stored, #db>>::Comparison)
};
let crossings = self.assumptions(model);
let mut rows: ::std::vec::Vec<crate::unit::ComparisonColumn> = columns
.iter()
.map(|column| crate::unit::ComparisonColumn {
member: column.member().clone(),
name: format!("`{}` column", column.name),
held: held(column),
gate: model.gate(&column.source),
})
.collect();
rows.extend(
self
.relations(model)
.into_iter()
.map(|row| crate::unit::ComparisonColumn {
name: format!("`{}` reverse position (`{}`)", row.member, row.source),
held: self.related_comparison(model, &row),
member: row.member,
gate: proc_macro2::TokenStream::new(),
}),
);
rows.extend(
self
.forwards(model)
.into_iter()
.map(|row| crate::unit::ComparisonColumn {
name: format!(
"`{}` reference's nested predicate (`{}`)",
row.column, row.spelling
),
held: self.forward_comparison(model, &row),
gate: proc_macro2::TokenStream::new(),
member: row.position,
}),
);
let header = crate::unit::UnitHeader {
vis,
name: name.clone(),
subject: format!("[`{record}`]"),
note: None,
};
let (declaration, methods) = crate::unit::comparison(&header, &db, &crossings, &rows);
let lowering = self.lowering(model);
let collapse = self.collapse(model);
(declaration, quote! { #methods #lowering #collapse })
}
fn related_comparison(&self, model: &RecordModel, row: &RelationRow) -> proc_macro2::TokenStream {
let db = super::parameter("DB");
let to_related = model.framework(&["comparison"], "ToRelatedComparison");
let record = model.framework(&["transform"], "Record");
let (held, source) = (&row.held, &row.path);
quote!(<#held as #to_related<<#source as #record<#db>>::Comparison, #db>>::Comparison)
}
fn forward_comparison(&self, model: &RecordModel, row: &ForwardRow) -> proc_macro2::TokenStream {
let db = super::parameter("DB");
let to_related = model.framework(&["comparison"], "ToRelatedComparison");
let record = model.framework(&["transform"], "Record");
let (held, target) = (&row.held, &row.target);
quote! {
<#held as #to_related<
::std::boxed::Box<<#target as #record<#db>>::Comparison>,
#db,
>>::Comparison
}
}
fn related_seat(
&self,
model: &RecordModel,
held: &proc_macro2::TokenStream,
far: &syn::Path,
boxed: bool,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let db = super::parameter("DB");
let to_lowered = model.framework(&["comparison"], "ToLoweredRelatedComparison");
let record = model.framework(&["transform"], "Record");
let nested = if boxed {
quote!(::std::boxed::Box<<#far as #record<#db>>::Comparison>)
} else {
quote!(<#far as #record<#db>>::Comparison)
};
(held.clone(), quote!(#to_lowered<#nested, #db>))
}
pub(super) fn forwards(&self, model: &RecordModel) -> Vec<ForwardRow> {
if !self.kind().is_sql() {
return Vec::new();
}
model
.graphql
.as_ref()
.map(|graphql| {
graphql
.forward_rows(model)
.into_iter()
.filter(|row| self.stores(&row.column).is_some())
.collect()
})
.unwrap_or_default()
}
pub(super) fn relations(&self, model: &RecordModel) -> Vec<RelationRow> {
if !self.kind().is_sql() {
return Vec::new();
}
model
.graphql
.as_ref()
.map(|graphql| graphql.relation_rows(model))
.unwrap_or_default()
}
pub(crate) fn assumptions(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let db = super::parameter("DB");
let backend = model.framework(&["comparison"], "Backend");
let to_comparison = model.framework(&["comparison"], "ToDatabaseComparison");
let to_flattened = model.framework(&["comparison"], "ToFlattenedComparison");
let crossings = self.compared(model).into_iter().map(|column| {
let (filter, stored) = (
filter_of(model, &column.domain, model.marker_of(&column.source)),
column.ty(),
);
let crossing = if column.flatten {
&to_flattened
} else {
&to_comparison
};
quote!(#filter: #crossing<#stored, #db>,)
});
let graphql = model.framework(&["transform"], "Graphql");
let graphql_input = model.framework(&["transform"], "GraphqlInput");
let record = model.framework(&["transform"], "Record");
let to_related = model.framework(&["comparison"], "ToRelatedComparison");
let relations = self.relations(model).into_iter().map(|row| {
let (held, source) = (&row.held, &row.path);
quote! {
#source: #record<#db> + #graphql,
<#source as #graphql>::Input: #graphql_input,
#held: #to_related<<#source as #record<#db>>::Comparison, #db>,
}
});
let forwards = self.forwards(model).into_iter().map(|row| {
let (held, target) = (&row.held, &row.target);
quote! {
#target: #record<#db> + #graphql,
<#target as #graphql>::Input: #graphql_input,
#held: #to_related<::std::boxed::Box<<#target as #record<#db>>::Comparison>, #db>,
}
});
quote! {
#db: #backend,
#(#crossings)*
#(#relations)*
#(#forwards)*
}
}
fn lowering_assumptions(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let assumptions = self.assumptions(model);
let relations = self
.relations(model)
.into_iter()
.map(|row| self.related_seat(model, &row.held, &row.path, false))
.collect::<Vec<_>>();
let forwards = self
.forwards(model)
.into_iter()
.map(|row| self.related_seat(model, &row.held, &row.target, true))
.collect::<Vec<_>>();
let members = relations
.into_iter()
.chain(forwards)
.map(|(held, bound)| quote!(#held: #bound,));
quote! {
#assumptions
#(#members)*
}
}
fn lowering(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let seats = crate::unit::LoweringSeats {
backend: model.framework(&["comparison"], "Backend"),
complex: model.framework(&["comparison"], "ComplexComparison"),
frame: model.framework(&["comparison"], "Frame"),
at: model.framework(&["comparison"], "At"),
field_name: model.framework(&["field"], "FieldName"),
};
let mut rows: ::std::vec::Vec<crate::unit::LoweringColumn> = self
.compared(model)
.into_iter()
.map(|column| crate::unit::LoweringColumn {
member: column.member().clone(),
rendered: column.name.to_string(),
flatten: column.flatten,
through: None,
gate: model.gate(&column.source),
})
.collect();
rows.extend(self.relations(model).into_iter().map(|row| {
let (held, bound) = self.related_seat(model, &row.held, &row.path, false);
crate::unit::LoweringColumn::unframed(row.member, quote!(<#held as #bound>))
}));
let framed: ::std::collections::HashMap<syn::Ident, String> = self
.compared(model)
.into_iter()
.map(|column| (column.member().clone(), column.name.to_string()))
.collect();
rows.extend(self.forwards(model).into_iter().map(|row| {
let (held, bound) = self.related_seat(model, &row.held, &row.target, true);
crate::unit::LoweringColumn::framed(
row.position,
framed.get(&row.column).cloned().unwrap_or_default(),
Some(quote!(<#held as #bound>)),
)
}));
crate::unit::comparison_lowering(
self.comparison_name(),
&super::parameter("DB"),
&self.lowering_assumptions(model),
&seats,
&rows,
)
}
fn collapse(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let columns = self.compared(model);
let id = model.key.id.source.clone();
let Some(id_column) = columns.iter().find(|column| column.source == id) else {
return proc_macro2::TokenStream::new();
};
let backend = self.backend_type(model);
let (collapsible, referential, complex, to_comparison) = (
model.framework(&["comparison"], "CollapsibleComparison"),
model.framework(&["comparison"], "ReferentialComparison"),
model.framework(&["comparison"], "ComplexComparison"),
model.framework(&["comparison"], "ToDatabaseComparison"),
);
let (filter, stored) = (
filter_of(model, &id_column.domain, model.marker_of(&id_column.source)),
id_column.ty(),
);
let held = quote!(<#filter as #to_comparison<#stored, #backend>>::Comparison);
let others: Vec<(proc_macro2::TokenStream, syn::Ident)> = columns
.iter()
.filter(|column| column.source != id)
.map(|column| (model.gate(&column.source), column.member().clone()))
.chain(
self
.relations(model)
.into_iter()
.map(|row| (proc_macro2::TokenStream::new(), row.member)),
)
.chain(
self
.forwards(model)
.into_iter()
.map(|row| (proc_macro2::TokenStream::new(), row.position)),
)
.collect();
let member = id_column.member();
let name = self.comparison_name();
let gate = model.framework(&["gate"], &self.kind().gate().to_string());
let conditional = others.iter().any(|(gate, _)| !gate.is_empty());
let (accumulated, collapses) = if conditional {
let terms = others.iter().map(|(gate, member)| {
quote! {
#gate
{
__ingraph_others_empty &= #complex::<#backend>::is_empty(&self.#member);
}
}
});
(
quote! {
let mut __ingraph_others_empty = true;
#(#terms)*
},
quote!(__ingraph_others_empty && #referential::<#backend>::is_referential(&self.#member)),
)
} else {
let terms = others
.iter()
.map(|(_, member)| quote!(#complex::<#backend>::is_empty(&self.#member) &&));
(
proc_macro2::TokenStream::new(),
quote!(#(#terms)* #referential::<#backend>::is_referential(&self.#member)),
)
};
quote! {
#gate! {
#[automatically_derived]
impl #collapsible<#backend> for #name<#backend>
where
#held: #referential<#backend>,
{
type Id = #held;
#[inline]
fn only_id(&self) -> ::core::option::Option<&Self::Id> {
#accumulated
if #collapses {
return ::core::option::Option::Some(&self.#member);
}
::core::option::Option::None
}
}
}
}
}
pub(crate) fn comparison_traits(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let Some(graphql) = model.graphql.as_ref() else {
return proc_macro2::TokenStream::new();
};
let name = self.comparison_name();
let row = self.name();
let db = super::parameter("DB");
let filter = graphql.filter.safe();
let to_comparison = model.framework(&["comparison"], "ToDatabaseComparison");
let crossings = self.lowering_assumptions(model);
quote! {
#[automatically_derived]
impl<#db> #to_comparison<#row, #db> for #filter
where
#crossings
{
type Comparison = #name<#db>;
}
}
}
}