appstruct-codegen 0.2.0

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

pub(super) struct HandlerContext<'context> {
    pub module: &'context Ident,
    pub hooks: &'context Ident,
    pub policy: &'context Ident,
    pub parse_id: &'context TokenStream,
    pub primary: &'context Ident,
    pub soft_delete: bool,
    pub activity_resource: Option<&'context str>,
}

pub(super) fn handlers(
    entity: &EntityIr,
    context: &HandlerContext<'_>,
    create_values: &[TokenStream],
    active_default: Option<&TokenStream>,
    updates: &[TokenStream],
) -> Result<TokenStream, CodegenError> {
    let HandlerContext {
        module,
        hooks,
        policy,
        parse_id,
        primary,
        soft_delete,
        activity_resource,
    } = context;
    let read_scope = access::member_scope(entity, module, &entity.access.read)?;
    let create_allowed = access::create_allowed(entity, &entity.access.create)?;
    let update_allowed = access::update_allowed(entity, &entity.access.update)?;
    let delete_allowed = access::row_allowed(entity, &entity.access.delete)?;
    let event_prefix = module_name(entity);
    let resource = Literal::string(&entity.table_name);
    let create_event = Literal::string(&format!("{event_prefix}.created"));
    let update_event = Literal::string(&format!("{event_prefix}.updated"));
    let delete_event = Literal::string(&format!("{event_prefix}.deleted"));
    let read = read_handler(module, policy, parse_id, &read_scope);
    let create_audit = audit_event(entity, primary, "create");
    let update_audit = audit_event(entity, primary, "update");
    let delete_audit = audit_event(entity, primary, "delete");
    let create_activity = super::activity::write_event(*activity_resource, primary, "created");
    let update_activity = super::activity::write_event(*activity_resource, primary, "updated");
    let delete_activity = super::activity::write_event(*activity_resource, primary, "deleted");
    let create = create_handler(
        module,
        hooks,
        policy,
        create_values,
        active_default,
        &create_allowed,
        &create_audit,
        &create_activity,
        &create_event,
    );
    let update = update_handler(
        context,
        updates,
        &read_scope,
        &update_allowed,
        &update_audit,
        &update_activity,
        &update_event,
    );
    let delete = delete_handler(
        module,
        hooks,
        policy,
        parse_id,
        &read_scope,
        &delete_allowed,
        &delete_audit,
        &delete_activity,
        *soft_delete,
        &delete_event,
    );
    let helpers = helper_functions(module, hooks, primary, &resource);
    Ok(quote! {
        #read
        #create
        #update
        #delete
        #helpers
    })
}

fn read_handler(
    module: &Ident,
    policy: &Ident,
    parse_id: &TokenStream,
    read_scope: &TokenStream,
) -> TokenStream {
    quote! {
        async fn read(
            State(state): State<AppState>,
            Path(id): Path<String>,
            headers: HeaderMap,
        ) -> Result<([(header::HeaderName, String); 1], Json<serde_json::Value>), ApiError> {
            let context = state.context(&headers).await?;
            let id = #parse_id;
            #read_scope
            let model = #module::select_by_id(id)
                .filter(access_condition)
                .one(&state.database).await?.ok_or(ApiError::NotFound)?;
            if !state.extensions.#policy().can_read(&context, &model).await? {
                return Err(ApiError::NotFound);
            }
            Ok((etag_header(&model), Json(redact_model(&context, model)?)))
        }
    }
}

