appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::super::parse_ident;
use crate::CodegenError;
use appstruct_ir::{AccessRuleIr, EntityIr, FieldIr};
use proc_macro2::TokenStream;
use quote::quote;

pub(super) fn 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::super::access::operation_allowed(rule);
                quote! { #name => #allowed }
            })
        })
        .collect()
}

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()
                && !entity.is_workflow_field(field)
                && (!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()
}