appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
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 })
        }
    }
}