mod cross;
mod graphql;
mod mongo;
mod queries;
mod query;
mod relate;
mod sql;
pub(crate) mod wire;
pub(crate) use graphql::upper_camel;
use quote::{format_ident, quote, quote_spanned};
mod channel;
mod declared;
mod grant;
mod poll;
mod topology;
#[cfg(test)]
mod batching_tests;
#[cfg(test)]
mod indexed_tests;
#[cfg(test)]
mod shadow_cursor_tests;
#[cfg(test)]
mod sortable_tests;
#[cfg(test)]
mod tracing_tests;
pub use topology::PAIRED;
use crate::{
method,
model::{
Column, Conversion, Crossing, DatabaseBackend, DatabaseKind, Kind, PersistColumn, Projection,
RecordModel, Shape, Upstreams, fanned_lineage, fanned_lineage_column, one_storage_marker,
},
};
struct Family {
derives: proc_macro2::TokenStream,
attrs: proc_macro2::TokenStream,
via: Option<String>,
mapping: Mapping,
what: fn(DatabaseKind) -> &'static str,
noun: &'static str,
}
enum Mapping {
#[allow(dead_code)]
Attribute(&'static str),
Decode(fn(&DatabaseBackend, &RecordModel) -> proc_macro2::TokenStream),
AttributeAndDecode(
&'static str,
fn(&DatabaseBackend, &RecordModel) -> proc_macro2::TokenStream,
),
}
fn conversion(
from: proc_macro2::TokenStream,
into: &syn::Ident,
binding: &syn::Ident,
body: proc_macro2::TokenStream,
error: Option<&proc_macro2::TokenStream>,
doc: &str,
) -> proc_macro2::TokenStream {
let doc = leading(doc);
if let Some(error) = error {
return quote! {
#[automatically_derived]
impl ::core::convert::TryFrom<#from> for #into {
type Error = #error;
#[doc = #doc]
#[inline]
fn try_from(#binding: #from) -> ::core::result::Result<Self, Self::Error> {
::core::result::Result::Ok(#body)
}
}
};
}
quote! {
#[automatically_derived]
impl ::core::convert::From<#from> for #into {
#[doc = #doc]
#[inline]
fn from(#binding: #from) -> Self {
#body
}
}
}
}
pub(crate) fn leading(doc: &str) -> String {
format!(" {doc}")
}
pub(crate) fn framework(
krate: &syn::Path,
module: &[&str],
name: &str,
) -> proc_macro2::TokenStream {
let module = module.iter().map(|segment| format_ident!("{segment}"));
let name = format_ident!("{name}");
quote!(#krate::__private #(:: #module)* :: #name)
}
pub(crate) fn lower_initial(published: &str) -> String {
let mut characters = published.chars();
match characters.next() {
Some(first) => first.to_lowercase().chain(characters).collect(),
None => published.to_owned(),
}
}
pub(crate) fn raise_initial(published: &str) -> String {
let mut characters = published.chars();
match characters.next() {
Some(first) => first.to_uppercase().chain(characters).collect(),
None => published.to_owned(),
}
}
pub(crate) fn respan(
tokens: proc_macro2::TokenStream,
at: proc_macro2::Span,
) -> proc_macro2::TokenStream {
tokens
.into_iter()
.map(|token| match token {
proc_macro2::TokenTree::Group(group) => {
let mut respanned = proc_macro2::Group::new(group.delimiter(), respan(group.stream(), at));
respanned.set_span(at);
proc_macro2::TokenTree::Group(respanned)
}
mut other => {
other.set_span(at);
other
}
})
.collect()
}
pub(crate) fn snake(name: &str) -> String {
use heck::ToSnakeCase as _;
name.to_snake_case()
}
pub(crate) fn family(ty: &syn::Type) -> String {
let syn::Type::Path(path) = ty else {
return String::new();
};
let Some(last) = path.path.segments.last() else {
return String::new();
};
let name = last.ident.to_string();
let stem = name.strip_suffix("Id").filter(|rest| !rest.is_empty());
snake(stem.unwrap_or(&name))
}
pub(crate) fn positions(
declared: &[Option<&crate::model::Condition>],
) -> (proc_macro2::TokenStream, Vec<proc_macro2::TokenStream>) {
if declared
.iter()
.all(|condition| condition.is_none_or(crate::model::Condition::always_present))
{
return (
proc_macro2::TokenStream::new(),
(0..declared.len()).map(|at| quote!(#at)).collect(),
);
}
let names: Vec<syn::Ident> = (0..declared.len())
.map(|at| format_ident!("__INGRAPH_AT_{at}"))
.collect();
let mut places = proc_macro2::TokenStream::new();
for (at, name) in names.iter().enumerate() {
let place = match at.checked_sub(1) {
None => quote!(0usize),
Some(before) => {
let previous = &names[before];
let term =
declared[before].map_or_else(|| quote!(1usize), crate::model::Condition::present);
quote!(#previous + #term)
}
};
places.extend(quote!(const #name: ::core::primitive::usize = #place;));
}
(places, names.iter().map(|name| quote!(#name)).collect())
}
pub(crate) fn vendored(krate: &syn::Path, name: &str) -> String {
let name = format_ident!("{name}");
quote!(#krate::__private::#name)
.to_string()
.replace(' ', "")
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum FilterFace {
Full,
Column,
}
impl FilterFace {
fn item(self) -> syn::Ident {
match self {
Self::Full => format_ident!("Filter"),
Self::Column => format_ident!("ColumnFilter"),
}
}
}
pub(crate) fn filter_of(
krate: &syn::Path,
ty: &syn::Type,
marker: Option<&crate::model::Marker>,
face: FilterFace,
) -> proc_macro2::TokenStream {
let to_filter = framework(krate, &["graphql"], "ToGraphqlFilter");
let item = face.item();
let Some(marker) = marker else {
let inferred = framework(krate, &["marker"], "DefaultMarker");
return quote!(<<#ty as #inferred>::Marker as #to_filter>::#item);
};
let resolved = marker.resolved(krate, ty);
quote!(<#resolved as #to_filter>::#item)
}
pub(super) fn parameter(name: &str) -> syn::Ident {
format_ident!("__INGRAPH_{name}__")
}
pub(crate) fn wide_signature() -> proc_macro2::TokenStream {
quote!(#[allow(clippy::too_many_arguments)])
}
pub(crate) fn substrate() -> proc_macro2::TokenStream {
quote!(pub(crate))
}
impl RecordModel {
pub fn emit(&self) -> proc_macro2::TokenStream {
let record = &self.record;
let (key_doc, new_doc) = match self.lineage {
Some(_) => (
format!("The address of a [`{record}`] row: its lineage path followed by its own id."),
"Construct an address from its lineage path and the row's own id.".to_owned(),
),
None => (
format!("The address of a [`{record}`] row: its own id."),
"Construct an address from the row's own id.".to_owned(),
),
};
let (key_type, key_impl) = self.address_type(
&self.key.name,
&key_doc,
&new_doc,
self.key.columns(),
Some(&self.key.id),
);
let key_from = self.address_conversions(&self.key.name, self.key.columns());
let (lineage_type, lineage_impl, lineage_from) = match self
.lineage
.as_ref()
.map(|lineage| (lineage, &lineage.shape))
{
Some((lineage, Shape::Path(columns))) => {
let (declaration, methods) = self.address_type(
&lineage.name,
&format!("The path from the root to a [`{record}`] row, root-first."),
"Construct a path from its steps, root-first.",
columns.iter(),
None,
);
(
Some(declaration),
Some(methods),
Some(self.address_conversions(&lineage.name, columns.iter())),
)
}
Some((lineage, Shape::Kinds(kinds))) => {
let (declaration, conversions) = self.lineage_kinds(&lineage.name, kinds);
(Some(declaration), None, Some(conversions))
}
None => (None, None, None),
};
let storage_marker = self.storage_marker();
let (topology_types, topology_impls) = self.topology();
let declared = self.declared();
let receipts = self.receipts();
let (poll_types, poll_impls) = self.poll_face();
let (grant_types, grant_impls) = self.polling_face();
let (channel_types, channel_impls) = self.channel_face();
let subscription = self.subscription();
let goodbye = self.goodbye();
let face = self.face();
let key_parent = self.key_parent();
let root_projection = self.root_projection();
let record_impl = self.methods();
let binding = self.binding();
let wire_binding = self.wire_binding();
let hydration_binding = self.hydration_binding();
let address_segments = self.address_segments();
let relations = self.relations();
let (row_types, row_impls) = self.rows();
let (wire_types, wire_impls) = self
.graphql
.as_ref()
.map_or_else(Default::default, |graphql| graphql.faces(self));
let wire = self.wire();
let queries_type = self.queries_type();
let remote_prelude = self.remote_prelude();
let remote_family = self.remote_family();
quote! {
#key_type
#lineage_type
#row_types
#wire_types
#queries_type
#topology_types
#poll_types
#grant_types
#channel_types
#storage_marker
const _: () = {
#remote_prelude
#remote_family
#key_impl
#lineage_impl
#record_impl
#binding
#wire_binding
#hydration_binding
#address_segments
#relations
#key_from
#lineage_from
#row_impls
#wire_impls
#wire
#subscription
#topology_impls
#declared
#receipts
#root_projection
#poll_impls
#grant_impls
#channel_impls
#goodbye
#face
#key_parent
};
}
}
fn goodbye(&self) -> Option<proc_macro2::TokenStream> {
if !self.teardown {
return None;
}
let record = &self.record;
let teardown = self.framework(&["drive"], "AsyncTeardown");
Some(quote! {
const _: () = {
fn __ig_says_goodbye<__INGRAPH_NODE__: #teardown>() {}
const _: fn() = __ig_says_goodbye::<#record>;
};
})
}
fn face(&self) -> Option<proc_macro2::TokenStream> {
let word = self
.asynchronous
.as_ref()
.or(self.streaming.as_ref())
.or(self.autonomous.as_ref())?;
let named = match (
self.streaming.is_some(),
self.autonomous.is_some(),
self.asynchronous.is_some(),
) {
(true, _, true) => "AsyncStreamOperator",
(true, _, false) => "StreamOperator",
(false, true, true) => "AsyncAutonomousOperator",
(false, true, false) => "AutonomousOperator",
(false, false, _) => "AsyncOperator",
};
let operator = self.framework(&["operator"], named);
let mut node = self.record.clone();
node.set_span(syn::spanned::Spanned::span(word));
Some(quote! {
const _: () = {
fn __ig_awaits<__INGRAPH_NODE__: #operator>() {}
const _: fn() = __ig_awaits::<#node>;
};
})
}
fn storage_marker(&self) -> Option<proc_macro2::TokenStream> {
self.kind.stores().then(|| {
let marker = one_storage_marker(&self.prefix, &self.record);
quote! {
#[doc(hidden)]
#[allow(dead_code, non_upper_case_globals)]
const #marker: () = ();
}
})
}
fn subscription(&self) -> Option<proc_macro2::TokenStream> {
let upstreams: Vec<&syn::Path> = self
.subscribe
.iter()
.chain(self.upstreams.iter().flat_map(Upstreams::upstreams))
.collect();
if upstreams.is_empty() {
return None;
}
let transformer = self.framework(&["transform"], "Transformer");
Some(quote! {
const _: () = {
fn __ig_subscribes_to<__INGRAPH_UPSTREAM__: #transformer>() {}
#(const _: fn() = __ig_subscribes_to::<#upstreams>;)*
};
})
}
fn lineage_kinds(
&self,
name: &syn::Ident,
kinds: &[Kind],
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let record = &self.record;
let vis = &self.vis;
let injected = fanned_lineage(&self.prefix);
let transformer = self.framework(&["transform"], "Transformer");
let doc = leading(&format!(
"Which upstream a [`{record}`] row descends from, and that message's own address."
));
let variants = kinds.iter().map(|kind| {
let (variant, node) = (&kind.variant, &kind.node);
let doc = leading(&format!("Descended from a `{variant}` message."));
quote! {
#[doc = #doc]
#variant(<#node as #transformer>::Key),
}
});
let declaration = quote! {
#[doc = #doc]
#[derive(
::core::fmt::Debug,
::core::clone::Clone,
::core::cmp::PartialEq,
::core::cmp::Eq,
::core::hash::Hash
)]
#vis enum #name {
#(#variants)*
}
};
let conversions = quote! {
#[automatically_derived]
impl ::core::convert::From<#record> for #name {
#[inline]
fn from(record: #record) -> Self {
record.#injected
}
}
#[automatically_derived]
impl<'a> ::core::convert::From<&'a #record> for #name {
#[inline]
fn from(record: &'a #record) -> Self {
::core::clone::Clone::clone(&record.#injected)
}
}
};
(declaration, conversions)
}
fn key_parent(&self) -> Option<proc_macro2::TokenStream> {
let fusion = self.upstreams.as_ref()?.fused()?;
let lineage = &self.lineage.as_ref()?.name;
let parent = &fusion.parent;
let transformer = self.framework(&["transform"], "Transformer");
let mirrors = fusion.mirrors.iter().map(|mirror| {
let (column, from) = (&mirror.column, &mirror.from);
let read = quote_spanned!(from.span() => __ingraph_key.#from);
quote!(#column: #read,)
});
Some(quote! {
const _: fn(<#parent as #transformer>::Key) -> #lineage = |__ingraph_key| #lineage {
#(#mirrors)*
};
})
}
fn root_projection(&self) -> proc_macro2::TokenStream {
let record = &self.record;
let root = self
.key
.columns()
.next()
.expect("a key always has its id, so it always has a first column");
let ty = &root.ty;
let family = family(ty);
let attributes = self.framework(&["drive"], "Attributes");
let projection = self.framework(&["drive"], "RootProjection");
let node_name = self.framework(&["drive"], "NodeName");
let arrival = self.framework(&["drive"], "Arrival");
let binding = format_ident!("record");
let source = &root.source;
let read = if self.remote.is_some() {
self.remote_read(&binding, source)
} else {
quote!(::core::clone::Clone::clone(&record.#source))
};
let doc = leading(&format!(
"Which root key a [`{record}`] descends from — its key's FIRST column, which is the \
`{source}` field. The root-key registry tables one machine per family, and this is what \
tells it which family a record of this type belongs to."
));
let family_doc = leading(
"This root family's own name, read off the root type rather than off a column name so that \
every record sharing a root agrees on it without saying so.",
);
quote! {
#[automatically_derived]
impl #attributes<#record> for #projection<#record> {
#[doc = #family_doc]
const FAMILY: &'static str = #family;
#[doc = #doc]
type Root = #ty;
#[inline]
fn root(&self, record: &#record) -> Self::Root {
#read
}
#[inline]
fn observe(&self, _root: &Self::Root, _worker: &#node_name, _arrival: &#arrival) {}
}
}
}
fn rows(&self) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let mut types = proc_macro2::TokenStream::new();
let mut impls = proc_macro2::TokenStream::new();
for database in self.persist.iter().flat_map(|persist| &persist.backends) {
let (declaration, methods) = database.row(self);
types.extend(declaration);
impls.extend(methods);
let (declaration, methods) = database.comparison(self);
types.extend(declaration);
impls.extend(methods);
impls.extend(database.comparison_traits(self));
impls.extend(database.filter_crossing(self));
impls.extend(database.vocabulary(self));
impls.extend(database.column_fence(self));
}
let (order_type, order_impls) = self.ordering();
types.extend(order_type);
impls.extend(order_impls);
let (query_types, query_impls) = self.query();
types.extend(query_types);
impls.extend(query_impls);
(types, impls)
}
fn methods(&self) -> proc_macro2::TokenStream {
if self.remote.is_some() {
return self.remote_methods();
}
let record = &self.record;
let families = self.fields.iter().map(|field| {
field.column.methods(
&self.vis,
&self.krate,
&format!("`{}` field of this [`{record}`]", field.column.name),
!field.identity,
&field.condition.gate(),
)
});
quote! {
impl #record {
#(#families)*
}
}
}
fn binding(&self) -> proc_macro2::TokenStream {
let record = &self.record;
let key = &self.key.name;
let id = &self.key.id.ty;
let field = &self.key.id.source;
let column = &self.key.id.name;
let lineage = match &self.lineage {
Some(lineage) => {
let name = &lineage.name;
quote!(#name)
}
None => quote!(()),
};
let row = if self.persist.is_some() {
quote!(Self)
} else {
quote!(())
};
let wire = if self.graphql.is_some() {
quote!(Self)
} else {
quote!(())
};
let transformer = self.framework(&["transform"], "Transformer");
let identifiable = self.framework(&["transform"], "Identifiable");
let keyable = self.framework(&["transform"], "ids_are_keys");
let id_read = if self.remote.is_some() {
self.remote_id_ref()
} else {
quote!(&self.#field)
};
quote! {
const _: fn() = #keyable::<#id>;
#[automatically_derived]
impl #identifiable for #record {
type Id = #id;
#[inline]
fn id_ref(&self) -> &#id {
#id_read
}
}
#[automatically_derived]
impl #transformer for #record {
type Key = #key;
type Lineage = #lineage;
type Record = #row;
type Graphql = #wire;
#[inline]
fn key(&self) -> #key {
<#key as ::core::convert::From<&#record>>::from(self)
}
}
#[automatically_derived]
impl #identifiable for #key {
type Id = #id;
#[inline]
fn id_ref(&self) -> &#id {
&self.#column
}
}
}
}
fn wire_binding(&self) -> proc_macro2::TokenStream {
let Some(graphql) = &self.graphql else {
return proc_macro2::TokenStream::new();
};
let record = &self.record;
let input = graphql.input.safe();
let output = graphql.output.safe();
let filter = graphql.filter.safe();
let key_output = graphql.key_output.safe();
let order_by = if self.orderable() {
let name = self.order_by.safe();
quote!(#name)
} else {
quote!(())
};
let queries = match self.wire_query_row() {
Some(_) => {
let name = crate::model::default_queries_name(record);
quote!(#name)
}
None => quote!(()),
};
let face = self.framework(&["transform"], "Graphql");
let input_face = self.framework(&["transform"], "GraphqlInput");
let output_face = self.framework(&["transform"], "GraphqlOutput");
quote! {
#[automatically_derived]
impl #input_face for #input {
type Filter = #filter;
type OrderBy = #order_by;
}
#[automatically_derived]
impl #output_face for #output {
type Key = #key_output;
}
#[automatically_derived]
impl #face for #record {
type Input = #input;
type Output = #output;
type Query = #queries;
}
}
}
fn hydration_binding(&self) -> proc_macro2::TokenStream {
let Some(database) = self.wire_query_row() else {
return proc_macro2::TokenStream::new();
};
let record = &self.record;
let backend = database.backend_type(self);
let hydrates = self.framework(&["transform"], "Hydrates");
let gate = self.framework(&["gate"], &database.kind().gate().to_string());
quote! {
#gate! {
#[automatically_derived]
impl #hydrates for #record {
type Db = #backend;
}
}
}
}
fn address_segments(&self) -> proc_macro2::TokenStream {
let key = &self.key.name;
let key_segments = self.framework(&["store"], "KeySegments");
let segments = self.framework(&["store"], "Segments");
let fanned = self.fanned_lineage_name();
let columns = self.key.columns().map(|column| {
let name = &column.name;
if fanned.is_some_and(|_| name == &fanned_lineage_column()) {
quote!(#key_segments::segments(&self.#name, out);)
} else {
quote!(out.push(&self.#name);)
}
});
let choice = fanned.map(|(name, kinds)| {
let arms = kinds.iter().map(|kind| {
let variant = &kind.variant;
let word = variant.to_string();
quote! {
Self::#variant(__ingraph_key) => {
out.push_word(#word);
#key_segments::segments(__ingraph_key, out);
}
}
});
quote! {
#[automatically_derived]
impl #key_segments for #name {
#[inline]
fn segments(&self, out: &mut #segments) {
match self { #(#arms)* }
}
}
}
});
quote! {
#[automatically_derived]
impl #key_segments for #key {
#[inline]
fn segments(&self, out: &mut #segments) {
#(#columns)*
}
}
#choice
}
}
fn fanned_lineage_name(&self) -> Option<(&syn::Ident, &[Kind])> {
let lineage = self.lineage.as_ref()?;
match &lineage.shape {
Shape::Kinds(kinds) => Some((&lineage.name, kinds)),
Shape::Path(_) => None,
}
}
fn address_type<'a>(
&self,
name: &syn::Ident,
doc: &str,
new_doc: &str,
columns: impl Iterator<Item = &'a Column> + Clone,
id: Option<&Column>,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let vis = &self.vis;
let (names, types): (Vec<&syn::Ident>, Vec<&syn::Type>) = columns
.clone()
.map(|column| (&column.name, &column.ty))
.unzip();
let families = columns.map(|column| {
let subject = if id.is_some_and(|id| core::ptr::eq(id, column)) {
"row\'s own id".to_owned()
} else {
format!("`{}` step of the lineage path", column.name)
};
column.methods(
&self.vis,
&self.krate,
&subject,
true,
&proc_macro2::TokenStream::new(),
)
});
let doc = leading(doc);
let new_doc = leading(new_doc);
let declaration = quote! {
#[doc = #doc]
#[derive(
::core::fmt::Debug,
::core::clone::Clone,
::core::cmp::PartialEq,
::core::cmp::Eq,
::core::hash::Hash
)]
#vis struct #name {
#(pub(crate) #names: #types,)*
}
};
let arity = wide_signature();
let methods = quote! {
impl #name {
#[doc = #new_doc]
#arity
#[inline]
#vis const fn new(#(#names: #types,)*) -> Self {
Self { #(#names,)* }
}
#(#families)*
}
};
(declaration, methods)
}
fn address_conversions<'a>(
&self,
name: &syn::Ident,
columns: impl Iterator<Item = &'a Column> + Clone,
) -> proc_macro2::TokenStream {
let record = &self.record;
let (names, sources): (Vec<&syn::Ident>, Vec<&syn::Ident>) =
columns.map(|column| (&column.name, &column.source)).unzip();
let binding = format_ident!("record");
let (moved, borrowed): (Vec<_>, Vec<_>) = if self.remote.is_some() {
let reads: Vec<proc_macro2::TokenStream> = sources
.iter()
.map(|source| self.remote_read(&binding, source))
.collect();
(reads.clone(), reads)
} else {
(
sources
.iter()
.map(|source| quote!(record.#source))
.collect(),
sources
.iter()
.map(|source| quote!(::core::clone::Clone::clone(&record.#source)))
.collect(),
)
};
quote! {
#[automatically_derived]
impl ::core::convert::From<#record> for #name {
#[inline]
fn from(record: #record) -> Self {
Self { #(#names: #moved,)* }
}
}
#[automatically_derived]
impl<'a> ::core::convert::From<&'a #record> for #name {
#[inline]
fn from(record: &'a #record) -> Self {
Self { #(#names: #borrowed,)* }
}
}
}
}
pub(crate) fn framework(&self, module: &[&str], name: &str) -> proc_macro2::TokenStream {
framework(&self.krate, module, name)
}
pub(crate) fn vendored(&self, krate: &str) -> String {
vendored(&self.krate, krate)
}
}
impl DatabaseBackend {
pub(crate) fn edge_stored(&self, model: &RecordModel, column: &PersistColumn) -> bool {
(self.kind().edge_collections() || column.edge) && model.collects(&column.source)
}
pub(crate) fn stores(&self, source: &syn::Ident) -> Option<&PersistColumn> {
self
.columns()
.iter()
.find(|column| column.source == *source)
}
pub(crate) fn compared(&self, model: &RecordModel) -> Vec<&PersistColumn> {
model
.queried_columns()
.into_iter()
.filter_map(|(_, shared)| self.stores(&shared.source))
.collect()
}
pub(crate) fn mirrors(&self, model: &RecordModel, column: &PersistColumn) -> bool {
self.edge_stored(model, column) && model.sortable(&column.source)
}
pub(crate) fn seeks_by_value(&self, model: &RecordModel, column: &PersistColumn) -> bool {
self.edge_stored(model, column) && model.indexed(&column.source)
}
pub(crate) fn sort_column(&self, model: &RecordModel, column: &PersistColumn) -> String {
crate::alias::sort_column(
self.storage().aliases.prefix_in(&model.prefix),
&self.external(model, column),
)
}
pub(crate) fn aggregates(&self, model: &RecordModel, column: &PersistColumn) -> bool {
self.edge_stored(model, column) && !self.kind().edge_collections()
}
pub(crate) fn extracts(&self) -> bool {
!self.kind().is_sql()
}
pub(crate) fn external(&self, model: &RecordModel, column: &PersistColumn) -> String {
if self.kind().is_sql() || column.source != model.key.id.source {
return column.name.to_string();
}
crate::model::MONGO_ID.to_owned()
}
pub(crate) fn row_field(
&self,
model: &RecordModel,
column: &PersistColumn,
) -> proc_macro2::TokenStream {
let ty = column.ty();
if self.kind().is_sql() && model.collects(&column.source) {
return quote!(::std::vec::Vec<#ty>);
}
quote!(#ty)
}
pub(crate) fn row(
&self,
model: &RecordModel,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
let family = &self.kind().family(model);
let vis = &model.vis;
let record = &model.record;
let name = self.name();
let derives = &family.derives;
let attrs = &family.attrs;
let what = (family.what)(self.kind());
let noun = family.noun;
let fields = self.columns().iter().map(|column| {
let field = column.name.safe();
let ty = self.row_field(model, column);
let naming = match family.mapping {
Mapping::Attribute(attribute) | Mapping::AttributeAndDecode(attribute, _) => {
let attribute = format_ident!("{attribute}");
let external = self.external(model, column);
family.via.as_ref().map_or_else(
|| Some(quote!(#[#attribute(rename = #external)])),
|via| Some(quote!(#[#attribute(rename = #external, with = #via)])),
)
}
Mapping::Decode(_) => None,
};
let gate = model.gate(&column.source);
quote! {
#gate
#naming
#field: #ty,
}
});
let families = self.columns().iter().map(|column| {
let subject = format!("`{}` column", column.name);
let mut shaped = column.as_column();
let held = self.row_field(model, column);
shaped.ty = syn::parse2(held).expect("a field type is a type");
shaped.methods(
&model.vis,
&model.krate,
&subject,
false,
&model.gate(&column.source),
)
});
let withheld: Vec<String> = model
.fields
.iter()
.filter(|field| field.skip.is_some())
.map(|field| format!("`{}`", field.column.source))
.collect();
let narrowed: Vec<String> = self
.storage()
.fills
.iter()
.map(|filled| format!("`{}`", filled.source))
.collect();
let mut omissions = String::new();
if !withheld.is_empty() {
omissions.push_str(&format!(
"\n\n# Omitted\n\nThe declaration wears `skip` for {list}, so no row of this record \
mints a column for {them} — a read fills {them} from `Default::default()`, or from the \
function `skip(default = \"…\")` named.",
list = withheld.join(", "),
them = if withheld.len() == 1 { "it" } else { "them" },
));
}
if !narrowed.is_empty() {
omissions.push_str(&format!(
"\n\n# Narrowed out of this database\n\n{list} {are} {a}columns of this record's other \
databases and not of `{db}`, so this row mints none — a read supplies {them} from the \
function `{db}(skip(default = \"…\"))` named.",
list = narrowed.join(", "),
are = if narrowed.len() == 1 { "is" } else { "are" },
a = if narrowed.len() == 1 { "a " } else { "" },
them = if narrowed.len() == 1 { "it" } else { "them" },
db = self.kind().as_str(),
));
}
let doc = leading(&format!(
"The {what} {noun} a [`{record}`] is stored as.{omissions}"
));
let declaration = quote! {
#[doc = #doc]
#[derive(#derives)]
#attrs
#vis struct #name {
#(#fields)*
}
};
let conversions = self.conversions(model);
let decode = match family.mapping {
Mapping::Attribute(_) => proc_macro2::TokenStream::new(),
Mapping::Decode(emit) | Mapping::AttributeAndDecode(_, emit) => emit(self, model),
};
let equality = self.equality(model);
let methods = quote! {
impl #name {
#(#families)*
}
#conversions
#equality
#decode
};
(declaration, methods)
}
fn equality(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let name = self.name();
let column_eq = model.framework(&["column"], "ColumnEq");
let same = quote!(true);
let comparisons: Vec<proc_macro2::TokenStream> = self
.columns()
.iter()
.map(|column| {
let field = column.name.safe();
let ty = self.row_field(model, column);
let at = column.source.span();
let compared = quote_spanned! {at=>
<#ty as #column_eq>::column_eq(&self.#field, &__ingraph_other.#field)
};
model
.condition(&column.source)
.map_or(compared.clone(), |condition| {
condition.either(&compared, &same)
})
})
.collect();
let body = if comparisons.is_empty() {
same
} else {
quote!(#(#comparisons)&&*)
};
quote! {
#[automatically_derived]
impl ::core::cmp::PartialEq for #name {
#[inline]
fn eq(&self, __ingraph_other: &Self) -> ::core::primitive::bool {
#body
}
}
}
}
fn conversions(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let record = &model.record;
let row = self.name();
let binding = format_ident!("record");
let writes = self.columns().iter().map(|column| {
let field = column.name.safe();
let source = &column.source;
let read = if model.remote.is_some() {
model.remote_read(&binding, source)
} else {
quote!(record.#source)
};
let value = column.from.apply(read, column.stored.is_some());
let gate = model.gate(source);
quote!(#gate #field: #value,)
});
let write = match self.from() {
Conversion::Default => quote!(Self { #(#writes)* }),
declared => declared.apply(quote!(record), false),
};
let write_fallible = self.writes_fallibly();
let write_error = model.error(Crossing::PersistWrite, self.kind());
let to_row = conversion(
quote!(#record),
row,
&format_ident!("record"),
write,
write_fallible.then_some(&write_error),
&format!("Project a [`{record}`] into the row that stores it."),
);
let mut values: Vec<(syn::Ident, proc_macro2::TokenStream)> = self
.columns()
.iter()
.map(|column| {
let field = column.name.safe();
let value = column
.into
.apply(quote!(row.#field), column.stored.is_some());
(column.source.clone(), value)
})
.collect();
values.extend(self.fills(model));
let members = values.iter().map(|(source, value)| {
let gate = model.gate(source);
quote!(#gate #source: #value,)
});
let read = match self.into() {
Conversion::Default if self.carries_every_field(model) => {
if model.remote.is_some() {
model.remote_build(&values)
} else {
quote!(Self { #(#members)* })
}
}
Conversion::Default => return to_row,
declared => declared.apply(quote!(row), false),
};
let read_fallible = self.reads_fallibly(model);
let read_error = model.error(Crossing::PersistRead, self.kind());
let to_record = conversion(
quote!(#row),
record,
&format_ident!("row"),
read,
read_fallible.then_some(&read_error),
&format!("Raise a stored row back into the [`{record}`] it came from."),
);
quote! {
#to_row
#to_record
}
}
pub(crate) fn writes_fallibly(&self) -> bool {
match self.from() {
Conversion::Default => self.columns().iter().any(|column| column.from.fallible()),
container => container.fallible(),
}
}
pub(crate) fn reads_fallibly(&self, model: &RecordModel) -> bool {
match self.into() {
Conversion::Default if self.carries_every_field(model) => {
self.columns().iter().any(|column| column.into.fallible())
|| (model.remote.is_some() && model.construction.fallible)
}
Conversion::Default => false,
container => container.fallible(),
}
}
fn fills(&self, model: &RecordModel) -> Vec<(syn::Ident, proc_macro2::TokenStream)> {
let withheld = model.fields.iter().filter_map(|field| {
let fill = field.skip.as_ref()?;
let source = &field.column.source;
let value = fill.value(&field.column.ty);
Some((source.clone(), value))
});
let narrowed = self.storage().fills.iter().map(|filled| {
let ty = model
.fields
.iter()
.find(|field| field.column.source == filled.source)
.map(|field| &field.column.ty)
.expect("a filled field is one the record declares");
(filled.source.clone(), filled.fill.value(ty))
});
withheld.chain(narrowed).collect()
}
pub(crate) fn carries_every_field(&self, model: &RecordModel) -> bool {
model
.fields
.iter()
.all(|field| field.skip.is_some() || self.supplies(&field.column.source))
}
pub(crate) fn supplies(&self, source: &syn::Ident) -> bool {
self.stores(source).is_some()
|| self
.storage()
.fills
.iter()
.any(|filled| filled.source == *source)
}
pub(crate) fn backend_type(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let (module, name) = self.kind().backend();
model.framework(module, name)
}
fn vocabulary(&self, model: &RecordModel) -> proc_macro2::TokenStream {
let record = &model.record;
let row = self.name();
let comparison = self.comparison_name();
let backend = self.backend_type(model);
let vocabulary = model.framework(&["transform"], "Record");
let gate = model.framework(&["gate"], &self.kind().gate().to_string());
let order_by = model.order_by.safe();
quote! {
#gate! {
#[automatically_derived]
impl #vocabulary<#backend> for #record {
type Row = #row;
type Comparison = #comparison<#backend>;
type OrderBy = #order_by;
}
}
}
}
}
impl PersistColumn {
pub(crate) fn as_column(&self) -> Column {
Column {
name: self.name.safe().clone(),
source: self.source.clone(),
ty: self.ty().clone(),
project: if self.copy {
Projection::Copied
} else {
Projection::Borrowed
},
}
}
}
impl Column {
pub(crate) fn methods(
&self,
vis: &syn::Visibility,
krate: &syn::Path,
subject: &str,
mutable: bool,
gate: &proc_macro2::TokenStream,
) -> proc_macro2::TokenStream {
let Column {
name, ty, project, ..
} = self;
let method::Family {
value,
borrow,
slice,
set,
with,
} = self.family(mutable);
let accessors = match project {
Projection::Repeated => slice.map(|slice| {
let doc = leading(&format!("The {subject}, as a slice."));
let repeated = framework(krate, &["project"], "Repeated");
quote! {
#gate
#[doc = #doc]
#[inline]
#vis fn #slice(&self) -> &[<#ty as #repeated>::Item] {
#repeated::as_slice(&self.#name)
}
}
}),
Projection::Optional => borrow.map(|borrow| {
let doc = leading(&format!("The {subject}, by reference."));
let optional = framework(krate, &["project"], "Optional");
quote! {
#gate
#[doc = #doc]
#[inline]
#vis fn #borrow(&self) -> ::core::option::Option<&<#ty as #optional>::Item> {
#optional::as_option(&self.#name)
}
}
}),
Projection::Borrowed | Projection::Copied => borrow.map(|borrow| {
let doc = leading(&format!("The {subject}, by reference."));
let value = value.map(|value| {
let doc = leading(&format!("The {subject}."));
quote! {
#gate
#[doc = #doc]
#[inline]
#vis const fn #value(&self) -> #ty {
self.#name
}
}
});
quote! {
#value
#gate
#[doc = #doc]
#[inline]
#vis const fn #borrow(&self) -> &#ty {
&self.#name
}
}
}),
};
let constness = project.copies().then(|| quote!(const));
let mutators = set.zip(with).map(|(set, with)| {
let set_doc = leading(&format!("Set the {subject}."));
let with_doc = leading(&format!("The same value with a different `{name}`."));
quote! {
#gate
#[doc = #set_doc]
#[inline]
#vis #constness fn #set(&mut self, value: #ty) -> &mut Self {
self.#name = value;
self
}
#gate
#[doc = #with_doc]
#[must_use]
#[inline]
#vis #constness fn #with(mut self, value: #ty) -> Self {
self.#name = value;
self
}
}
});
quote! {
#accessors
#mutators
}
}
}
impl Conversion {
pub(crate) fn apply(
&self,
value: proc_macro2::TokenStream,
converted: bool,
) -> proc_macro2::TokenStream {
match self {
Conversion::Infallible(path) => quote!(#path(#value)),
Conversion::Fallible(fallible) => {
let path = &fallible.path;
match &fallible.escape {
None => quote!(#path(#value)?),
Some(escape) => quote! {
::core::result::Result::map_err(#path(#value), #escape)?
},
}
}
Conversion::Default if converted => quote!(::core::convert::Into::into(#value)),
Conversion::Default => value,
}
}
}
impl DatabaseKind {
fn family(self, model: &RecordModel) -> Family {
if self.is_sql() {
sql::family()
} else {
mongo::family(model)
}
}
}