#[allow(clippy::too_many_arguments)]
fn create_handler(
    module: &Ident,
    hooks: &Ident,
    policy: &Ident,
    create_values: &[TokenStream],
    active_default: Option<&TokenStream>,
    create_allowed: &TokenStream,
    audit: &TokenStream,
    activity: &TokenStream,
    event: &Literal,
) -> TokenStream {
    quote! {
        async fn create(
            State(state): State<AppState>,
            headers: HeaderMap,
            Json(mut input): Json<CreateInput>,
        ) -> Result<(StatusCode, [(header::HeaderName, String); 1], Json<serde_json::Value>), ApiError> {
            let context = state.mutation_context(&headers).await?;
            let actor = context.actor().cloned();
            let tenant = context.tenant();
            authorize_create_fields(&context, &input)?;
            state.extensions.#hooks().before_validate_create(&context, &mut input).await?;
            validate_create(&input)?;
            let transaction = state.database.begin().await?;
            let model = {
                let context = RequestContext::transaction_with_file(
                    &transaction, &state.mail, &state.file, &state.realtime, actor.clone(), tenant,
                );
                state.extensions.#hooks().before_create(&context, &mut input).await?;
                authorize_create_fields(&context, &input)?;
                validate_create(&input)?;
                if !(#create_allowed) {
                    return Err(access_denied(&context));
                }
                if !state.extensions.#policy().can_create(&context, &input).await? {
                    return Err(ApiError::Forbidden);
                }
                let active = #module::Model { #(#create_values,)* #active_default };
                validate_candidate(&active)?;
                let model = active.insert(&transaction).await?;
                state.extensions.#hooks().after_create(&context, &model).await?;
                #audit
                #activity
                model
            };
            transaction.commit().await?;
            publish_realtime_event(&state, &context, #event, &model);
            run_after_commit(&state, crate::HookOperation::Create, &model, actor, tenant).await;
            Ok((StatusCode::CREATED, etag_header(&model), Json(redact_model(&context, model)?)))
        }
    }
}

fn update_handler(
    context: &HandlerContext<'_>,
    updates: &[TokenStream],
    read_scope: &TokenStream,
    update_allowed: &TokenStream,
    audit: &TokenStream,
    activity: &TokenStream,
    event: &Literal,
) -> TokenStream {
    let HandlerContext {
        module,
        hooks,
        policy,
        parse_id,
        ..
    } = context;
    quote! {
        async fn update(
            State(state): State<AppState>,
            Path(id): Path<String>,
            headers: HeaderMap,
            Json(mut input): Json<UpdateInput>,
        ) -> Result<([(header::HeaderName, String); 1], Json<serde_json::Value>), ApiError> {
            let expected = expected_revision(&headers)?;
            let context = state.mutation_context(&headers).await?;
            let actor = context.actor().cloned();
            let tenant = context.tenant();
            authorize_update_fields(&context, &input)?;
            state.extensions.#hooks().before_validate_update(&context, &mut input).await?;
            validate_update(&input)?;
            let id = #parse_id;
            let transaction = state.database.begin().await?;
            let after = {
                let context = RequestContext::transaction_with_file(
                    &transaction, &state.mail, &state.file, &state.realtime, actor.clone(), tenant,
                );
                #read_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);
                }
                state.extensions.#hooks().before_update(&context, &before, &mut input).await?;
                authorize_update_fields(&context, &input)?;
                validate_update(&input)?;
                let mut active = before.clone();
                #(#updates)*
                active.revision = before.revision.checked_add(1)
                    .ok_or_else(|| sqlx::Error::Protocol("revision overflow".to_owned()))?;
                let candidate = active.clone();
                if !(#update_allowed) {
                    return Err(access_denied(&context));
                }
                if !state.extensions.#policy()
                    .can_update(&context, &before, &input, &candidate).await?
                {
                    return Err(ApiError::Forbidden);
                }
                validate_candidate(&active)?;
                let after = active.update(&transaction).await?;
                state.extensions.#hooks().after_update(&context, &before, &after).await?;
                #audit
                #activity
                after
            };
            transaction.commit().await?;
            publish_realtime_event(&state, &context, #event, &after);
            run_after_commit(&state, crate::HookOperation::Update, &after, actor, tenant).await;
            Ok((etag_header(&after), Json(redact_model(&context, after)?)))
        }
    }
}

