use std::collections::BTreeMap;
use proc_macro2::{Ident, Span, TokenStream};
use quote::{format_ident, quote};
use ruprizzle_core::ir::{
EnumDef, Field, FieldKind, Model, Provider, RelationKind, ResolvedRelation, ScalarType, Schema,
};
use ruprizzle_parser::naming;
pub fn generate_all(schema: &Schema) -> BTreeMap<String, String> {
let mut files = BTreeMap::new();
files.insert("_generated.rs".to_owned(), generated_rs(schema));
files.insert("enums.rs".to_owned(), enums_rs(schema));
files.insert("mod.rs".to_owned(), mod_rs(schema));
for model in schema.models.values() {
let path = format!("{}.rs", safe_module_name(model.name.as_str()));
files.insert(path, model_rs(schema, model));
}
files
}
pub fn format(tokens: TokenStream) -> String {
let file = syn::parse2::<syn::File>(tokens).expect("generated tokens must be valid Rust");
prettyplease::unparse(&file)
}
fn header() -> TokenStream {
quote! {
#![allow(clippy::all, clippy::pedantic, unused_imports)]
}
}
fn generated_rs(schema: &Schema) -> String {
let hash = schema.fingerprint();
let version = env!("CARGO_PKG_VERSION");
let header = header();
let tokens = quote! {
#header
pub const SCHEMA_HASH: &str = #hash;
pub const RUPRIZZLE_VERSION: &str = #version;
};
format(tokens)
}
fn enums_rs(schema: &Schema) -> String {
let is_postgres = matches!(schema.datasource.provider, Provider::Postgres);
let enum_items: Vec<_> = schema
.enums
.values()
.map(|e| emit_enum(e, is_postgres))
.collect();
let header = header();
let tokens = quote! {
#header
use ::ruprizzle::serde::{Deserialize, Serialize};
use ::ruprizzle::sqlx::Type;
use ::ruprizzle::Value;
#( #enum_items )*
};
format(tokens)
}
fn emit_enum(e: &EnumDef, is_postgres: bool) -> TokenStream {
let name = format_ident!("{}", e.name.as_str());
let docs = doc_attrs(e.docs.as_deref());
let type_name = &e.db_name;
let variants: Vec<_> = e
.variants
.values()
.map(|v| {
let var = format_ident!("{}", pascal(&v.name));
let docs = doc_attrs(v.docs.as_deref());
quote! {
#docs
#var,
}
})
.collect();
let all_variants: Vec<_> = e
.variants
.values()
.map(|v| {
let var = format_ident!("{}", pascal(&v.name));
quote! { #name::#var }
})
.collect();
let as_db_arms: Vec<_> = e
.variants
.values()
.map(|v| {
let var = format_ident!("{}", pascal(&v.name));
let db = &v.db_name;
quote! { Self::#var => #db, }
})
.collect();
let from_db_arms: Vec<_> = e
.variants
.values()
.map(|v| {
let var = format_ident!("{}", pascal(&v.name));
let db = &v.db_name;
quote! { #db => Some(Self::#var), }
})
.collect();
let sqlx_attrs = if is_postgres {
quote! { #[sqlx(type_name = #type_name, rename_all = "SCREAMING_SNAKE_CASE")] }
} else {
quote! { #[sqlx(rename_all = "SCREAMING_SNAKE_CASE")] }
};
quote! {
#docs
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Type, Serialize, Deserialize)]
#sqlx_attrs
#[serde(crate = "::ruprizzle::serde")]
pub enum #name {
#( #variants )*
}
impl #name {
pub const ALL: &'static [#name] = &[ #( #all_variants ),* ];
#[must_use]
pub const fn as_db_str(&self) -> &'static str {
match self {
#( #as_db_arms )*
}
}
#[must_use]
pub fn from_db_str(s: &str) -> Option<Self> {
match s {
#( #from_db_arms )*
_ => None,
}
}
}
impl std::fmt::Display for #name {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_db_str())
}
}
impl std::str::FromStr for #name {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::from_db_str(s).ok_or_else(|| format!("unknown {0}: {1}", stringify!(#name), s))
}
}
impl ::ruprizzle::Encodable for #name {
fn to_value(&self) -> Value {
Value::Str(self.as_db_str().into())
}
}
#[cfg(feature = "sqlite-rusqlite")]
impl ::ruprizzle::rusqlite::FromValue for #name {
fn from_value(value: &::ruprizzle::rusqlite::types::Value) -> Result<Self, ::ruprizzle::Error> {
let s = <String as ::ruprizzle::rusqlite::FromValue>::from_value(value)?;
s.parse().map_err(|e: String| {
::ruprizzle::Error::Message(format!(
"cannot parse {} from {s:?}: {e}",
stringify!(#name)
))
})
}
}
}
}
fn mod_rs(schema: &Schema) -> String {
let mods: Vec<_> = schema
.models
.values()
.map(|m| {
let module = format_ident!("{}", safe_module_name(m.name.as_str()));
quote! { pub mod #module; }
})
.collect();
let uses: Vec<_> = schema
.models
.values()
.map(|m| {
let module = format_ident!("{}", safe_module_name(m.name.as_str()));
let model = format_ident!("{}", m.name.as_str());
let insert = format_ident!("{}Insert", m.name.as_str());
let update = format_ident!("{}Update", m.name.as_str());
let aggregate = format_ident!("{}Aggregate", m.name.as_str());
let aggregate_input = format_ident!("{}AggregateInput", m.name.as_str());
let repo = format_ident!("{}Repo", m.name.as_str());
quote! {
pub use self::#module::{
#aggregate, #aggregate_input, #insert, #model, #repo, #update,
};
}
})
.collect();
let repo_methods: Vec<_> = schema
.models
.values()
.map(|m| {
let method = format_ident!("{}", naming::snake_case(m.name.as_str()));
let repo = format_ident!("{}Repo", m.name.as_str());
quote! {
pub fn #method(&self) -> #repo<'_> {
#repo::new(self)
}
}
})
.collect();
let prelude_uses: Vec<_> = schema
.models
.values()
.map(|m| {
let model = format_ident!("{}", m.name.as_str());
let insert = format_ident!("{}Insert", m.name.as_str());
let update = format_ident!("{}Update", m.name.as_str());
let aggregate = format_ident!("{}Aggregate", m.name.as_str());
let aggregate_input = format_ident!("{}AggregateInput", m.name.as_str());
let repo = format_ident!("{}Repo", m.name.as_str());
let module = format_ident!("{}", safe_module_name(m.name.as_str()));
quote! { #model, #insert, #update, #aggregate, #aggregate_input, #repo, #module, }
})
.collect();
let header = header();
let tokens = quote! {
#header
pub mod _generated;
pub mod enums;
#( #mods )*
pub use _generated::{RUPRIZZLE_VERSION, SCHEMA_HASH};
#( #uses )*
#[derive(Debug, Clone)]
pub struct Db {
pool: ::ruprizzle::Pool,
}
impl Db {
pub async fn connect(url: &str) -> Result<Self, ::ruprizzle::Error> {
let pool = ::ruprizzle::connect(url).await?;
Ok(Self { pool })
}
pub fn from_pool(pool: ::ruprizzle::Pool) -> Self {
Self { pool }
}
pub fn raw_pool(&self) -> &::ruprizzle::Pool {
&self.pool
}
#( #repo_methods )*
pub fn select<M: ::ruprizzle::Model>(&self) -> ::ruprizzle::SelectQuery<'_, M> {
::ruprizzle::SelectQuery::new(self.raw_pool())
}
pub fn insert<M: ::ruprizzle::Model>(&self) -> ::ruprizzle::InsertQuery<'_, M> {
::ruprizzle::InsertQuery::new(self.raw_pool())
}
pub async fn transaction<F, T>(&self, f: F) -> Result<T, ::ruprizzle::Error>
where
F: for<'t> FnOnce(&'t mut ::ruprizzle::Tx)
-> ::ruprizzle::BoxFuture<'t, Result<T, ::ruprizzle::Error>>,
{
let mut tx = ::ruprizzle::Tx::begin(self.raw_pool()).await?;
match f(&mut tx).await {
Ok(v) => {
tx.commit().await?;
Ok(v)
}
Err(e) => {
tx.rollback().await?;
Err(e)
}
}
}
pub async fn transaction_with<F, T>(
&self,
level: ::ruprizzle::IsolationLevel,
f: F,
) -> Result<T, ::ruprizzle::Error>
where
F: for<'t> FnOnce(&'t mut ::ruprizzle::Tx)
-> ::ruprizzle::BoxFuture<'t, Result<T, ::ruprizzle::Error>>,
{
let mut tx =
::ruprizzle::Tx::begin_with_isolation(self.raw_pool(), level).await?;
match f(&mut tx).await {
Ok(v) => {
tx.commit().await?;
Ok(v)
}
Err(e) => {
tx.rollback().await?;
Err(e)
}
}
}
pub async fn transaction_retrying<F, T>(
&self,
attempts: u32,
mut f: F,
) -> Result<T, ::ruprizzle::Error>
where
F: for<'t> FnMut(&'t mut ::ruprizzle::Tx)
-> ::ruprizzle::BoxFuture<'t, Result<T, ::ruprizzle::Error>>,
{
let mut attempt = 0;
loop {
attempt += 1;
let mut tx = ::ruprizzle::Tx::begin(self.raw_pool()).await?;
let result = f(&mut tx).await;
match result {
Ok(v) => {
match tx.commit().await {
Ok(()) => return Ok(v),
Err(e) => {
if attempt >= attempts.max(1)
|| !::ruprizzle::is_retryable(&e)
{
return Err(e);
}
}
}
}
Err(e) => {
tx.rollback().await?;
if attempt >= attempts.max(1) || !::ruprizzle::is_retryable(&e) {
return Err(e);
}
}
}
}
}
}
pub mod prelude {
pub use super::{
Db, RUPRIZZLE_VERSION, SCHEMA_HASH,
#( #prelude_uses )*
};
pub use ::ruprizzle::prelude::*;
}
};
format(tokens)
}
fn model_rs(schema: &Schema, model: &Model) -> String {
let model_name = format_ident!("{}", model.name.as_str());
let insert_name = format_ident!("{}Insert", model.name.as_str());
let update_name = format_ident!("{}Update", model.name.as_str());
let repo_name = format_ident!("{}Repo", model.name.as_str());
let table = &model.table;
let docs = doc_attrs(model.docs.as_deref());
let entity_fields: Vec<_> = model
.fields
.values()
.map(|f| emit_entity_field(schema, model.name.as_str(), f))
.collect();
let insert_fields: Vec<_> = model
.fields
.values()
.filter(|f| f.has_column() && f.generated.is_none())
.map(|f| emit_insert_field(schema, model.name.as_str(), f))
.collect();
let update_fields: Vec<_> = model
.fields
.values()
.filter(|f| f.has_column() && f.generated.is_none())
.map(|f| emit_update_field(schema, model.name.as_str(), f))
.collect();
let column_consts: Vec<_> = model
.fields
.values()
.filter(|f| f.has_column())
.map(|f| emit_column_const(schema, model, f, table))
.collect();
let primary_key = model
.primary_key
.fields
.first()
.and_then(|name| model.fields.get(name))
.map_or_else(|| "id".to_owned(), |f| f.column.clone());
let relation_helpers: Vec<_> = model
.fields
.values()
.filter(|f| f.relation().is_some())
.filter_map(|f| emit_relation_helper(schema, model, f))
.collect();
let relation_filter_helpers: Vec<_> = model
.fields
.values()
.filter(|f| f.relation().is_some())
.filter_map(|f| emit_relation_filter_helpers(schema, model, f))
.collect();
let (tree_module_tokens, tree_repo_tokens) = emit_tree_helpers(model);
let insert_sets: Vec<_> = model
.fields
.values()
.filter(|f| f.has_column() && f.generated.is_none())
.map(|f| emit_insert_set(schema, model, f))
.collect();
let insert_many_fields: Vec<_> = model
.fields
.values()
.filter(|f| f.has_column() && f.generated.is_none())
.map(emit_insert_many_field)
.collect();
let columns: Vec<_> = model
.fields
.values()
.filter(|f| f.has_column())
.map(|f| f.column.as_str())
.collect();
let row_fields = |native_json: bool, native_array: bool, is_join_side: bool| {
let mut next_index = 0;
model
.fields
.values()
.map(|f| {
let idx = if f.has_column() {
let i = next_index;
next_index += 1;
Some(i)
} else {
None
};
let row_expr = quote! { row };
let idx_expr = if let Some(i) = idx {
let idx = syn::Index::from(i);
if is_join_side {
quote! { #idx + __offset }
} else {
quote! { #idx }
}
} else {
quote! { 0 }
};
emit_from_row_field(
schema,
model.name.as_str(),
f,
&row_expr,
&idx_expr,
native_json,
native_array,
)
})
.collect::<Vec<_>>()
};
let any_from_row_fields = row_fields(false, false, false);
let any_join_side_fields = row_fields(false, false, true);
let postgres_from_row_fields = row_fields(true, true, false);
let postgres_join_side_fields = row_fields(true, true, true);
let sqlite_from_row_fields = row_fields(true, false, false);
let sqlite_join_side_fields = row_fields(true, false, true);
let mysql_from_row_fields = row_fields(true, false, false);
let mysql_join_side_fields = row_fields(true, false, true);
let mut next_rusqlite_index = 0;
let rusqlite_from_row_fields: Vec<_> = model
.fields
.values()
.map(|f| {
let idx = if f.has_column() {
let i = next_rusqlite_index;
next_rusqlite_index += 1;
Some(i)
} else {
None
};
emit_from_rusqlite_row_field(schema, model.name.as_str(), f, idx)
})
.collect();
let mut next_owned_index = 0;
let owned_from_row_fields: Vec<_> = model
.fields
.values()
.map(|f| {
let idx = if f.has_column() {
let i = next_owned_index;
next_owned_index += 1;
Some(i)
} else {
None
};
emit_from_owned_row_field(schema, model.name.as_str(), f, idx)
})
.collect();
let mut next_tokio_postgres_index = 0;
let tokio_postgres_from_row_fields: Vec<_> = model
.fields
.values()
.map(|f| {
let idx = if f.has_column() {
let i = next_tokio_postgres_index;
next_tokio_postgres_index += 1;
Some(i)
} else {
None
};
emit_from_tokio_postgres_row_field(schema, model.name.as_str(), f, idx)
})
.collect();
let aggregate_tokens = emit_aggregate_structs(schema, model);
let deleted_at_col = model
.fields
.values()
.find(|f| f.attrs.is_deleted_at)
.map(|f| f.column.as_str());
let deleted_at_tokens = match deleted_at_col {
Some(c) => quote! { Some(#c) },
None => quote! { None },
};
let updated_at_col = model
.fields
.values()
.find(|f| f.attrs.is_updated_at)
.map(|f| f.column.as_str());
let updated_at_tokens = match updated_at_col {
Some(c) => quote! { Some(#c) },
None => quote! { None },
};
let header = header();
let tokens = quote! {
#header
use ::ruprizzle::serde::{Deserialize, Serialize};
use ::ruprizzle::sqlx::any::AnyRow;
use ::ruprizzle::types::chrono::{DateTime, NaiveDate, NaiveTime, Utc};
use ::ruprizzle::types::{Decimal, Uuid};
use ::ruprizzle::serde_json::Value as JsonValue;
use ::ruprizzle::Related;
use ::ruprizzle::Column;
#docs
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(crate = "::ruprizzle::serde")]
pub struct #model_name {
#( #entity_fields )*
}
impl<'r> ::ruprizzle::sqlx::FromRow<'r, AnyRow> for #model_name {
fn from_row(row: &'r AnyRow) -> Result<Self, ::ruprizzle::sqlx::Error> {
Ok(Self {
#( #any_from_row_fields )*
})
}
}
impl<'r> ::ruprizzle::sqlx::FromRow<'r, ::ruprizzle::sqlx::postgres::PgRow> for #model_name {
fn from_row(row: &'r ::ruprizzle::sqlx::postgres::PgRow) -> Result<Self, ::ruprizzle::sqlx::Error> {
Ok(Self {
#( #postgres_from_row_fields )*
})
}
}
impl<'r> ::ruprizzle::sqlx::FromRow<'r, ::ruprizzle::sqlx::sqlite::SqliteRow> for #model_name {
fn from_row(row: &'r ::ruprizzle::sqlx::sqlite::SqliteRow) -> Result<Self, ::ruprizzle::sqlx::Error> {
Ok(Self {
#( #sqlite_from_row_fields )*
})
}
}
impl<'r> ::ruprizzle::sqlx::FromRow<'r, ::ruprizzle::sqlx::mysql::MySqlRow> for #model_name {
fn from_row(row: &'r ::ruprizzle::sqlx::mysql::MySqlRow) -> Result<Self, ::ruprizzle::sqlx::Error> {
Ok(Self {
#( #mysql_from_row_fields )*
})
}
}
impl ::ruprizzle::JoinSide<AnyRow> for #model_name {
fn from_offset_row<'r>(__offset_row: &::ruprizzle::OffsetRow<'r, AnyRow>) -> Result<Self, ::ruprizzle::sqlx::Error>
where
Self: Sized,
{
let row = __offset_row.as_raw();
let __offset = __offset_row.offset();
Ok(Self {
#( #any_join_side_fields )*
})
}
}
impl ::ruprizzle::JoinSide<::ruprizzle::sqlx::postgres::PgRow> for #model_name {
fn from_offset_row<'r>(__offset_row: &::ruprizzle::OffsetRow<'r, ::ruprizzle::sqlx::postgres::PgRow>) -> Result<Self, ::ruprizzle::sqlx::Error>
where
Self: Sized,
{
let row = __offset_row.as_raw();
let __offset = __offset_row.offset();
Ok(Self {
#( #postgres_join_side_fields )*
})
}
}
impl ::ruprizzle::JoinSide<::ruprizzle::sqlx::sqlite::SqliteRow> for #model_name {
fn from_offset_row<'r>(__offset_row: &::ruprizzle::OffsetRow<'r, ::ruprizzle::sqlx::sqlite::SqliteRow>) -> Result<Self, ::ruprizzle::sqlx::Error>
where
Self: Sized,
{
let row = __offset_row.as_raw();
let __offset = __offset_row.offset();
Ok(Self {
#( #sqlite_join_side_fields )*
})
}
}
impl ::ruprizzle::JoinSide<::ruprizzle::sqlx::mysql::MySqlRow> for #model_name {
fn from_offset_row<'r>(__offset_row: &::ruprizzle::OffsetRow<'r, ::ruprizzle::sqlx::mysql::MySqlRow>) -> Result<Self, ::ruprizzle::sqlx::Error>
where
Self: Sized,
{
let row = __offset_row.as_raw();
let __offset = __offset_row.offset();
Ok(Self {
#( #mysql_join_side_fields )*
})
}
}
#[cfg(feature = "sqlite-rusqlite")]
impl ::ruprizzle::rusqlite::FromRusqliteRow for #model_name {
fn from_rusqlite_row(row: &::ruprizzle::rusqlite::RusqliteRow) -> Result<Self, ::ruprizzle::Error> {
Ok(Self {
#( #rusqlite_from_row_fields )*
})
}
}
#[cfg(feature = "sqlite-rusqlite")]
impl ::ruprizzle::rusqlite::FromOwnedRow for #model_name {
fn from_owned_row(row: &::ruprizzle::rusqlite::Row) -> Result<Self, ::ruprizzle::Error> {
Ok(Self {
#( #owned_from_row_fields )*
})
}
}
#[cfg(feature = "postgres-tokio-postgres")]
impl ::ruprizzle::tokio_postgres::FromTokioPostgresRow for #model_name {
fn from_tokio_postgres_row(row: &::ruprizzle::tokio_postgres::Row) -> Result<Self, ::ruprizzle::Error> {
Ok(Self {
#( #tokio_postgres_from_row_fields )*
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(crate = "::ruprizzle::serde")]
pub struct #insert_name {
#( #insert_fields )*
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(crate = "::ruprizzle::serde")]
pub struct #update_name {
#( #update_fields )*
}
#aggregate_tokens
impl ::ruprizzle::Model for #model_name {
const TABLE: &'static str = #table;
const PRIMARY_KEY: &'static str = #primary_key;
const COLUMNS: &'static [&'static str] = &[ #( #columns ),* ];
const DELETED_AT_COLUMN: Option<&'static str> = #deleted_at_tokens;
const UPDATED_AT_COLUMN: Option<&'static str> = #updated_at_tokens;
}
impl #model_name {
pub fn nested_create() -> ::ruprizzle::NestedCreate<#model_name> {
::ruprizzle::NestedCreate::new()
}
pub fn nested_connect(id: impl ::ruprizzle::Encodable) -> ::ruprizzle::Value {
id.to_value()
}
pub fn nested_connect_or_create(
filter: ::ruprizzle::Filter<#model_name>,
create: ::ruprizzle::NestedCreate<#model_name>,
) -> ::ruprizzle::NestedConnectOrCreate<#model_name> {
::ruprizzle::NestedConnectOrCreate::new(filter, create)
}
}
#tree_module_tokens
pub const TABLE: &str = #table;
#( #column_consts )*
#( #relation_helpers )*
#( #relation_filter_helpers )*
#[derive(Debug, Clone, Copy)]
pub struct #repo_name<'a> {
db: &'a super::Db,
}
impl<'a> #repo_name<'a> {
pub(crate) fn new(db: &'a super::Db) -> Self {
Self { db }
}
pub fn find_many(&self) -> ::ruprizzle::SelectQuery<'a, #model_name> {
::ruprizzle::SelectQuery::new(self.db.raw_pool())
}
pub fn create(&self, _data: #insert_name) -> ::ruprizzle::InsertQuery<'a, #model_name> {
let mut insert = ::ruprizzle::InsertQuery::new(self.db.raw_pool());
#( #insert_sets )*
insert
}
pub fn create_many(
&self,
_data: Vec<#insert_name>,
) -> ::ruprizzle::InsertManyQuery<'a, #model_name> {
let mut q = ::ruprizzle::InsertManyQuery::new(self.db.raw_pool());
for _row in _data {
q = q.row([ #( #insert_many_fields )* ]);
}
q
}
pub fn update(&self) -> ::ruprizzle::UpdateQuery<'a, #model_name> {
::ruprizzle::UpdateQuery::new(self.db.raw_pool())
}
pub fn delete(&self) -> ::ruprizzle::DeleteQuery<'a, #model_name> {
::ruprizzle::DeleteQuery::new(self.db.raw_pool())
}
#tree_repo_tokens
}
};
format(tokens)
}
fn emit_entity_field(schema: &Schema, owner: &str, field: &Field) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
let ty = rust_type_tokens(schema, owner, field, field.optional, false);
let doc = doc_attrs(field.docs.as_deref());
if !field.has_column() {
return quote! {
#doc
#[serde(skip_serializing_if = "::ruprizzle::Related::is_absent", default)]
pub #name: #ty,
};
}
quote! {
#doc
pub #name: #ty,
}
}
fn emit_from_row_field(
schema: &Schema,
owner: &str,
field: &Field,
row_expr: &TokenStream,
idx_expr: &TokenStream,
native_json: bool,
native_array: bool,
) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
if !field.has_column() {
return quote! { #name: ::ruprizzle::Related::default(), };
}
let optional = field.optional;
let _inner = rust_type_tokens(schema, owner, field, false, true);
let expr = match &field.kind {
ruprizzle_core::ir::FieldKind::Scalar(st) => match st {
ruprizzle_core::ir::ScalarType::String
| ruprizzle_core::ir::ScalarType::Int
| ruprizzle_core::ir::ScalarType::BigInt
| ruprizzle_core::ir::ScalarType::Float => {
let helper = format_ident!(
"{}",
if optional {
"direct_opt_idx"
} else {
"direct_idx"
}
);
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
ruprizzle_core::ir::ScalarType::Boolean => {
let helper = format_ident!(
"{}",
if optional {
"boolean_opt_idx"
} else {
"boolean_idx"
}
);
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
ruprizzle_core::ir::ScalarType::Decimal
| ruprizzle_core::ir::ScalarType::DateTime
| ruprizzle_core::ir::ScalarType::Date
| ruprizzle_core::ir::ScalarType::Time
| ruprizzle_core::ir::ScalarType::Uuid
| ruprizzle_core::ir::ScalarType::Point
| ruprizzle_core::ir::ScalarType::Polygon
| ruprizzle_core::ir::ScalarType::MultiPolygon
| ruprizzle_core::ir::ScalarType::LineString => {
let helper =
format_ident!("{}", if optional { "text_opt_idx" } else { "text_idx" });
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
ruprizzle_core::ir::ScalarType::Json => {
let helper = if native_json {
format_ident!("{}", if optional { "json_opt_idx" } else { "json_idx" })
} else {
format_ident!(
"{}",
if optional {
"json_text_opt_idx"
} else {
"json_text_idx"
}
)
};
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
ruprizzle_core::ir::ScalarType::Bytes => {
let helper = format_ident!(
"{}",
if optional {
"bytes_opt_idx"
} else {
"bytes_idx"
}
);
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
},
ruprizzle_core::ir::FieldKind::Enum(_) => {
let helper = format_ident!("{}", if optional { "text_opt_idx" } else { "text_idx" });
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
ruprizzle_core::ir::FieldKind::List(inner) => {
let inner_base = match inner.as_ref() {
ruprizzle_core::ir::FieldKind::Scalar(st) => scalar_type_tokens(*st),
ruprizzle_core::ir::FieldKind::Enum(name) => {
let name = format_ident!("{}", name.as_str());
quote! { super::enums::#name }
}
_ => quote! { () },
};
if native_array {
match inner.as_ref() {
ruprizzle_core::ir::FieldKind::Enum(_) => quote! {
#name: {
let __raw: ::std::vec::Vec<::std::string::String> = #row_expr.try_get(#idx_expr)?;
__raw
.into_iter()
.map(|__s| __s.parse::<#inner_base>().map_err(|__e| ::ruprizzle::sqlx::Error::Decode(::std::boxed::Box::new(__e))))
.collect::<::std::result::Result<::std::vec::Vec<_>, _>>()?
}
},
_ => {
quote! { #name: #row_expr.try_get::<_, ::std::vec::Vec<#inner_base>>(#idx_expr)?, }
}
}
} else {
let helper = format_ident!(
"{}",
if optional {
"array_opt_idx"
} else {
"array_idx"
}
);
quote! { #name: ::ruprizzle::decode::#helper::<_, #inner_base>(#row_expr, #idx_expr)?, }
}
}
_ => {
let helper = format_ident!(
"{}",
if optional {
"direct_opt_idx"
} else {
"direct_idx"
}
);
quote! { ::ruprizzle::decode::#helper(#row_expr, #idx_expr)? }
}
};
quote! { #name: #expr, }
}
fn emit_from_rusqlite_row_field(
schema: &Schema,
owner: &str,
field: &Field,
idx: Option<usize>,
) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
if !field.has_column() {
return quote! { #name: ::ruprizzle::Related::default(), };
}
let idx = syn::Index::from(idx.unwrap_or(0));
let ty = rust_type_tokens(schema, owner, field, field.optional, false);
let inner_ty = rust_type_tokens(schema, owner, field, false, false);
let expr = match &field.kind {
ruprizzle_core::ir::FieldKind::Scalar(st) => {
scalar_rusqlite_expr(*st, &idx, &ty, &inner_ty, field.optional)
}
ruprizzle_core::ir::FieldKind::Enum(_) => {
if field.optional {
quote! { ::ruprizzle::rusqlite::parse_opt::<#inner_ty>(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::parse::<#inner_ty>(row, #idx)? }
}
}
ruprizzle_core::ir::FieldKind::List(_) => {
quote! { ::ruprizzle::rusqlite::get::<_, #ty>(row, #idx)? }
}
_ => {
if field.optional {
quote! { ::ruprizzle::rusqlite::get_text_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_text(row, #idx)? }
}
}
};
quote! { #name: #expr, }
}
fn emit_from_owned_row_field(
schema: &Schema,
owner: &str,
field: &Field,
idx: Option<usize>,
) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
if !field.has_column() {
return quote! { #name: ::ruprizzle::Related::default(), };
}
let idx = syn::Index::from(idx.unwrap_or(0));
let ty = rust_type_tokens(schema, owner, field, field.optional, false);
quote! { #name: ::ruprizzle::rusqlite::Row::get::<#ty>(row, #idx)?, }
}
fn scalar_rusqlite_expr(
st: ruprizzle_core::ir::ScalarType,
idx: &syn::Index,
_ty: &TokenStream,
inner_ty: &TokenStream,
optional: bool,
) -> TokenStream {
use ruprizzle_core::ir::ScalarType;
let col = proc_macro2::Literal::usize_unsuffixed(idx.index as usize);
match st {
ScalarType::String => {
if optional {
quote! { ::ruprizzle::rusqlite::get_text_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_text(row, #idx)? }
}
}
ScalarType::BigInt => {
if optional {
quote! { ::ruprizzle::rusqlite::get_i64_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_i64(row, #idx)? }
}
}
ScalarType::Int => {
if optional {
quote! {
::ruprizzle::rusqlite::get_i64_opt(row, #idx)?
.map(|v| v.try_into().map_err(|e: std::num::TryFromIntError| {
::ruprizzle::Error::Message(format!("cannot decode i32 from column {}: {}", #col, e))
}))
.transpose()?
}
} else {
quote! {
::ruprizzle::rusqlite::get_i64(row, #idx)?
.try_into()
.map_err(|e: std::num::TryFromIntError| {
::ruprizzle::Error::Message(format!("cannot decode i32 from column {}: {}", #col, e))
})?
}
}
}
ScalarType::Float => {
if optional {
quote! { ::ruprizzle::rusqlite::get_f64_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_f64(row, #idx)? }
}
}
ScalarType::Boolean => {
if optional {
quote! { ::ruprizzle::rusqlite::get_bool_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_bool(row, #idx)? }
}
}
ScalarType::Json => {
if optional {
quote! { ::ruprizzle::rusqlite::get_json_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_json(row, #idx)? }
}
}
ScalarType::Bytes => {
if optional {
quote! { ::ruprizzle::rusqlite::get_bytes_opt(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::get_bytes(row, #idx)? }
}
}
ScalarType::Decimal
| ScalarType::DateTime
| ScalarType::Date
| ScalarType::Time
| ScalarType::Uuid
| ScalarType::Point
| ScalarType::Polygon
| ScalarType::MultiPolygon
| ScalarType::LineString => {
if optional {
quote! { ::ruprizzle::rusqlite::parse_opt::<#inner_ty>(row, #idx)? }
} else {
quote! { ::ruprizzle::rusqlite::parse::<#inner_ty>(row, #idx)? }
}
}
}
}
fn emit_from_tokio_postgres_row_field(
schema: &Schema,
owner: &str,
field: &Field,
idx: Option<usize>,
) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
if !field.has_column() {
return quote! { #name: ::ruprizzle::Related::default(), };
}
let idx = syn::Index::from(idx.unwrap_or(0));
let ty = rust_type_tokens(schema, owner, field, false, false);
match &field.kind {
ruprizzle_core::ir::FieldKind::Enum(_) => {
if field.optional {
quote! {
#name: row.try_get::<usize, Option<String>>(#idx)
.map_err(::ruprizzle::Error::TokioPostgres)?
.map(|s| s.parse::<#ty>().map_err(|e| ::ruprizzle::Error::Message(format!("cannot parse enum: {e}"))))
.transpose()?,
}
} else {
quote! {
#name: row.try_get::<usize, String>(#idx)
.map_err(::ruprizzle::Error::TokioPostgres)?
.parse::<#ty>()
.map_err(|e| ::ruprizzle::Error::Message(format!("cannot parse enum: {e}")))?,
}
}
}
ruprizzle_core::ir::FieldKind::List(inner) => match inner.as_ref() {
ruprizzle_core::ir::FieldKind::Enum(enum_name) => {
let enum_name = format_ident!("{}", enum_name.as_str());
quote! {
#name: row.try_get::<usize, ::std::vec::Vec<::std::string::String>>(#idx)
.map_err(::ruprizzle::Error::TokioPostgres)?
.into_iter()
.map(|s| s.parse::<super::enums::#enum_name>().map_err(|e| ::ruprizzle::Error::Message(format!("cannot parse enum: {e}"))))
.collect::<::std::result::Result<::std::vec::Vec<_>, _>>()?,
}
}
_ => {
quote! { #name: row.try_get::<usize, #ty>(#idx).map_err(::ruprizzle::Error::TokioPostgres)?, }
}
},
_ => {
if field.optional {
quote! { #name: row.try_get::<usize, Option<#ty>>(#idx).map_err(::ruprizzle::Error::TokioPostgres)?, }
} else {
quote! { #name: row.try_get::<usize, #ty>(#idx).map_err(::ruprizzle::Error::TokioPostgres)?, }
}
}
}
}
fn emit_insert_field(schema: &Schema, owner: &str, field: &Field) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
let ty = rust_type_tokens(schema, owner, field, false, true);
let optional = field.optional || field.default.is_some() || field.attrs.is_updated_at;
let ty = if optional {
quote! { Option<#ty> }
} else {
ty
};
let serde_attr = if optional {
Some(quote! { #[serde(default, skip_serializing_if = "Option::is_none")] })
} else {
None
};
quote! {
#serde_attr
pub #name: #ty,
}
}
fn emit_update_field(schema: &Schema, owner: &str, field: &Field) -> TokenStream {
let name = safe_field_ident(field.name.as_str());
let ty = rust_type_tokens(schema, owner, field, field.optional, false);
let ty = quote! { Option<#ty> };
quote! {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub #name: #ty,
}
}
fn emit_column_const(schema: &Schema, model: &Model, field: &Field, table: &str) -> TokenStream {
let name = format_ident!("{}", shouty_snake(field.name.as_str()));
let ty = rust_type_tokens(schema, model.name.as_str(), field, false, false);
let column = &field.column;
let model_name = format_ident!("{}", model.name.as_str());
quote! {
pub const #name: Column<#model_name, #ty> = Column::new(#table, #column);
}
}
fn emit_insert_set(_schema: &Schema, _model: &Model, field: &Field) -> TokenStream {
let field_ident = safe_field_ident(field.name.as_str());
let col = format_ident!("{}", shouty_snake(field.name.as_str()));
let optional = field.optional || field.default.is_some() || field.attrs.is_updated_at;
if optional {
quote! { insert = insert.set_optional(#col, _data.#field_ident); }
} else {
quote! { insert = insert.set(#col, _data.#field_ident); }
}
}
fn emit_insert_many_field(field: &Field) -> TokenStream {
let field_ident = safe_field_ident(field.name.as_str());
let col_name = field.column.as_str();
quote! { (#col_name, ::ruprizzle::Encodable::to_value(&_row.#field_ident)), }
}
fn rust_type_tokens(
schema: &Schema,
owner: &str,
field: &Field,
wrap_optional: bool,
base_only: bool,
) -> TokenStream {
let inner = match &field.kind {
FieldKind::Scalar(st) => scalar_type_tokens(*st),
FieldKind::Enum(name) => {
let name = format_ident!("{}", name.as_str());
quote! { super::enums::#name }
}
FieldKind::List(inner) => match inner.as_ref() {
FieldKind::Scalar(st) => {
let inner_ty = scalar_type_tokens(*st);
quote! { Vec<#inner_ty> }
}
FieldKind::Enum(name) => {
let name = format_ident!("{}", name.as_str());
quote! { Vec<super::enums::#name> }
}
FieldKind::Relation(r) => relation_inner_tokens(schema, owner, r.target.as_str(), true),
FieldKind::List(_) => {
quote! { () }
}
},
FieldKind::Relation(r) => relation_inner_tokens(schema, owner, r.target.as_str(), false),
};
let is_relation = match &field.kind {
FieldKind::Relation(_) => true,
FieldKind::List(inner) => matches!(inner.as_ref(), FieldKind::Relation(_)),
_ => false,
};
let wrapped = if !base_only && wrap_optional && !is_relation {
quote! { Option<#inner> }
} else {
inner
};
if is_relation {
quote! { ::ruprizzle::Related<#wrapped> }
} else {
wrapped
}
}
fn relation_inner_tokens(
_schema: &Schema,
owner: &str,
target: &str,
is_list: bool,
) -> TokenStream {
let is_self = owner == target;
let target_module = safe_module_name(target);
let target_ident = format_ident!("{}", target);
let module = format_ident!("{}", target_module);
if is_list {
quote! { Vec<super::#module::#target_ident> }
} else if is_self {
quote! { Option<Box<super::#module::#target_ident>> }
} else {
quote! { Option<super::#module::#target_ident> }
}
}
fn scalar_type_tokens(st: ScalarType) -> TokenStream {
match st {
ScalarType::String => quote! { String },
ScalarType::Int => quote! { i32 },
ScalarType::BigInt => quote! { i64 },
ScalarType::Float => quote! { f64 },
ScalarType::Decimal => quote! { Decimal },
ScalarType::Boolean => quote! { bool },
ScalarType::DateTime => quote! { DateTime<Utc> },
ScalarType::Date => quote! { NaiveDate },
ScalarType::Time => quote! { NaiveTime },
ScalarType::Uuid => quote! { Uuid },
ScalarType::Json => quote! { JsonValue },
ScalarType::Bytes => quote! { Vec<u8> },
ScalarType::Point => quote! { ::ruprizzle::spatial::Point },
ScalarType::Polygon => quote! { ::ruprizzle::spatial::Polygon },
ScalarType::MultiPolygon => quote! { ::ruprizzle::spatial::MultiPolygon },
ScalarType::LineString => quote! { ::ruprizzle::spatial::LineString },
}
}
#[derive(Debug)]
struct AggregateField {
name: Ident,
alias: String,
input_r: TokenStream,
output_inner: TokenStream,
}
fn numeric_aggregate_types(st: ScalarType) -> Option<(TokenStream, TokenStream, TokenStream)> {
match st {
ScalarType::Int => Some((quote! { i64 }, quote! { f64 }, quote! { i32 })),
ScalarType::BigInt => Some((quote! { i64 }, quote! { f64 }, quote! { i64 })),
ScalarType::Float => Some((quote! { f64 }, quote! { f64 }, quote! { f64 })),
_ => None,
}
}
fn emit_aggregate_structs(_schema: &Schema, model: &Model) -> TokenStream {
let model_name = format_ident!("{}", model.name.as_str());
let aggregate_name = format_ident!("{}Aggregate", model.name.as_str());
let input_name = format_ident!("{}AggregateInput", model.name.as_str());
let mut fields: Vec<AggregateField> = Vec::new();
for field in model.fields.values().filter(|f| f.has_column()) {
let column_suffix = naming::snake_case(&field.column);
let optional = field.optional;
let mut add = |kind: &'static str, input_r: TokenStream, output_inner: TokenStream| {
let alias = format!("{}_{}", kind, column_suffix);
let name = safe_field_ident(&alias);
fields.push(AggregateField {
name,
alias,
input_r,
output_inner,
});
};
add("count", quote! { i64 }, quote! { i64 });
add("count_distinct", quote! { i64 }, quote! { i64 });
if let FieldKind::Scalar(st) = &field.kind {
if let Some((sum_ty, avg_ty, minmax_ty)) = numeric_aggregate_types(*st) {
let sum_r = if optional {
quote! { Option<Option<#sum_ty>> }
} else {
quote! { Option<#sum_ty> }
};
let avg_r = if optional {
quote! { Option<Option<#avg_ty>> }
} else {
quote! { Option<#avg_ty> }
};
let minmax_r = if optional {
quote! { Option<Option<#minmax_ty>> }
} else {
quote! { Option<#minmax_ty> }
};
add("sum", sum_r, sum_ty);
add("avg", avg_r, avg_ty);
add("min", minmax_r.clone(), minmax_ty.clone());
add("max", minmax_r, minmax_ty);
}
}
}
let out_fields: Vec<_> = fields
.iter()
.map(|af| {
let name = &af.name;
let inner = &af.output_inner;
quote! {
#[sqlx(default)]
pub #name: Option<#inner>,
}
})
.collect();
let input_fields: Vec<_> = fields
.iter()
.map(|af| {
let name = &af.name;
let r = &af.input_r;
quote! {
pub #name: Option<::ruprizzle::Aggregate<#model_name, #r>>,
}
})
.collect();
let push_arms: Vec<_> = fields
.iter()
.map(|af| {
let name = &af.name;
quote! {
if let Some(a) = &self.#name {
a.push_entry(out);
}
}
})
.collect();
let from_rusqlite_fields: Vec<_> = fields
.iter()
.map(|af| {
let name = &af.name;
let alias = &af.alias;
let inner = &af.output_inner;
quote! {
let #name = match row.get::<_, Option<#inner>>(#alias) {
Ok(v) => v,
Err(::ruprizzle::rusqlite::Error::InvalidColumnName(_)) => None,
Err(e) => return Err(::ruprizzle::Error::Message(e.to_string())),
};
}
})
.collect();
let from_owned_fields: Vec<_> = fields
.iter()
.map(|af| {
let name = &af.name;
let alias = &af.alias;
let inner = &af.output_inner;
quote! {
let #name = row.get_by_name::<Option<#inner>>(#alias)?;
}
})
.collect();
let from_tokio_postgres_fields: Vec<_> = fields
.iter()
.map(|af| {
let name = &af.name;
let alias = &af.alias;
let inner = &af.output_inner;
quote! {
let #name = match row.columns().iter().position(|c| c.name() == #alias) {
Some(idx) => row
.try_get::<usize, Option<#inner>>(idx)
.map_err(::ruprizzle::Error::TokioPostgres)?,
None => None,
};
}
})
.collect();
let field_names: Vec<_> = fields.iter().map(|af| &af.name).collect();
quote! {
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, ::ruprizzle::sqlx::FromRow)]
#[serde(crate = "::ruprizzle::serde", default)]
pub struct #aggregate_name {
#( #out_fields )*
}
#[derive(Debug, Clone, Default)]
pub struct #input_name {
#( #input_fields )*
}
impl ::ruprizzle::AggregateSet<#model_name, #aggregate_name> for #input_name {
fn push_entries(&self, out: &mut Vec<::ruprizzle::AggregateEntry>) {
use ::ruprizzle::IntoAggregate;
#( #push_arms )*
}
}
#[cfg(feature = "sqlite-rusqlite")]
impl ::ruprizzle::rusqlite::FromRusqliteRow for #aggregate_name {
fn from_rusqlite_row(row: &::ruprizzle::rusqlite::RusqliteRow) -> Result<Self, ::ruprizzle::Error> {
#( #from_rusqlite_fields )*
Ok(Self {
#( #field_names ),*
})
}
}
#[cfg(feature = "sqlite-rusqlite")]
impl ::ruprizzle::rusqlite::FromOwnedRow for #aggregate_name {
fn from_owned_row(row: &::ruprizzle::rusqlite::Row) -> Result<Self, ::ruprizzle::Error> {
#( #from_owned_fields )*
Ok(Self {
#( #field_names ),*
})
}
}
#[cfg(feature = "postgres-tokio-postgres")]
impl ::ruprizzle::tokio_postgres::FromTokioPostgresRow for #aggregate_name {
fn from_tokio_postgres_row(row: &::ruprizzle::tokio_postgres::Row) -> Result<Self, ::ruprizzle::Error> {
#( #from_tokio_postgres_fields )*
Ok(Self {
#( #field_names ),*
})
}
}
}
}
fn doc_attrs(docs: Option<&str>) -> TokenStream {
match docs {
Some(text) => {
let lines: Vec<_> = text.lines().collect();
quote! { #( #[doc = #lines] )* }
}
None => TokenStream::new(),
}
}
fn safe_field_ident(s: &str) -> Ident {
let name = naming::snake_case(s);
safe_ident(&name)
}
fn safe_module_name(s: &str) -> String {
let name = naming::snake_case(s);
if is_keyword(&name) {
format!("{name}_")
} else {
name
}
}
fn safe_ident(s: &str) -> Ident {
if is_keyword(s) {
Ident::new_raw(s, Span::call_site())
} else {
Ident::new(s, Span::call_site())
}
}
fn is_keyword(s: &str) -> bool {
matches!(
s,
"as" | "async"
| "await"
| "break"
| "const"
| "continue"
| "crate"
| "dyn"
| "else"
| "enum"
| "extern"
| "false"
| "fn"
| "for"
| "if"
| "impl"
| "in"
| "let"
| "loop"
| "match"
| "mod"
| "move"
| "mut"
| "pub"
| "ref"
| "return"
| "self"
| "Self"
| "static"
| "struct"
| "super"
| "trait"
| "true"
| "type"
| "unsafe"
| "use"
| "where"
| "while"
| "abstract"
| "become"
| "box"
| "do"
| "final"
| "macro"
| "override"
| "priv"
| "typeof"
| "unsized"
| "virtual"
| "yield"
| "try"
)
}
fn shouty_snake(s: &str) -> String {
naming::snake_case(s).to_ascii_uppercase()
}
fn pascal(s: &str) -> String {
s.split('_')
.map(|w| {
let mut chars = w.chars();
match chars.next() {
Some(c) => c.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase(),
None => String::new(),
}
})
.collect()
}
fn find_field_by_column<'a>(model: &'a Model, column: &str) -> Option<&'a Field> {
model
.fields
.values()
.find(|f| f.has_column() && f.column.as_str() == column)
}
fn relation_key_type(schema: &Schema, owner: &str, field: &Field) -> TokenStream {
rust_type_tokens(schema, owner, field, false, true)
}
fn emit_relation_helper(schema: &Schema, model: &Model, field: &Field) -> Option<TokenStream> {
let model_name = format_ident!("{}", model.name.as_str());
let rel_ref = match &field.kind {
FieldKind::Relation(r) => r,
FieldKind::List(inner) => match inner.as_ref() {
FieldKind::Relation(r) => r,
_ => return None,
},
_ => return None,
};
let rel_index = rel_ref.resolved?;
let rel = schema.relations.get(rel_index)?;
let is_list = matches!(field.kind, FieldKind::List(_));
let is_owner = model.name == rel.owner;
if rel.kind == RelationKind::ManyToMany {
return emit_many_to_many_helpers(schema, model, field, rel);
}
let (parent_name, child_name, parent_key_col, child_key_col) = if is_owner {
(
&rel.owner,
&rel.target,
rel.owner_cols.first()?,
rel.target_cols.first()?,
)
} else {
(
&rel.target,
&rel.owner,
rel.target_cols.first()?,
rel.owner_cols.first()?,
)
};
let parent_model = schema.models.get(parent_name)?;
let child_model = schema.models.get(child_name)?;
let parent_key_field = find_field_by_column(parent_model, parent_key_col)?;
let child_key_field = find_field_by_column(child_model, child_key_col)?;
if parent_key_field.optional || child_key_field.optional {
return None;
}
let key_type = relation_key_type(schema, model.name.as_str(), parent_key_field);
let child_key_type = relation_key_type(schema, model.name.as_str(), child_key_field);
if key_type.to_string() != child_key_type.to_string() {
return None;
}
let parent_field_ident = safe_field_ident(field.name.as_str());
let parent_key_ident = safe_field_ident(parent_key_field.name.as_str());
let child_key_ident = safe_field_ident(child_key_field.name.as_str());
let child_key_const = format_ident!("{}", shouty_snake(child_key_field.name.as_str()));
let child_module = safe_module_name(child_name.as_str());
let child_module_ident = format_ident!("{}", child_module);
let child_type = format_ident!("{}", child_name.as_str());
let helper_name = safe_field_ident(field.name.as_str());
let is_self_to_one = !is_list && child_name.as_str() == model.name.as_str();
let one_setter = if is_self_to_one {
quote! {
|__row, __loaded| {
__row.#parent_field_ident = match __loaded {
::ruprizzle::Related::Absent => ::ruprizzle::Related::Absent,
::ruprizzle::Related::Loaded(__v) => {
::ruprizzle::Related::Loaded(__v.map(Box::new))
}
};
}
}
} else {
quote! { |__row, __loaded| __row.#parent_field_ident = __loaded }
};
Some(if is_list {
quote! {
pub fn #helper_name() -> ::ruprizzle::IncludeList<'static, #model_name, super::#child_module_ident::#child_type, #key_type, ()> {
::ruprizzle::IncludeList::new(
|__row| __row.#parent_key_ident,
|__row, __loaded| __row.#parent_field_ident = __loaded,
super::#child_module_ident::#child_key_const,
|__child| __child.#child_key_ident,
)
}
}
} else {
quote! {
pub fn #helper_name() -> ::ruprizzle::IncludeOne<'static, #model_name, super::#child_module_ident::#child_type, #key_type, ()> {
::ruprizzle::IncludeOne::new(
|__row| __row.#parent_key_ident,
#one_setter,
super::#child_module_ident::#child_key_const,
|__child| __child.#child_key_ident,
)
}
}
})
}
fn emit_many_to_many_helpers(
schema: &Schema,
model: &Model,
field: &Field,
rel: &ResolvedRelation,
) -> Option<TokenStream> {
let join_model = schema.models.get(rel.join_model.as_ref()?.as_str())?;
let owner_fk_field = join_model
.fields
.get(rel.join_owner_field.as_ref()?.as_str())?;
let target_fk_field = join_model
.fields
.get(rel.join_target_field.as_ref()?.as_str())?;
let owner_fk_rel = owner_fk_field.relation()?;
let target_fk_rel = target_fk_field.relation()?;
let owner_pk_name = owner_fk_rel.references.first()?;
let target_pk_name = target_fk_rel.references.first()?;
let owner_model = schema.models.get(rel.owner.as_str())?;
let target_model = schema.models.get(rel.target.as_str())?;
let owner_pk_field = owner_model.fields.get(owner_pk_name.as_str())?;
let target_pk_field = target_model.fields.get(target_pk_name.as_str())?;
if owner_pk_field.optional || target_pk_field.optional {
return None;
}
let owner_fk_col_field = join_model
.fields
.get(owner_fk_rel.fields.first()?.as_str())?;
let target_fk_col_field = join_model
.fields
.get(target_fk_rel.fields.first()?.as_str())?;
let key_type = rust_type_tokens(schema, rel.owner.as_str(), owner_pk_field, false, true);
let ckey_type = rust_type_tokens(schema, rel.target.as_str(), target_pk_field, false, true);
let include_helper_name = safe_field_ident(field.name.as_str());
let query_helper_name = format_ident!("{}_query", include_helper_name);
let param_name = safe_field_ident(owner_pk_field.name.as_str());
let field_ident = safe_field_ident(field.name.as_str());
let model_name = format_ident!("{}", model.name.as_str());
let join_module = safe_module_name(join_model.name.as_str());
let join_module_ident = format_ident!("{}", join_module);
let join_type = format_ident!("{}", join_model.name.as_str());
let target_module = safe_module_name(target_model.name.as_str());
let target_module_ident = format_ident!("{}", target_module);
let target_type = format_ident!("{}", target_model.name.as_str());
let owner_fk_field_ident = safe_field_ident(owner_fk_col_field.name.as_str());
let target_fk_field_ident = safe_field_ident(target_fk_col_field.name.as_str());
let target_pk_field_ident = safe_field_ident(target_pk_field.name.as_str());
let owner_pk_field_ident = safe_field_ident(owner_pk_field.name.as_str());
let owner_join_const = format_ident!("{}", shouty_snake(owner_fk_col_field.name.as_str()));
let target_join_const = format_ident!("{}", shouty_snake(target_fk_col_field.name.as_str()));
let target_pk_const = format_ident!("{}", shouty_snake(target_pk_field.name.as_str()));
let query_doc = format!(
"Returns a query for the `{}` many-to-many relation.",
include_helper_name
);
let include_doc = format!(
"Returns an `IncludeMany` for the `{}` many-to-many relation.",
include_helper_name
);
let attach_helper_name = format_ident!("{}_attach", include_helper_name);
let set_helper_name = format_ident!("{}_set", include_helper_name);
let detach_helper_name = format_ident!("{}_detach", include_helper_name);
let attach_doc = format!(
"Returns an `M2mWrite::Attach` for the `{}` many-to-many relation.",
include_helper_name
);
let set_doc = format!(
"Returns an `M2mWrite::Set` for the `{}` many-to-many relation.",
include_helper_name
);
let detach_doc = format!(
"Returns an `M2mWrite::Detach` for the `{}` many-to-many relation.",
include_helper_name
);
let join_table = &join_model.table;
let join_owner_col = &owner_fk_col_field.column;
let join_target_col = &target_fk_col_field.column;
let target_table = &target_model.table;
let target_pk_col = &target_pk_field.column;
let m2m_type = quote! {
::ruprizzle::M2mWrite<
'static,
#model_name,
super::#target_module_ident::#target_type,
super::#join_module_ident::#join_type,
>
};
Some(quote! {
#[doc = #query_doc]
pub fn #query_helper_name<'__a>(
__exec: &'__a dyn ::ruprizzle::Executor,
#param_name: #key_type,
) -> ::ruprizzle::SelectQuery<'__a, super::#target_module_ident::#target_type> {
let __subquery = ::ruprizzle::SelectQuery::new(__exec)
.filter(super::#join_module_ident::#owner_join_const.eq(#param_name))
.columns(super::#join_module_ident::#target_join_const);
::ruprizzle::SelectQuery::new(__exec)
.filter(super::#target_module_ident::#target_pk_const.in_subquery(__subquery))
}
#[doc = #include_doc]
pub fn #include_helper_name() -> ::ruprizzle::IncludeMany<
'static,
#model_name,
super::#target_module_ident::#target_type,
super::#join_module_ident::#join_type,
#key_type,
#ckey_type,
(),
> {
::ruprizzle::IncludeMany::new(
|__row: &#model_name| __row.#owner_pk_field_ident,
|__row: &mut #model_name, __loaded: ::ruprizzle::Related<Vec<super::#target_module_ident::#target_type>>| {
__row.#field_ident = __loaded;
},
|__row: &super::#join_module_ident::#join_type| __row.#owner_fk_field_ident,
|__row: &super::#join_module_ident::#join_type| __row.#target_fk_field_ident,
|__child: &super::#target_module_ident::#target_type| __child.#target_pk_field_ident,
super::#join_module_ident::#owner_join_const,
super::#join_module_ident::#target_join_const,
super::#target_module_ident::#target_pk_const,
)
}
#[doc = #attach_doc]
pub fn #attach_helper_name(
ids: impl IntoIterator<Item = #ckey_type>,
) -> #m2m_type {
::ruprizzle::M2mWrite::new(
::ruprizzle::M2mAction::Attach,
|__row: &#model_name| ::ruprizzle::Encodable::to_value(&__row.#owner_pk_field_ident),
#join_table,
#join_owner_col,
#join_target_col,
#target_table,
#target_pk_col,
ids.into_iter().map(|__id| ::ruprizzle::Encodable::to_value(&__id)).collect(),
|__row: &mut #model_name, __loaded: Vec<super::#target_module_ident::#target_type>| {
__row.#field_ident = ::ruprizzle::Related::Loaded(__loaded);
},
)
}
#[doc = #set_doc]
pub fn #set_helper_name(
ids: impl IntoIterator<Item = #ckey_type>,
) -> #m2m_type {
::ruprizzle::M2mWrite::new(
::ruprizzle::M2mAction::Set,
|__row: &#model_name| ::ruprizzle::Encodable::to_value(&__row.#owner_pk_field_ident),
#join_table,
#join_owner_col,
#join_target_col,
#target_table,
#target_pk_col,
ids.into_iter().map(|__id| ::ruprizzle::Encodable::to_value(&__id)).collect(),
|__row: &mut #model_name, __loaded: Vec<super::#target_module_ident::#target_type>| {
__row.#field_ident = ::ruprizzle::Related::Loaded(__loaded);
},
)
}
#[doc = #detach_doc]
pub fn #detach_helper_name(
ids: impl IntoIterator<Item = #ckey_type>,
) -> #m2m_type {
::ruprizzle::M2mWrite::new(
::ruprizzle::M2mAction::Detach,
|__row: &#model_name| ::ruprizzle::Encodable::to_value(&__row.#owner_pk_field_ident),
#join_table,
#join_owner_col,
#join_target_col,
#target_table,
#target_pk_col,
ids.into_iter().map(|__id| ::ruprizzle::Encodable::to_value(&__id)).collect(),
|__row: &mut #model_name, __loaded: Vec<super::#target_module_ident::#target_type>| {
__row.#field_ident = ::ruprizzle::Related::Loaded(__loaded);
},
)
}
})
}
fn emit_relation_filter_helpers(
schema: &Schema,
model: &Model,
field: &Field,
) -> Option<TokenStream> {
let model_name = format_ident!("{}", model.name.as_str());
let rel_ref = match &field.kind {
FieldKind::Relation(r) => r,
FieldKind::List(inner) => match inner.as_ref() {
FieldKind::Relation(r) => r,
_ => return None,
},
_ => return None,
};
let rel_index = rel_ref.resolved?;
let rel = schema.relations.get(rel_index)?;
if rel.kind == RelationKind::ManyToMany {
return None;
}
let is_owner = model.name == rel.owner;
let (parent_table, parent_col, child, child_col) = if is_owner {
(
&model.table,
rel.owner_cols.first()?,
&rel.target,
rel.target_cols.first()?,
)
} else {
(
&model.table,
rel.target_cols.first()?,
&rel.owner,
rel.owner_cols.first()?,
)
};
let child_model = schema.models.get(child)?;
let child_table = &child_model.table;
let child_module = safe_module_name(child.as_str());
let child_module_ident = format_ident!("{}", child_module);
let child_type = format_ident!("{}", child.as_str());
let live = child_model
.fields
.values()
.find(|f| f.attrs.is_deleted_at)
.map(|f| {
let col = f.column.as_str();
quote! {
.and(::ruprizzle::Filter::new(::ruprizzle::FilterNode::Null {
table: #child_table,
column: #col,
negated: false,
}))
}
})
.unwrap_or_default();
let base = safe_field_ident(field.name.as_str());
let some_name = format_ident!("{}_some", base);
let none_name = format_ident!("{}_none", base);
let every_name = format_ident!("{}_every", base);
Some(quote! {
pub fn #some_name(f: ::ruprizzle::Filter<super::#child_module_ident::#child_type>) -> ::ruprizzle::Filter<#model_name> {
::ruprizzle::Filter::new(::ruprizzle::FilterNode::Exists {
child_table: #child_table,
child_col: #child_col,
parent_table: #parent_table,
parent_col: #parent_col,
filter: Box::new(f #live .node),
negated: false,
})
}
pub fn #none_name(f: ::ruprizzle::Filter<super::#child_module_ident::#child_type>) -> ::ruprizzle::Filter<#model_name> {
::ruprizzle::Filter::new(::ruprizzle::FilterNode::Exists {
child_table: #child_table,
child_col: #child_col,
parent_table: #parent_table,
parent_col: #parent_col,
filter: Box::new(f #live .node),
negated: true,
})
}
pub fn #every_name(f: ::ruprizzle::Filter<super::#child_module_ident::#child_type>) -> ::ruprizzle::Filter<#model_name> {
::ruprizzle::Filter::new(::ruprizzle::FilterNode::Exists {
child_table: #child_table,
child_col: #child_col,
parent_table: #parent_table,
parent_col: #parent_col,
filter: Box::new((!f) #live .node),
negated: true,
})
}
})
}
fn emit_tree_helpers(model: &Model) -> (TokenStream, TokenStream) {
let model_name = format_ident!("{}", model.name.as_str());
let table = &model.table;
let Some(pk_name) = model.primary_key.fields.first() else {
return (quote! {}, quote! {});
};
let Some(pk_field) = model.fields.get(pk_name.as_str()) else {
return (quote! {}, quote! {});
};
let primary_key = &pk_field.column;
let pk_field_ident = safe_field_ident(pk_name.as_str());
let self_rel = model.fields.values().find_map(|f| {
let rel = f.relation()?;
if rel.target == model.name && !rel.fields.is_empty() {
let fk_name = rel.fields.first()?;
let fk_field = model.fields.get(fk_name.as_str())?;
Some((fk_field, f))
} else {
None
}
});
let Some((parent_fk_field, _rel_field)) = self_rel else {
return (quote! {}, quote! {});
};
let parent_fk_col = &parent_fk_field.column;
let parent_fk_ident = safe_field_ident(parent_fk_field.name.as_str());
let module_tokens = quote! {
pub fn ancestors<'__a>(
id: impl Into<::ruprizzle::Value>,
pool: &'__a ::ruprizzle::Pool,
) -> ::ruprizzle::HierarchyQuery<'__a, #model_name> {
::ruprizzle::HierarchyQuery::ancestors(
pool,
#table,
#primary_key,
#parent_fk_col,
id,
)
}
pub fn descendants<'__a>(
id: impl Into<::ruprizzle::Value>,
pool: &'__a ::ruprizzle::Pool,
) -> ::ruprizzle::HierarchyQuery<'__a, #model_name> {
::ruprizzle::HierarchyQuery::descendants(
pool,
#table,
#primary_key,
#parent_fk_col,
id,
)
}
pub async fn tree_from_root(
root_id: impl Into<::ruprizzle::Value>,
pool: &::ruprizzle::Pool,
) -> Result<::ruprizzle::HierarchyNode<#model_name>, ::ruprizzle::Error> {
let root_val = root_id.into();
let root_items = ::ruprizzle::HierarchyQuery::<#model_name>::new(
pool,
#table,
#primary_key,
#parent_fk_col,
root_val.clone(),
::ruprizzle::HierarchyDirection::Ancestors,
)
.max_depth(1)
.all()
.await?;
let root = root_items.into_iter().next().ok_or_else(|| {
::ruprizzle::Error::Message(format!("Tree root entity not found in {}", #table))
})?;
let descendants = ::ruprizzle::HierarchyQuery::<#model_name>::descendants(
pool,
#table,
#primary_key,
#parent_fk_col,
root_val,
)
.all()
.await?;
let descendants = descendants
.into_iter()
.filter(|d| {
::ruprizzle::Encodable::to_value(&d.#pk_field_ident)
!= ::ruprizzle::Encodable::to_value(&root.#pk_field_ident)
})
.collect();
Ok(::ruprizzle::HierarchyNode::from_flat(
root,
descendants,
|m| ::ruprizzle::Encodable::to_value(&m.#pk_field_ident),
|m| m.#parent_fk_ident.as_ref().map(::ruprizzle::Encodable::to_value),
))
}
};
let repo_tokens = quote! {
pub fn ancestors(
&self,
id: impl Into<::ruprizzle::Value>,
) -> ::ruprizzle::HierarchyQuery<'a, #model_name> {
ancestors(id, self.db.raw_pool())
}
pub fn descendants(
&self,
id: impl Into<::ruprizzle::Value>,
) -> ::ruprizzle::HierarchyQuery<'a, #model_name> {
descendants(id, self.db.raw_pool())
}
pub async fn tree_from_root(
&self,
root_id: impl Into<::ruprizzle::Value>,
) -> Result<::ruprizzle::HierarchyNode<#model_name>, ::ruprizzle::Error> {
tree_from_root(root_id, self.db.raw_pool()).await
}
};
(module_tokens, repo_tokens)
}