appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
mod bulk;
mod write;
use super::query::list_support;
use super::validation::validation_rules;
use super::{module_name, parse_ident, render, rust_type};
use crate::CodegenError;
use appstruct_ir::{AccessRuleIr, AppIr, EntityIr, FieldIr, FieldTypeIr, GeneratedValueIr};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};

pub(super) fn source(ir: &AppIr, entity: &EntityIr) -> Result<String, CodegenError> {
    let module = parse_ident(&module_name(entity))?;
    let create_fields = dto_fields(entity, false)?;
    let update_fields = dto_fields(entity, true)?;
    let create_values = create_values(entity)?;
    let active_default = entity
        .fields
        .iter()
        .any(|field| matches!(field.generated, Some(GeneratedValueIr::AutoIncrement)))
        .then(|| quote! { ..Default::default() });
    let updates = update_values(entity)?;
    let parse_id = parse_id_expression(primary_key(entity)?);
    let primary = parse_ident(&primary_key(entity)?.rust_name)?;
    let hooks = format_ident!("{}_hooks", module_name(entity));
    let policy = format_ident!("{}_policy", module_name(entity));
    let list = list_support(ir, entity, &module, &policy)?;
    let aggregate = super::query::aggregate::aggregate_support(ir, entity, &module, &policy)?;
    let handlers = write::handlers(
        entity,
        &write::HandlerContext {
            module: &module,
            hooks: &hooks,
            policy: &policy,
            parse_id: &parse_id,
            primary: &primary,
            soft_delete: entity.views.soft_delete,
        },
        &create_values,
        active_default.as_ref(),
        &updates,
    )?;
    let validators = validation_functions(entity)?;
    let field_access = field_access_support(entity, &module)?;
    let list_scope = super::access::scope(entity, &module, &entity.access.list)?;
    let create_allowed = super::access::create_allowed(entity, &entity.access.create)?;
    let update_allowed = super::access::update_allowed(entity, &entity.access.update)?;
    let delete_allowed = super::access::row_allowed(entity, &entity.access.delete)?;
    let bulk = bulk::source(
        entity,
        &module,
        &parse_id,
        &primary,
        &hooks,
        &policy,
        &list_scope,
        &create_allowed,
        &delete_allowed,
        &update_allowed,
        &create_values,
        active_default.as_ref(),
        &updates,
    )?;
    let restore_route = entity
        .views
        .soft_delete
        .then(|| quote! { .route("/_restore", axum::routing::post(restore)).route("/_trash", get(trash)) });

    render(quote! {
        use crate::{AppState, ApiError, FieldViolation, RequestContext, entities::#module};
        use axum::{
            Json, Router,
            extract::{Path, State},
            http::{HeaderMap, StatusCode, header},
            routing::get,
        };
        use sea_orm::{
            ActiveModelTrait, ActiveValue::Set, EntityTrait, IntoActiveModel,
            ModelTrait, QuerySelect, TransactionTrait, TryIntoModel,
        };
        use serde::{Deserialize, Serialize};
        use std::collections::BTreeMap;

        #[derive(Clone, Debug, Default, Deserialize)]
        pub struct CreateInput { #(#create_fields,)* }
        #[derive(Clone, Debug, Default, Deserialize)]
        pub struct UpdateInput { #(#update_fields,)* }
        pub fn router() -> Router<AppState> {
            Router::new()
                .route("/", get(list).post(create))
                .route("/_aggregate", get(aggregate))
                .route("/_bulk", axum::routing::patch(bulk_update).delete(bulk_delete))
                .route("/_export.csv", get(export_csv))
                .route("/_import.csv", axum::routing::post(import_csv))
                #restore_route
                .route("/{id}", get(read).patch(update).delete(delete))
        }
        #list
        #aggregate
        #handlers
        #validators
        #field_access
        #bulk
    })
}
fn field_access_support(
    entity: &EntityIr,
    module: &syn::Ident,
) -> Result<TokenStream, CodegenError> {
    let read_arms = field_access_arms(entity, |field| field.read_access.as_ref());
    let write_arms = field_access_arms(entity, |field| field.write_access.as_ref());
    let read_redactions = entity
        .fields
        .iter()
        .filter(|field| field.read_access.is_some())
        .map(|field| {
            let key = field.rust_name.as_str();
            quote! {
                if !field_read_allowed(context, #key) {
                    if let serde_json::Value::Object(object) = &mut value {
                        object.remove(#key);
                    }
                }
            }
        });
    let create_guards = write_guards(entity, false)?;
    let update_guards = write_guards(entity, true)?;
    Ok(quote! {
        #[allow(dead_code, unused_variables, unused_mut)]
        fn field_read_allowed(context: &RequestContext, field: &str) -> bool {
            match field {
                #(#read_arms,)*
                _ => true,
            }
        }

        #[allow(dead_code, unused_variables, unused_mut)]
        fn field_write_allowed(context: &RequestContext, field: &str) -> bool {
            match field {
                #(#write_arms,)*
                _ => true,
            }
        }

        #[allow(dead_code, unused_variables, unused_mut)]
        fn redact_model(
            context: &RequestContext,
            model: #module::Model,
        ) -> Result<serde_json::Value, ApiError> {
            let mut value = serde_json::to_value(model).map_err(|_| ApiError::Internal)?;
            #(#read_redactions)*
            Ok(value)
        }

        #[allow(dead_code, unused_variables, unused_mut)]
        fn authorize_create_fields(
            context: &RequestContext,
            input: &CreateInput,
        ) -> Result<(), ApiError> {
            #(#create_guards)*
            Ok(())
        }

        #[allow(dead_code, unused_variables, unused_mut)]
        fn authorize_update_fields(
            context: &RequestContext,
            input: &UpdateInput,
        ) -> Result<(), ApiError> {
            #(#update_guards)*
            Ok(())
        }
    })
}

fn field_access_arms(
    entity: &EntityIr,
    access: impl Fn(&FieldIr) -> Option<&AccessRuleIr>,
) -> Vec<TokenStream> {
    entity
        .fields
        .iter()
        .filter_map(|field| {
            access(field).map(|rule| {
                let name = &field.rust_name;
                let allowed = super::access::operation_allowed(rule);
                quote! { #name => #allowed }
            })
        })
        .collect::<Vec<_>>()
}

fn write_guards(entity: &EntityIr, update: bool) -> Result<Vec<TokenStream>, CodegenError> {
    entity
        .fields
        .iter()
        .filter(|field| {
            field.write_access.is_some()
                && field.generated.is_none()
                && (!update || !field.primary_key)
        })
        .map(|field| {
            let name = parse_ident(&field.rust_name)?;
            let key = field.rust_name.as_str();
            let check = quote! {
                if !field_write_allowed(context, #key) {
                    return Err(access_denied(context));
                }
            };
            if update || field.nullable || field.default.is_some() {
                Ok(quote! { if input.#name.is_some() { #check } })
            } else {
                Ok(check)
            }
        })
        .collect()
}

fn validation_functions(entity: &EntityIr) -> Result<TokenStream, CodegenError> {
    let create_rules = validation_rules(entity, false)?;
    let update_rules = validation_rules(entity, true)?;
    Ok(quote! {
        #[allow(unused_mut, unused_variables)]
        fn validate_create(input: &CreateInput) -> Result<(), ApiError> {
            let mut violations = Vec::new();
            #(#create_rules)*
            finish_validation(violations)
        }

        #[allow(unused_mut, unused_variables)]
        fn validate_update(input: &UpdateInput) -> Result<(), ApiError> {
            let mut violations = Vec::new();
            #(#update_rules)*
            finish_validation(violations)
        }

        fn finish_validation(violations: Vec<FieldViolation>) -> Result<(), ApiError> {
            if violations.is_empty() { Ok(()) } else { Err(ApiError::Validation(violations)) }
        }

        fn access_denied(context: &RequestContext) -> ApiError {
            if context.actor().is_some() { ApiError::Forbidden } else { ApiError::Unauthorized }
        }
    })
}

fn dto_fields(entity: &EntityIr, update: bool) -> Result<Vec<TokenStream>, CodegenError> {
    writable_fields(entity, update)
        .map(|field| dto_field(field, update))
        .collect()
}

fn dto_field(field: &FieldIr, update: bool) -> Result<TokenStream, CodegenError> {
    let name = parse_ident(&field.rust_name)?;
    let mut ty = rust_type(&field.ty);
    if field.nullable {
        ty = quote! { Option<#ty> };
    }
    if update || field.default.is_some() || field.write_access.is_some() {
        ty = quote! { Option<#ty> };
    }
    Ok(quote! { pub #name: #ty })
}

fn create_values(entity: &EntityIr) -> Result<Vec<TokenStream>, CodegenError> {
    entity
        .fields
        .iter()
        .filter_map(|field| create_value(field).transpose())
        .collect()
}

fn create_value(field: &FieldIr) -> Result<Option<TokenStream>, CodegenError> {
    let name = parse_ident(&field.rust_name)?;
    let value = match field.generated {
        Some(GeneratedValueIr::UuidV7) => quote! { uuid::Uuid::now_v7() },
        Some(GeneratedValueIr::Now) if matches!(field.ty, FieldTypeIr::Date) => {
            quote! { chrono::Utc::now().date_naive() }
        }
        Some(GeneratedValueIr::Now) => quote! { chrono::Utc::now() },
        Some(GeneratedValueIr::AutoIncrement) => return Ok(None),
        Some(GeneratedValueIr::Revision) => quote! { 1_i64 },
        Some(GeneratedValueIr::Tenant) => quote! { context.require_tenant()? },
        None => field.default.as_ref().map_or_else(
            || {
                if field.write_access.is_some() && !field.nullable {
                    let field_name = field.api_name.clone();
                    let message = format!("field `{}` is required", field.api_name);
                    quote! {
                        input.#name.ok_or_else(|| ApiError::Validation(vec![FieldViolation {
                            field: #field_name.to_owned(), message: #message.to_owned()
                        }]))?
                    }
                } else {
                    quote! { input.#name }
                }
            },
            |default| {
                let default = default_expression(field, default);
                quote! { input.#name.unwrap_or_else(|| #default) }
            },
        ),
    };
    Ok(Some(quote! { #name: Set(#value) }))
}

fn default_expression(field: &FieldIr, default: &str) -> TokenStream {
    match field.ty {
        FieldTypeIr::String | FieldTypeIr::Text | FieldTypeIr::Enum { .. } => {
            quote! { #default.to_owned() }
        }
        FieldTypeIr::Integer => {
            let value = default
                .parse::<i32>()
                .expect("compiler validated integer default");
            quote! { #value }
        }
        FieldTypeIr::Bigint => {
            let value = default
                .parse::<i64>()
                .expect("compiler validated bigint default");
            quote! { #value }
        }
        FieldTypeIr::Boolean => {
            let value = default
                .parse::<bool>()
                .expect("compiler validated boolean default");
            quote! { #value }
        }
        FieldTypeIr::Decimal => {
            quote! { rust_decimal::Decimal::from_str_exact(#default).expect("validated default") }
        }
        FieldTypeIr::Uuid | FieldTypeIr::Relation { .. } => {
            quote! { uuid::Uuid::parse_str(#default).expect("validated default") }
        }
        FieldTypeIr::Date => {
            quote! { chrono::NaiveDate::parse_from_str(#default, "%Y-%m-%d").expect("validated default") }
        }
        FieldTypeIr::Datetime => {
            quote! { #default.parse::<chrono::DateTime<chrono::Utc>>().expect("validated default") }
        }
        FieldTypeIr::Json => {
            quote! { serde_json::from_str(#default).expect("validated default") }
        }
    }
}

fn update_values(entity: &EntityIr) -> Result<Vec<TokenStream>, CodegenError> {
    writable_fields(entity, true)
        .map(|field| {
            let name = parse_ident(&field.rust_name)?;
            let value = if copy_type(&field.ty) {
                quote! { *value }
            } else {
                quote! { value.clone() }
            };
            Ok(quote! {
                if let Some(value) = &input.#name { active.#name = Set(#value); }
            })
        })
        .collect()
}

fn copy_type(field_type: &FieldTypeIr) -> bool {
    matches!(
        field_type,
        FieldTypeIr::Uuid
            | FieldTypeIr::Integer
            | FieldTypeIr::Bigint
            | FieldTypeIr::Decimal
            | FieldTypeIr::Boolean
            | FieldTypeIr::Date
            | FieldTypeIr::Datetime
            | FieldTypeIr::Relation { .. }
    )
}

fn writable_fields(entity: &EntityIr, update: bool) -> impl Iterator<Item = &FieldIr> {
    entity
        .fields
        .iter()
        .filter(move |field| field.generated.is_none() && (!update || !field.primary_key))
}

fn primary_key(entity: &EntityIr) -> Result<&FieldIr, CodegenError> {
    entity
        .fields
        .iter()
        .find(|field| field.primary_key)
        .ok_or_else(|| CodegenError::new(format!("entity `{}` has no primary key", entity.id)))
}

fn parse_id_expression(field: &FieldIr) -> TokenStream {
    match field.ty {
        FieldTypeIr::Uuid | FieldTypeIr::Relation { .. } => {
            quote! { uuid::Uuid::parse_str(&id).map_err(|_| ApiError::InvalidId)? }
        }
        FieldTypeIr::Integer => quote! { id.parse::<i32>().map_err(|_| ApiError::InvalidId)? },
        FieldTypeIr::Bigint => quote! { id.parse::<i64>().map_err(|_| ApiError::InvalidId)? },
        _ => quote! { id },
    }
}