use super::{find_entity, module_name, parse_ident, render, rust_type};
mod registry;
use crate::CodegenError;
use appstruct_ir::{AppIr, EntityIr, OperationTypeIr, ValueObjectIr};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
pub(super) fn source(ir: &AppIr) -> Result<String, CodegenError> {
let request_context = super::context::contract();
let values = ir
.value_objects
.iter()
.map(value_object)
.collect::<Result<Vec<_>, _>>()?;
let hooks = ir
.entities
.iter()
.map(hook_contract)
.collect::<Result<Vec<_>, _>>()?;
let policies = ir
.entities
.iter()
.map(policy_contract)
.collect::<Result<Vec<_>, _>>()?;
let handler_traits = handler_traits(ir)?;
let registry = registry::source(ir);
render(quote! {
use crate::{Actor, ApiError, TenantId, api, entities};
use async_trait::async_trait;
use sea_orm::{
ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
ExecResult, QueryResult, Statement,
};
use std::sync::Arc;
#request_context
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum HookOperation { Create, Update, Delete }
#(#values)*
#(#hooks)*
#(#policies)*
#handler_traits
#registry
})
}
fn value_object(value: &ValueObjectIr) -> Result<TokenStream, CodegenError> {
let name = parse_ident(&value.rust_name)?;
let fields = value
.fields
.iter()
.map(|field| {
let name = parse_ident(&field.rust_name)?;
let base = rust_type(&field.ty);
let ty = if field.required {
base
} else {
quote! { Option<#base> }
};
Ok(quote! { pub #name: #ty })
})
.collect::<Result<Vec<_>, CodegenError>>()?;
Ok(quote! {
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct #name { #(#fields,)* }
})
}
fn hook_contract(entity: &EntityIr) -> Result<TokenStream, CodegenError> {
let trait_name = format_ident!("{}Hooks", entity.rust_name);
let default_name = format_ident!("Default{}Hooks", entity.rust_name);
let module = parse_ident(&module_name(entity))?;
Ok(quote! {
#[async_trait]
pub trait #trait_name: Send + Sync {
async fn before_validate_create(&self, _ctx: &RequestContext, _input: &mut api::#module::CreateInput) -> Result<(), ApiError> { Ok(()) }
async fn before_validate_update(&self, _ctx: &RequestContext, _input: &mut api::#module::UpdateInput) -> Result<(), ApiError> { Ok(()) }
async fn before_create(&self, _ctx: &RequestContext, _input: &mut api::#module::CreateInput) -> Result<(), ApiError> { Ok(()) }
async fn after_create(&self, _ctx: &RequestContext, _model: &entities::#module::Model) -> Result<(), ApiError> { Ok(()) }
async fn before_update(&self, _ctx: &RequestContext, _before: &entities::#module::Model, _input: &mut api::#module::UpdateInput) -> Result<(), ApiError> { Ok(()) }
async fn after_update(&self, _ctx: &RequestContext, _before: &entities::#module::Model, _after: &entities::#module::Model) -> Result<(), ApiError> { Ok(()) }
async fn before_delete(&self, _ctx: &RequestContext, _model: &entities::#module::Model) -> Result<(), ApiError> { Ok(()) }
async fn after_delete(&self, _ctx: &RequestContext, _model: &entities::#module::Model) -> Result<(), ApiError> { Ok(()) }
async fn after_commit(&self, _ctx: &RequestContext, _operation: HookOperation, _model: &entities::#module::Model) -> Result<(), ApiError> { Ok(()) }
}
struct #default_name;
#[async_trait]
impl #trait_name for #default_name {}
})
}
fn policy_contract(entity: &EntityIr) -> Result<TokenStream, CodegenError> {
let trait_name = format_ident!("{}Policy", entity.rust_name);
let default_name = format_ident!("Default{}Policy", entity.rust_name);
let module = parse_ident(&module_name(entity))?;
Ok(quote! {
#[async_trait]
pub trait #trait_name: Send + Sync {
async fn can_list(&self, _ctx: &RequestContext) -> Result<bool, ApiError> { Ok(true) }
async fn can_read(&self, _ctx: &RequestContext, _model: &entities::#module::Model) -> Result<bool, ApiError> { Ok(true) }
async fn can_create(&self, _ctx: &RequestContext, _input: &api::#module::CreateInput) -> Result<bool, ApiError> { Ok(true) }
async fn can_update(&self, _ctx: &RequestContext, _before: &entities::#module::Model, _input: &api::#module::UpdateInput, _after: &entities::#module::Model) -> Result<bool, ApiError> { Ok(true) }
async fn can_delete(&self, _ctx: &RequestContext, _model: &entities::#module::Model) -> Result<bool, ApiError> { Ok(true) }
}
struct #default_name;
#[async_trait]
impl #trait_name for #default_name {}
})
}
fn handler_traits(ir: &AppIr) -> Result<TokenStream, CodegenError> {
let mut traits = Vec::new();
let mut names = Vec::new();
for command in &ir.commands {
let name = format_ident!("{}Handler", command.rust_name);
let input = operation_type(ir, &command.input)?;
let output = operation_type(ir, &command.output)?;
traits.push(quote! {
#[async_trait]
pub trait #name: Send + Sync {
async fn execute(&self, ctx: &RequestContext, input: #input) -> Result<#output, ApiError>;
}
});
names.push(name);
}
for query in &ir.queries {
let name = format_ident!("{}Handler", query.rust_name);
let output = operation_type(ir, &query.output)?;
let method = if let Some(input) = &query.input {
let input = operation_type(ir, input)?;
quote! { async fn execute(&self, ctx: &RequestContext, input: #input) -> Result<#output, ApiError>; }
} else {
quote! { async fn execute(&self, ctx: &RequestContext) -> Result<#output, ApiError>; }
};
traits.push(quote! {
#[async_trait]
pub trait #name: Send + Sync { #method }
});
names.push(name);
}
Ok(quote! {
#(#traits)*
pub trait RequiredHandlers: Send + Sync #( + #names )* {}
impl<T> RequiredHandlers for T where T: Send + Sync #( + #names )* {}
})
}
pub(super) fn operation_type(
ir: &AppIr,
operation_type: &OperationTypeIr,
) -> Result<TokenStream, CodegenError> {
match operation_type {
OperationTypeIr::Entity { entity } => {
let entity = find_entity(ir, &entity.0)?;
let module = parse_ident(&module_name(entity))?;
Ok(quote! { entities::#module::Model })
}
OperationTypeIr::ValueObject { value_object } => {
let value = ir
.value_objects
.iter()
.find(|value| value.id == *value_object)
.ok_or_else(|| {
CodegenError::new(format!("missing value object `{value_object}`"))
})?;
let name = parse_ident(&value.rust_name)?;
Ok(quote! { #name })
}
}
}