use core::fmt;
use quote::format_ident;
use crate::model::{Column, DatabaseKind, Projection, RecordModel};
#[cfg(test)]
mod prefix_tests;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Member {
Value,
Borrow,
Slice,
Set,
With,
}
impl Member {
pub fn name(self, column: &syn::Ident) -> syn::Ident {
match self {
Self::Value => column.clone(),
Self::Borrow => format_ident!("{column}_ref"),
Self::Slice => format_ident!("{column}_slice"),
Self::Set => format_ident!("set_{column}"),
Self::With => format_ident!("with_{column}"),
}
}
pub const fn what(self) -> &'static str {
match self {
Self::Value => "value accessor",
Self::Borrow => "borrow accessor",
Self::Slice => "slice accessor",
Self::Set => "setter",
Self::With => "builder",
}
}
}
pub fn wire_method(name: &syn::Ident) -> syn::Ident {
format_ident!("__async_graphql_{name}")
}
pub fn fan_door(field: &syn::Ident) -> syn::Ident {
format_ident!("fan_{field}")
}
pub fn fold_accessor(field: &syn::Ident) -> syn::Ident {
format_ident!("fold_by_{field}")
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Door {
Keys,
Whole,
Own,
Similar,
Set,
SimilarSet,
Fused,
FusedSimilar,
FusedLegs,
FusedLegsSimilar,
}
impl Door {
pub fn name(self, election: &syn::Ident) -> syn::Ident {
match self {
Self::Keys => format_ident!("retrieve_keys_by_{election}"),
Self::Whole => format_ident!("retrieve_by_{election}"),
Self::Own => format_ident!("get_{election}"),
Self::Similar => format_ident!("retrieve_similar_by_{election}"),
Self::Set => format_ident!("{}_with", Self::Keys.name(election)),
Self::SimilarSet => format_ident!("{}_with", Self::Similar.name(election)),
Self::Fused => format_ident!("vector_fuse"),
Self::FusedSimilar => format_ident!("vector_fuse_similar"),
Self::FusedLegs => format_ident!("vector_fuse_by_{election}"),
Self::FusedLegsSimilar => format_ident!("vector_fuse_similar_by_{election}"),
}
}
pub fn pair(election: Option<&syn::Ident>) -> (syn::Ident, syn::Ident) {
match election {
Some(field) => (Self::Keys.name(field), Self::Whole.name(field)),
None => (format_ident!("retrieve_keys"), format_ident!("retrieve")),
}
}
const fn what(self) -> &'static str {
match self {
Self::Keys => "ranked-keys door",
Self::Whole => "whole-entities door",
Self::Own => "by-key read",
Self::Similar => "by-example door",
Self::Set => "set-similarity door",
Self::SimilarSet => "set-similarity by-example door",
Self::Fused => "fused door",
Self::FusedSimilar => "fused by-example door",
Self::FusedLegs => "fanned-slot fused door",
Self::FusedLegsSimilar => "fanned-slot fused by-example door",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DoorOrigin {
pub door: Door,
pub election: Option<syn::Ident>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ColumnOrigin {
pub column: syn::Ident,
pub member: Member,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Origin {
Constructor,
BorrowedKey,
Column(ColumnOrigin),
Fuse(FuseOrigin),
Resolver(DatabaseKind),
Direction,
Lowering(DatabaseKind),
Identity,
Term(DatabaseKind),
Complete,
Finder(DatabaseKind),
Snapshot(DatabaseKind),
Getter(DatabaseKind),
Inserter(DatabaseKind),
Upserter(DatabaseKind),
Deleter(DatabaseKind),
Purger(DatabaseKind),
Address,
Argument,
RootField,
Fan(syn::Ident),
Fold(syn::Ident),
Door(DoorOrigin),
Delegate(syn::Ident),
Roster,
Materialization,
Predicate(syn::Ident),
Extraction,
}
impl Origin {
pub const fn column(&self) -> Option<&syn::Ident> {
match self {
Self::Column(origin) => Some(&origin.column),
Self::Delegate(method) => Some(method),
Self::Constructor
| Self::BorrowedKey
| Self::Resolver(_)
| Self::Direction
| Self::Lowering(_)
| Self::Identity
| Self::Term(_)
| Self::Complete
| Self::Finder(_)
| Self::Snapshot(_)
| Self::Getter(_)
| Self::Inserter(_)
| Self::Upserter(_)
| Self::Deleter(_)
| Self::Purger(_)
| Self::Address
| Self::Argument
| Self::RootField
| Self::Fan(_)
| Self::Fold(_)
| Self::Door(_)
| Self::Extraction
| Self::Roster
| Self::Materialization
| Self::Predicate(_)
| Self::Fuse(_) => None,
}
}
}
impl fmt::Display for Origin {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Constructor => f.write_str("the type's own constructor"),
Self::BorrowedKey => f.write_str("the borrow of the upstream key it carries"),
Self::Column(origin) => write!(
f,
"the `{}` column's {}",
origin.column,
origin.member.what()
),
Self::Resolver(kind) => write!(f, "the `{}` order-by resolver", kind.as_str()),
Self::Direction => f.write_str("the order-by's direction accessor"),
Self::Lowering(kind) => write!(f, "the `{}` ordering lowering", kind.as_str()),
Self::Identity => f.write_str("the order-by's identity accessor"),
Self::Term(kind) => write!(f, "the `{}` ordering term", kind.as_str()),
Self::Complete => f.write_str("the order-by's id tail"),
Self::Finder(kind) => write!(f, "the `{}` plural query", kind.as_str()),
Self::Snapshot(kind) => write!(
f,
"the `{}` plural query in a read transaction",
kind.as_str()
),
Self::Getter(kind) => write!(f, "the `{}` single query", kind.as_str()),
Self::Inserter(kind) => write!(f, "the `{}` insert", kind.as_str()),
Self::Upserter(kind) => write!(f, "the `{}` keyed replace", kind.as_str()),
Self::Deleter(kind) => write!(f, "the `{}` removal at an address", kind.as_str()),
Self::Purger(kind) => write!(f, "the `{}` removal over a predicate", kind.as_str()),
Self::Address => f.write_str("the output object's own address member"),
Self::Argument => f.write_str("the argument object's own member"),
Self::RootField => f.write_str("the query unit's own root field"),
Self::Fan(field) => write!(f, "the `{field}` field's fan door"),
Self::Fold(field) => write!(f, "the `{field}` election's declared fold"),
Self::Door(origin) => match &origin.election {
Some(field) => write!(f, "the `{field}` election's {}", origin.door.what()),
None => write!(f, "the {}", origin.door.what()),
},
Self::Delegate(method) => write!(f, "the delegated `{method}`"),
Self::Roster => f.write_str("the mirror's own restated-variant roster"),
Self::Materialization => f.write_str("the mirror's own upstream materialization"),
Self::Predicate(variant) => write!(f, "the `{variant}` variant's predicate"),
Self::Extraction => f.write_str("the document's own extraction"),
Self::Fuse(origin) => write!(
f,
"the fuse family's `{}` on `{}`",
origin.member, origin.on
),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FuseOrigin {
pub on: syn::Ident,
pub member: syn::Ident,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Owner {
Key,
Lineage,
Record,
Row(DatabaseKind),
Comparison(DatabaseKind),
Input,
Fuse,
Output,
KeyOutput,
Queries,
Filter,
OrderBy,
}
#[derive(Debug, Clone)]
pub struct Emitted {
pub owner: Owner,
pub owner_name: syn::Ident,
pub name: syn::Ident,
pub origin: Origin,
}
pub(crate) struct Family {
pub(crate) value: Option<syn::Ident>,
pub(crate) borrow: Option<syn::Ident>,
pub(crate) slice: Option<syn::Ident>,
pub(crate) set: Option<syn::Ident>,
pub(crate) with: Option<syn::Ident>,
}
impl Family {
pub(crate) fn members(self) -> impl Iterator<Item = (Member, syn::Ident)> {
[
(Member::Value, self.value),
(Member::Borrow, self.borrow),
(Member::Slice, self.slice),
(Member::Set, self.set),
(Member::With, self.with),
]
.into_iter()
.filter_map(|(member, name)| name.map(|name| (member, name)))
}
}
impl Column {
pub(crate) fn family(&self, mutable: bool) -> Family {
let name = &self.name;
let repeated = matches!(self.project, Projection::Repeated);
Family {
value: self.project.copies().then(|| Member::Value.name(name)),
borrow: (!repeated).then(|| Member::Borrow.name(name)),
slice: repeated.then(|| Member::Slice.name(name)),
set: mutable.then(|| Member::Set.name(name)),
with: mutable.then(|| Member::With.name(name)),
}
}
pub(crate) fn emitted(
&self,
owner: Owner,
owner_name: &syn::Ident,
mutable: bool,
) -> Vec<Emitted> {
self
.family(mutable)
.members()
.map(|(member, name)| Emitted {
owner,
owner_name: owner_name.clone(),
name,
origin: Origin::Column(ColumnOrigin {
column: self.name.clone(),
member,
}),
})
.collect()
}
}
impl DatabaseKind {
pub(crate) fn order_resolver(self) -> syn::Ident {
format_ident!("{}_column", self.as_str())
}
pub(crate) fn order_lowering(self) -> syn::Ident {
format_ident!("{}_order_by", self.as_str())
}
pub(crate) fn order_term(self) -> syn::Ident {
format_ident!("{}_term", self.as_str())
}
pub(crate) fn finder(self) -> syn::Ident {
format_ident!("find_{}", self.as_str())
}
pub(crate) fn snapshot_finder(self) -> syn::Ident {
format_ident!("find_{}_snapshot", self.as_str())
}
pub(crate) fn getter(self) -> syn::Ident {
format_ident!("get_{}", self.as_str())
}
pub(crate) fn inserter(self) -> syn::Ident {
format_ident!("insert_{}", self.as_str())
}
pub(crate) fn upserter(self) -> syn::Ident {
format_ident!("upsert_{}", self.as_str())
}
pub(crate) fn deleter(self) -> syn::Ident {
format_ident!("delete_{}", self.as_str())
}
pub(crate) fn purger(self) -> syn::Ident {
format_ident!("{}_where", self.deleter())
}
pub(crate) fn gate(self) -> syn::Ident {
format_ident!("if_{}", self.as_str())
}
}
impl RecordModel {
pub fn emitted_methods(&self) -> Vec<Emitted> {
let constructor = |owner: Owner, owner_name: &syn::Ident| Emitted {
owner,
owner_name: owner_name.clone(),
name: format_ident!("new"),
origin: Origin::Constructor,
};
let mut emitted = vec![constructor(Owner::Key, &self.key.name)];
emitted.extend(
self
.key
.columns()
.flat_map(|column| column.emitted(Owner::Key, &self.key.name, true)),
);
if let Some(lineage) = self
.lineage
.as_ref()
.filter(|lineage| !lineage.path().is_empty())
{
emitted.push(constructor(Owner::Lineage, &lineage.name));
emitted.extend(
lineage
.path()
.iter()
.flat_map(|column| column.emitted(Owner::Lineage, &lineage.name, true)),
);
}
emitted.extend(self.fields.iter().flat_map(|field| {
if self.remote.is_some() {
return crate::remote::wrapped_family(field)
.members()
.map(|(member, name)| Emitted {
owner: Owner::Record,
owner_name: self.record.clone(),
name,
origin: Origin::Column(ColumnOrigin {
column: field.column.name.clone(),
member,
}),
})
.collect::<Vec<_>>();
}
field
.column
.emitted(Owner::Record, &self.record, !field.identity)
}));
for database in self.persist.iter().flat_map(|persist| &persist.backends) {
let kind = database.kind();
let row = database.name();
emitted.extend(
database
.columns()
.iter()
.flat_map(|column| column.as_column().emitted(Owner::Row(kind), row, false)),
);
if database.extracts() {
emitted.push(Emitted {
owner: Owner::Row(kind),
owner_name: row.clone(),
name: format_ident!("from_document"),
origin: Origin::Extraction,
});
}
let comparison = database.comparison_name();
emitted.push(constructor(Owner::Comparison(kind), comparison));
emitted.extend(database.compared(self).into_iter().map(|column| {
let column = column.member().clone();
Emitted {
owner: Owner::Comparison(kind),
owner_name: comparison.clone(),
name: Member::Borrow.name(&column),
origin: Origin::Column(ColumnOrigin {
column,
member: Member::Borrow,
}),
}
}));
}
emitted.extend(self.order_by_methods());
emitted.extend(self.wire_methods());
emitted.extend(self.queryable().into_iter().flat_map(|database| {
let kind = database.kind();
[
(kind.finder(), Origin::Finder(kind)),
(kind.snapshot_finder(), Origin::Snapshot(kind)),
(kind.getter(), Origin::Getter(kind)),
(kind.inserter(), Origin::Inserter(kind)),
(kind.upserter(), Origin::Upserter(kind)),
(kind.deleter(), Origin::Deleter(kind)),
(kind.purger(), Origin::Purger(kind)),
]
.map(|(name, origin)| Emitted {
owner: Owner::Record,
owner_name: self.record.clone(),
name,
origin,
})
}));
emitted
}
fn order_by_methods(&self) -> Vec<Emitted> {
let mut emitted = Vec::new();
if self.persist.is_none() {
return emitted;
}
let order_by = self.order_by.safe();
emitted.extend(
self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.map(|database| Emitted {
owner: Owner::OrderBy,
owner_name: order_by.clone(),
name: database.kind().order_resolver(),
origin: Origin::Resolver(database.kind()),
}),
);
emitted.push(Emitted {
owner: Owner::OrderBy,
owner_name: order_by.clone(),
name: format_ident!("direction"),
origin: Origin::Direction,
});
let paged = self.id_column_stored().is_some()
&& self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.any(|database| database.kind().is_sql());
if paged {
emitted.push(Emitted {
owner: Owner::OrderBy,
owner_name: order_by.clone(),
name: format_ident!("identity"),
origin: Origin::Identity,
});
emitted.extend(
self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.filter(|database| database.kind().is_sql())
.map(|database| Emitted {
owner: Owner::OrderBy,
owner_name: order_by.clone(),
name: database.kind().order_term(),
origin: Origin::Term(database.kind()),
}),
);
emitted.push(Emitted {
owner: Owner::OrderBy,
owner_name: order_by.clone(),
name: format_ident!("complete"),
origin: Origin::Complete,
});
}
if self.id_column_stored().is_some() {
emitted.extend(
self
.persist
.iter()
.flat_map(|persist| &persist.backends)
.filter(|database| database.kind().is_sql())
.map(|database| Emitted {
owner: Owner::OrderBy,
owner_name: order_by.clone(),
name: database.kind().order_lowering(),
origin: Origin::Lowering(database.kind()),
}),
);
}
emitted
}
fn wire_methods(&self) -> Vec<Emitted> {
let mut emitted = Vec::new();
let Some(graphql) = &self.graphql else {
return emitted;
};
let Some(backend) = graphql.backends.first() else {
return emitted;
};
let output = graphql.output.safe();
let address: &[&str] = if self.wire_writes_id() {
&["id", "key"]
} else {
&["key"]
};
emitted.extend(address.iter().map(|member| Emitted {
owner: Owner::Output,
owner_name: output.clone(),
name: Member::Borrow.name(&format_ident!("{member}")),
origin: Origin::Address,
}));
emitted.extend(backend.fields().iter().map(|field| {
let column = field.accessor().clone();
Emitted {
owner: Owner::Output,
owner_name: output.clone(),
name: Member::Borrow.name(&column),
origin: Origin::Column(ColumnOrigin {
column,
member: Member::Borrow,
}),
}
}));
let input = graphql.input.safe();
let argument = |name: &syn::Ident, member: Member| Emitted {
owner: Owner::Input,
owner_name: input.clone(),
name: member.name(name),
origin: Origin::Argument,
};
let paged: &[&str] = if self.orderable() {
let order = format_ident!("order");
emitted.extend([
argument(&order, Member::With),
argument(&order, Member::Slice),
]);
&["first", "last", "after", "before", "skip"]
} else {
&[]
};
for name in ["filter", "limit"].iter().chain(paged) {
let name = format_ident!("{name}");
emitted.extend([
argument(&name, Member::With),
argument(&name, Member::Borrow),
]);
}
let filter = graphql.filter.safe();
for column in self.stored_columns() {
let (rust, _, _) = backend.filter_field(column);
emitted.extend([Member::With, Member::Borrow].map(|member| Emitted {
owner: Owner::Filter,
owner_name: filter.clone(),
name: member.name(&rust),
origin: Origin::Column(ColumnOrigin {
column: rust.clone(),
member,
}),
}));
}
let key_output = graphql.key_output.safe();
emitted.extend(
self
.key
.columns()
.flat_map(|column| column.emitted(Owner::KeyOutput, key_output, false)),
);
emitted.extend(address.iter().map(|member| Emitted {
owner: Owner::Output,
owner_name: output.clone(),
name: wire_method(&format_ident!("{member}")),
origin: Origin::Address,
}));
emitted.extend(backend.fields().iter().map(|field| {
let column = field.source.clone();
Emitted {
owner: Owner::Output,
owner_name: output.clone(),
name: wire_method(&column),
origin: Origin::Column(ColumnOrigin {
column,
member: Member::Value,
}),
}
}));
emitted.extend(self.key.columns().map(|column| Emitted {
owner: Owner::KeyOutput,
owner_name: key_output.clone(),
name: wire_method(&column.name),
origin: Origin::Column(ColumnOrigin {
column: column.name.clone(),
member: Member::Value,
}),
}));
emitted.extend(self.root_field_methods());
emitted
}
fn root_field_methods(&self) -> Vec<Emitted> {
use heck::ToSnakeCase as _;
if self.wire_query_row().is_none() {
return Vec::new();
}
let owner_name = crate::model::default_queries_name(&self.record);
let snake = self.record.to_string().to_snake_case();
let mut emitted = vec![Emitted {
owner: Owner::Queries,
owner_name: owner_name.clone(),
name: wire_method(&format_ident!("{snake}")),
origin: Origin::RootField,
}];
if self.orderable() && !self.ordered_columns().is_empty() {
emitted.push(Emitted {
owner: Owner::Queries,
owner_name,
name: wire_method(&format_ident!("{snake}_list")),
origin: Origin::RootField,
});
}
emitted
}
}