use quote::format_ident;
use crate::{
model::{AliasOptions, DatabaseKind, Declared, Label, Marker, Role, boxed_error, stored_type},
prefix::EmissionPrefix,
union::{UnionMember, default_unwrap_error_name},
};
mod binding;
mod contract;
mod cross;
mod equations;
mod face;
mod hydrate;
mod order;
mod page;
mod queries;
mod row;
mod union_face;
mod wire;
#[cfg(test)]
mod tests;
#[derive(Debug, Clone)]
pub struct InterfaceModel {
pub prefix: EmissionPrefix,
pub vis: syn::Visibility,
pub name: syn::Ident,
pub krate: syn::Path,
pub members: Vec<UnionMember>,
pub fields: Vec<InterfaceField>,
pub error: Option<syn::Ident>,
pub computed_error: Option<syn::Path>,
pub persist: Vec<InterfaceDatabase>,
pub errors: Vec<InterfaceError>,
pub operand_errors: Vec<InterfaceError>,
pub plural: Option<String>,
pub connection: Option<String>,
pub edge: Option<String>,
}
#[derive(Debug, Clone)]
pub struct InterfaceDatabase {
pub kind: DatabaseKind,
pub aliases: AliasOptions,
}
#[derive(Debug, Clone)]
pub struct InterfaceError {
pub kind: DatabaseKind,
pub error: syn::Path,
}
#[derive(Debug, Clone)]
pub struct InterfaceField {
pub name: syn::Ident,
pub ty: syn::Type,
pub tier: Tier,
pub marker: Option<Marker>,
pub copy: bool,
pub pins: Vec<Pin>,
pub wire: Option<syn::Type>,
pub operands: Vec<Operand>,
pub members: Vec<MemberColumn>,
}
#[derive(Debug, Clone)]
pub struct Operand {
pub kind: DatabaseKind,
pub convert: syn::Path,
}
#[derive(Debug, Clone)]
pub struct MemberColumn {
pub variant: syn::Ident,
pub column: syn::Ident,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Tier {
Stored,
Computed,
TryComputed,
}
impl Tier {
#[must_use]
pub const fn computed(self) -> bool {
matches!(self, Self::Computed | Self::TryComputed)
}
#[must_use]
pub const fn fallible(self) -> bool {
matches!(self, Self::TryComputed)
}
}
#[derive(Debug, Clone)]
pub struct Pin {
pub kind: DatabaseKind,
pub stored: Option<syn::Type>,
}
impl InterfaceField {
#[must_use]
pub fn pinned(&self, kind: DatabaseKind) -> &syn::Type {
stored_type(
self
.pins
.iter()
.find(|pin| pin.kind == kind)
.and_then(|pin| pin.stored.as_ref()),
&self.ty,
)
}
#[must_use]
fn declares(&self, kind: DatabaseKind) -> bool {
self
.pins
.iter()
.any(|pin| pin.kind == kind && pin.stored.is_some())
}
#[must_use]
pub fn collects(&self) -> bool {
self.collection().is_some()
}
#[must_use]
pub fn collection(&self) -> Option<Label> {
match &self.marker {
Some(Marker::Framework(marker)) if marker.label.collection() => Some(marker.label),
_ => None,
}
}
#[must_use]
pub fn operand(&self, kind: DatabaseKind) -> Option<&syn::Path> {
self
.operands
.iter()
.find(|operand| operand.kind == kind)
.map(|operand| &operand.convert)
}
#[must_use]
pub fn column(&self, variant: &syn::Ident) -> &syn::Ident {
use syn::ext::IdentExt as _;
self
.members
.iter()
.find(|member| member.variant.unraw() == variant.unraw())
.map_or(&self.name, |member| &member.column)
}
}
impl InterfaceModel {
#[must_use]
pub fn error(&self) -> syn::Ident {
self
.error
.clone()
.unwrap_or_else(|| default_unwrap_error_name(&self.name))
}
#[must_use]
pub fn fields_name(&self) -> syn::Ident {
default_fields_name(&self.name)
}
#[must_use]
pub fn derivations_name(&self) -> syn::Ident {
default_derivations_name(&self.name)
}
#[must_use]
pub fn hydration_error(&self, kind: DatabaseKind) -> proc_macro2::TokenStream {
match self.errors.iter().find(|cell| cell.kind == kind) {
Some(cell) => {
let path = &cell.error;
quote::quote!(#path)
}
None => boxed_error(),
}
}
#[must_use]
pub fn operand_error(&self, kind: DatabaseKind) -> proc_macro2::TokenStream {
match self.operand_errors.iter().find(|cell| cell.kind == kind) {
Some(cell) => {
let path = &cell.error;
quote::quote!(#path)
}
None => boxed_error(),
}
}
#[must_use]
pub fn computed_error(&self) -> proc_macro2::TokenStream {
match &self.computed_error {
Some(path) => quote::quote!(#path),
None => boxed_error(),
}
}
pub fn stored(&self) -> impl Iterator<Item = &InterfaceField> + Clone {
self
.fields
.iter()
.filter(|field| field.tier == Tier::Stored)
}
pub fn computed(&self) -> impl Iterator<Item = &InterfaceField> + Clone {
self.fields.iter().filter(|field| field.tier.computed())
}
pub fn projected(&self) -> impl Iterator<Item = &InterfaceField> + Clone {
self.stored().filter(|field| !field.collects())
}
pub fn collected(&self) -> impl Iterator<Item = &InterfaceField> + Clone {
self.stored().filter(|field| field.collects())
}
#[must_use]
pub fn stored_at(&self, field: &InterfaceField, kind: DatabaseKind) -> proc_macro2::TokenStream {
let held = field.pinned(kind);
if !field.collects() || field.declares(kind) {
return quote::quote!(#held);
}
let state = self.framework(&["state"], "State");
let extracted = self.framework(&["state"], "Extracted");
let inner = self.framework(&["state"], "Inner");
quote::quote!(<#held as #state<#extracted<#inner>>>::Output)
}
#[must_use]
pub fn row_at(&self, field: &InterfaceField, kind: DatabaseKind) -> proc_macro2::TokenStream {
let held = self.stored_at(field, kind);
if field.collects() {
return quote::quote!(::std::vec::Vec<#held>);
}
held
}
#[must_use]
pub fn databases(&self) -> Vec<DatabaseKind> {
DatabaseKind::ALL
.into_iter()
.filter(|kind| {
self.persist.iter().any(|database| database.kind == *kind)
|| self
.fields
.iter()
.any(|field| field.pins.iter().any(|pin| pin.kind == *kind))
})
.collect()
}
fn alias_prefix(&self, kind: DatabaseKind) -> &str {
self
.persist
.iter()
.find(|database| database.kind == kind)
.map_or(self.prefix.mark(), |database| {
database.aliases.prefix_in(&self.prefix)
})
}
#[must_use]
pub fn kind_word(&self, kind: DatabaseKind) -> String {
format!("{}_kind__", self.alias_prefix(kind))
}
#[must_use]
pub fn source_word(&self, kind: DatabaseKind) -> String {
format!("{}_union__", self.alias_prefix(kind))
}
#[must_use]
pub fn mints_the_default_words(&self, kind: DatabaseKind) -> bool {
self.alias_prefix(kind) == crate::alias::ALIAS_PREFIX
}
#[must_use]
pub fn emitted_types(&self) -> Vec<Declared> {
let declared = |name: syn::Ident, role: Role| Declared { name, role };
let mut emitted = vec![
declared(self.error(), Role::UnwrapError),
declared(self.fields_name(), Role::Fields),
declared(self.derivations_name(), Role::Derivations),
];
if self.projects() {
emitted.push(declared(default_kind_name(&self.name), Role::Kind));
emitted.push(declared(default_id_name(&self.name), Role::Id));
emitted.push(declared(default_key_name(&self.name), Role::Key));
emitted.extend(
self
.sql_databases()
.into_iter()
.map(|kind| declared(default_row_name(&self.name, kind), Role::Row(kind))),
);
emitted.extend(self.sql_databases().into_iter().flat_map(|kind| {
[
declared(self.cursor_name(kind), Role::Cursor(kind)),
declared(self.comparison_name(kind), Role::Comparison(kind)),
]
}));
emitted.push(declared(default_order_by_name(&self.name), Role::OrderBy));
emitted.push(declared(default_filter_name(&self.name), Role::Filter));
emitted.push(declared(default_input_name(&self.name), Role::Input));
}
emitted.push(declared(default_output_name(&self.name), Role::Output));
if self.wire_query_database().is_some() {
emitted.push(declared(
crate::model::default_queries_name(&self.name),
Role::Queries,
));
}
emitted
}
#[must_use]
pub fn emit(&self) -> proc_macro2::TokenStream {
let face = self.union_face();
let contract = self.contract();
let equations = self.equations();
let projection = self.projection();
let page = self.page();
let ordering = self.ordering();
let wire = self.wire();
let output = self.output();
let sdl_face = self.sdl_face();
let queries = self.queries();
let bindings = self.bindings();
quote::quote! {
#face
#contract
#equations
#projection
#page
#ordering
#wire
#output
#sdl_face
#queries
#bindings
}
}
pub(crate) fn framework(&self, module: &[&str], name: &str) -> proc_macro2::TokenStream {
let krate = &self.krate;
let module = module.iter().map(|segment| format_ident!("{segment}"));
let name = format_ident!("{name}");
quote::quote!(#krate::__private #(:: #module)* :: #name)
}
}
#[must_use]
pub fn default_fields_name(interface: &syn::Ident) -> syn::Ident {
format_ident!("{interface}Fields")
}
#[must_use]
pub fn default_derivations_name(interface: &syn::Ident) -> syn::Ident {
format_ident!("{interface}Derivations")
}
#[must_use]
pub fn default_kind_name(interface: &syn::Ident) -> syn::Ident {
format_ident!("{interface}Kind")
}
#[must_use]
pub fn default_id_name(interface: &syn::Ident) -> syn::Ident {
format_ident!("{interface}Id")
}
#[must_use]
pub fn default_row_name(interface: &syn::Ident, kind: DatabaseKind) -> syn::Ident {
format_ident!("{interface}{}Row", kind.suffix())
}
#[must_use]
pub fn default_key_name(interface: &syn::Ident) -> syn::Ident {
crate::model::default_key_name(interface)
}
#[must_use]
pub fn default_filter_name(interface: &syn::Ident) -> syn::Ident {
crate::model::default_filter_name(interface)
}
#[must_use]
pub fn default_order_by_name(interface: &syn::Ident) -> syn::Ident {
crate::model::default_order_by_name(interface)
}
#[must_use]
pub fn default_input_name(interface: &syn::Ident) -> syn::Ident {
crate::model::default_input_name(interface)
}
#[must_use]
pub fn default_output_name(interface: &syn::Ident) -> syn::Ident {
crate::model::default_output_name(interface)
}