#[allow(clippy::too_many_arguments)]
fn delete_handler(
    module: &Ident,
    hooks: &Ident,
    policy: &Ident,
    parse_id: &TokenStream,
    read_scope: &TokenStream,
    delete_allowed: &TokenStream,
    audit: &TokenStream,
    activity: &TokenStream,
    soft_delete: bool,
    event: &Literal,
) -> TokenStream {
    let delete_model = if soft_delete {
        quote! {
            let mut active = model.clone();
            active.deleted_at = Some(chrono::Utc::now());
            active.revision = model.revision.checked_add(1)
                .ok_or_else(|| sqlx::Error::Protocol("revision overflow".to_owned()))?;
            validate_candidate(&active)?;
            active.update(&transaction).await?
        }
    } else {
        quote! {
            let deleted = model.clone();
            model.delete(&transaction).await?;
            deleted
        }
    };
    quote! {
        async fn delete(
            State(state): State<AppState>,
            Path(id): Path<String>,
            headers: HeaderMap,
        ) -> Result<StatusCode, ApiError> {
            let expected = expected_revision(&headers)?;
            let context = state.mutation_context(&headers).await?;
            let actor = context.actor().cloned();
            let tenant = context.tenant();
            let id = #parse_id;
            let transaction = state.database.begin().await?;
            let deleted = {
                let context = RequestContext::transaction_with_file(
                    &transaction, &state.mail, &state.file, &state.realtime, actor.clone(), tenant,
                );
                #read_scope
                let model = #module::select_by_id(id)
                    .filter(access_condition)
                    .lock_exclusive()
                    .one(&transaction).await?.ok_or(ApiError::NotFound)?;
                if !state.extensions.#policy().can_read(&context, &model).await? {
                    return Err(ApiError::NotFound);
                }
                if model.revision != expected {
                    return Err(ApiError::ConcurrentModification);
                }
                if !(#delete_allowed) {
                    return Err(access_denied(&context));
                }
                if !state.extensions.#policy().can_delete(&context, &model).await? {
                    return Err(ApiError::Forbidden);
                }
                state.extensions.#hooks().before_delete(&context, &model).await?;
                let deleted = { #delete_model };
                state.extensions.#hooks().after_delete(&context, &deleted).await?;
                #audit
                #activity
                deleted
            };
            transaction.commit().await?;
            publish_realtime_event(&state, &context, #event, &deleted);
            run_after_commit(&state, crate::HookOperation::Delete, &deleted, actor, tenant).await;
            Ok(StatusCode::NO_CONTENT)
        }
    }
}

fn audit_event(entity: &EntityIr, primary: &Ident, operation: &str) -> TokenStream {
    if !entity.audit_enabled {
        return TokenStream::new();
    }
    let entity_id = &entity.id.0;
    match operation {
        "create" => quote! {
            crate::audit::record(
                &transaction, &context, #entity_id, model.#primary.to_string(),
                "create", None, Some(&model),
            ).await?;
        },
        "update" => quote! {
            crate::audit::record(
                &transaction, &context, #entity_id, after.#primary.to_string(),
                "update", Some(&before), Some(&after),
            ).await?;
        },
        "delete" => quote! {
            crate::audit::record(
                &transaction, &context, #entity_id, deleted.#primary.to_string(),
                "delete", Some(&deleted), None,
            ).await?;
        },
        _ => unreachable!(),
    }
}

fn helper_functions(
    module: &Ident,
    hooks: &Ident,
    primary: &Ident,
    resource: &Literal,
) -> TokenStream {
    quote! {
        fn expected_revision(headers: &HeaderMap) -> Result<i64, ApiError> {
            let value = headers.get(header::IF_MATCH).ok_or(ApiError::PreconditionRequired)?;
            let value = value.to_str().map_err(|_| ApiError::InvalidPrecondition)?;
            appstruct_runtime::parse_revision_etag(value)
                .ok_or(ApiError::InvalidPrecondition)
        }

        fn etag_header(model: &#module::Model) -> [(header::HeaderName, String); 1] {
            [(header::ETAG, appstruct_runtime::revision_etag(model.revision))]
        }

        fn publish_realtime_event(
            state: &AppState,
            context: &RequestContext<'_>,
            event: &str,
            model: &#module::Model,
        ) {
            if let Err(error) = state.realtime.publish_resource_model(
                event, #resource, &model.#primary.to_string(), model,
                context.actor().map(|actor| actor.id),
                context.tenant(),
            ) {
                tracing::warn!(?error, event, "realtime event could not be published");
            }
        }

        async fn run_after_commit(
            state: &AppState,
            operation: crate::HookOperation,
            model: &#module::Model,
            actor: Option<crate::Actor>,
            tenant: Option<crate::TenantId>,
        ) {
            let context = RequestContext::connection_with_services(
                &state.database, &state.mail, &state.file, &state.realtime, actor, tenant,
            );
            if let Err(error) = state.extensions.#hooks().after_commit(&context, operation, model).await {
                tracing::error!(?error, ?operation, entity = stringify!(#module), "after_commit hook failed");
            }
        }
    }
}