appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::super::super::{access, module_name, parse_ident};
use crate::CodegenError;
use appstruct_ir::{AggregateIr, AppIr, EntityIr};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};

#[allow(clippy::too_many_lines)]
pub(super) fn support(
    ir: &AppIr,
    parent: &EntityIr,
    aggregate: &AggregateIr,
) -> Result<(TokenStream, TokenStream), CodegenError> {
    let module = parse_ident(&module_name(parent))?;
    let policy = format_ident!("{}_policy", module_name(parent));
    let child = ir
        .entities
        .iter()
        .find(|entity| entity.id == aggregate.child)
        .expect("validated child");
    let child_module = parse_ident(&module_name(child))?;
    let child_primary = parse_ident(&super::super::primary_key(child)?.rust_name)?;
    let primary = parse_ident(&super::super::primary_key(parent)?.rust_name)?;
    let read = format_ident!("read_aggregate_{}", aggregate.name);
    let write = format_ident!("write_aggregate_{}", aggregate.name);
    let path = format!("/{{id}}/_aggregates/{}", aggregate.name);
    let limit = u64::from(aggregate.max_items);
    let scope = access::member_scope(parent, &module, &parent.access.read)?;
    let allowed = access::update_allowed(parent, &parent.access.update)?;
    let guard = parent.workflow_field().map(|field| {
        let field = parse_ident(&field.rust_name).expect("validated field");
        let states = &aggregate.states;
        quote! { if ![#(#states),*].contains(&before.#field.as_str()) { return Err(ApiError::InvalidWorkflowState); } }
    });
    let event = format!("{}.aggregate.{}", module_name(parent), aggregate.name);
    let entity_id = &parent.id.0;
    let audit = parent.audit_enabled.then(|| quote! {
        crate::audit::record(&transaction, &context, #entity_id, after.#primary.to_string(), #event, Some(&before), Some(&after)).await?;
    });
    let activity = ir.activity.resource_for_entity(&parent.id).map(|resource| {
        let resource = &resource.resource;
        quote! { crate::activity::record_system_event(&transaction, &context, #resource, after.#primary.to_string(), #event).await?; }
    });
    let tokens = quote! {
        async fn #read(State(state): State<AppState>, Path(id): Path<uuid::Uuid>, headers: HeaderMap) -> Result<([(header::HeaderName, String); 1], Json<serde_json::Value>), ApiError> {
            let request = state.context(&headers).await?;
            let transaction = state.database.begin().await?;
            let context = RequestContext::transaction_with_file(&transaction, &state.mail, &state.file, &state.realtime, request.actor().cloned(), request.tenant());
            #scope
            let parent = #module::select_by_id(id).filter(access_condition).lock_shared().one(&transaction).await?.ok_or(ApiError::NotFound)?;
            if !state.extensions.#policy().can_read(&context, &parent).await? { return Err(ApiError::NotFound); }
            let rows = super::#child_module::aggregate_rows::collection(&state, &context, id, #limit).await?;
            let etag = etag_header(&parent);
            let response = serde_json::json!({ "parent": redact_model(&context, parent)?, "rows": rows, "created": {} });
            transaction.commit().await?;
            Ok((etag, Json(response)))
        }
        async fn #write(State(state): State<AppState>, Path(id): Path<uuid::Uuid>, headers: HeaderMap, Json(mut input): Json<super::#child_module::aggregate_rows::Batch>) -> Result<([(header::HeaderName, String); 1], Json<serde_json::Value>), ApiError> {
            use super::#child_module::aggregate_rows as rows;
            let expected = expected_revision(&headers)?;
            let request = state.mutation_context(&headers).await?;
            input.validate(#limit as usize)?;
            let transaction = state.database.begin().await?;
            let mut events = Vec::new();
            let (after, response) = {
                let context = RequestContext::transaction_with_file(&transaction, &state.mail, &state.file, &state.realtime, request.actor().cloned(), request.tenant());
                #scope
                let before = #module::select_by_id(id).filter(access_condition).lock_exclusive().one(&transaction).await?.ok_or(ApiError::NotFound)?;
                if !state.extensions.#policy().can_read(&context, &before).await? { return Err(ApiError::NotFound); }
                if before.revision != expected { return Err(ApiError::ConcurrentModification); }
                #guard
                let mut active = before.clone();
                active.revision = before.revision.checked_add(1).ok_or(ApiError::Internal)?;
                let candidate = active.clone();
                if !(#allowed) || !state.extensions.#policy().can_update(&context, &before, &UpdateInput::default(), &candidate).await? {
                    return Err(access_denied(&context));
                }
                let mut created = BTreeMap::new();
                for row in input.deletes {
                    let path = format!("deletes.{}", row.id);
                    let model = rows::delete(&state, &context, id, row).await.map_err(|error| rows::row_error(error, &path))?;
                    events.push((crate::HookOperation::Delete, model));
                }
                for row in input.updates {
                    let path = format!("updates.{}", row.id);
                    let model = rows::update(&state, &context, id, row).await.map_err(|error| rows::row_error(error, &path))?;
                    events.push((crate::HookOperation::Update, model));
                }
                for row in input.creates {
                    let path = format!("creates.{}", row.key);
                    let model = rows::create(&state, &context, id, row.input).await.map_err(|error| rows::row_error(error, &path))?;
                    created.insert(row.key, model.#child_primary.to_string());
                    events.push((crate::HookOperation::Create, model));
                }
                let collection = rows::collection(&state, &context, id, #limit).await?;
                if !state.extensions.#policy().can_update(&context, &before, &UpdateInput::default(), &candidate).await? { return Err(ApiError::Forbidden); }
                validate_candidate(&active)?;
                let after = active.update(&transaction).await?;
                #audit
                #activity
                let response = serde_json::json!({ "parent": redact_model(&context, after.clone())?, "rows": collection, "created": created });
                (after, response)
            };
            transaction.commit().await?;
            publish_realtime_event(&state, &request, #event, &after);
            run_after_commit(&state, crate::HookOperation::Update, &after, request.actor().cloned(), request.tenant()).await;
            for (operation, model) in events { rows::committed(&state, &request, operation, &model).await; }
            Ok((etag_header(&after), Json(response)))
        }
    };
    Ok((quote! { .route(#path, get(#read).post(#write)) }, tokens))
}