appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::relation;
use super::{column_ident, filter_keys, filter_rules, primary_key, search_rule};
use crate::CodegenError;
use appstruct_ir::{AppIr, EntityIr, FieldIr, FieldTypeIr};
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::LitStr;

pub fn aggregate_support(
    ir: &AppIr,
    entity: &EntityIr,
    module: &syn::Ident,
    policy: &syn::Ident,
) -> Result<TokenStream, CodegenError> {
    let mut keys = filter_keys(entity);
    keys.extend(relation::filter_keys(ir, entity)?);
    let filter_validation = super::filter_validation(&keys);
    let filters = filter_rules(entity, module)?;
    let relation_filters = relation::filter_rules(ir, entity, module)?;
    let search = search_rule(entity, module)?;
    let access_scope = super::access::scope(entity, module, &entity.access.list)?;
    let metric_arms = metric_arms(entity, module)?;
    let group_arms = group_arms(entity, module)?;
    let handler = aggregate_handler(&AggregateHandlerTokens {
        module,
        policy,
        filter_validation: &filter_validation,
        access_scope: &access_scope,
        filters: &filters,
        relation_filters: &relation_filters,
        search: &search,
        metric_arms: &metric_arms,
        group_arms: &group_arms,
    });
    Ok(quote! {
        use std::collections::BTreeSet;

        #[derive(Debug, Default, Deserialize)]
        pub struct AggregateQuery {
            metrics: Option<String>,
            group_by: Option<String>,
            limit: Option<u64>,
            q: Option<String>,
            #[serde(flatten)]
            filters: BTreeMap<String, String>,
        }

        #[derive(Debug, Serialize)]
        pub struct AggregateMeta {
            metrics: Vec<String>,
            group_by: Vec<String>,
            limit: u64,
        }

        #[derive(Debug, Serialize)]
        pub struct AggregateResponse {
            data: Vec<serde_json::Value>,
            meta: AggregateMeta,
        }

        #handler
    })
}

struct AggregateHandlerTokens<'a> {
    module: &'a syn::Ident,
    policy: &'a syn::Ident,
    filter_validation: &'a TokenStream,
    access_scope: &'a TokenStream,
    filters: &'a [TokenStream],
    relation_filters: &'a [TokenStream],
    search: &'a TokenStream,
    metric_arms: &'a [TokenStream],
    group_arms: &'a [TokenStream],
}

fn aggregate_handler(tokens: &AggregateHandlerTokens<'_>) -> TokenStream {
    let AggregateHandlerTokens {
        module,
        policy,
        filter_validation,
        access_scope,
        filters,
        relation_filters,
        search,
        metric_arms,
        group_arms,
    } = tokens;
    quote! {
        async fn aggregate(
            State(state): State<AppState>,
            headers: HeaderMap,
            axum::extract::Query(query): axum::extract::Query<AggregateQuery>,
        ) -> Result<Json<AggregateResponse>, ApiError> {
            let context = state.context(&headers).await?;
            if !state.extensions.#policy().can_list(&context).await? {
                return Err(access_denied(&context));
            }
            #filter_validation
            let limit = query.limit.unwrap_or(100);
            if !(1..=500).contains(&limit) {
                return Err(ApiError::InvalidQuery(
                    "`limit` must be between 1 and 500".to_owned()
                ));
            }
            let metrics = query
                .metrics
                .as_deref()
                .unwrap_or("count")
                .split(',')
                .map(str::trim)
                .filter(|metric| !metric.is_empty())
                .collect::<Vec<_>>();
            if metrics.is_empty() {
                return Err(ApiError::InvalidQuery(
                    "at least one aggregate metric is required".to_owned()
                ));
            }
            let mut selected_metrics = BTreeSet::new();
            let mut select = #module::Entity::find();
            #access_scope
            #(#filters)*
            #(#relation_filters)*
            #search
            let mut select = select.select_only();
            for metric in &metrics {
                if !selected_metrics.insert(*metric) {
                    return Err(ApiError::InvalidQuery(format!("duplicate aggregate metric `{metric}`")));
                }
                match *metric {
                    #(#metric_arms,)*
                    _ => return Err(ApiError::InvalidQuery(format!("aggregate metric `{metric}` is not allowed"))),
                }
            }
            let group_by = query
                .group_by
                .as_deref()
                .unwrap_or("")
                .split(',')
                .map(str::trim)
                .filter(|field| !field.is_empty())
                .collect::<Vec<_>>();
            let mut selected_groups = BTreeSet::new();
            for field in &group_by {
                if !selected_groups.insert(*field) {
                    return Err(ApiError::InvalidQuery(format!("duplicate group field `{field}`")));
                }
                match *field {
                    #(#group_arms,)*
                    _ => return Err(ApiError::InvalidQuery(format!("group field `{field}` is not allowed"))),
                }
            }
            let data = select
                .limit(limit)
                .into_json()
                .all(&state.database)
                .await?;
            Ok(Json(AggregateResponse {
                data,
                meta: AggregateMeta {
                    metrics: metrics.into_iter().map(str::to_owned).collect(),
                    group_by: group_by.into_iter().map(str::to_owned).collect(),
                    limit,
                },
            }))
        }
    }
}

fn metric_arms(entity: &EntityIr, module: &syn::Ident) -> Result<Vec<TokenStream>, CodegenError> {
    let primary = column_ident(primary_key(entity)?)?;
    let mut arms = vec![quote! {
        "count" | "count:*" => {
            select = select.column_as(#module::Column::#primary.count(), "count");
        }
    }];
    for field in aggregate_fields(entity) {
        let column = column_ident(field)?;
        let field_name = LitStr::new(&field.rust_name, Span::call_site());
        let read_guard = quote! {
            if !field_read_allowed(&context, #field_name) {
                return Err(access_denied(&context));
            }
        };
        let sum_name = LitStr::new(&format!("sum:{}", field.rust_name), Span::call_site());
        let avg_name = LitStr::new(&format!("avg:{}", field.rust_name), Span::call_site());
        let min_name = LitStr::new(&format!("min:{}", field.rust_name), Span::call_site());
        let max_name = LitStr::new(&format!("max:{}", field.rust_name), Span::call_site());
        let sum_alias = LitStr::new(&format!("sum_{}", field.rust_name), Span::call_site());
        let avg_alias = LitStr::new(&format!("avg_{}", field.rust_name), Span::call_site());
        let min_alias = LitStr::new(&format!("min_{}", field.rust_name), Span::call_site());
        let max_alias = LitStr::new(&format!("max_{}", field.rust_name), Span::call_site());
        if supports_sum_avg(&field.ty) {
            arms.push(quote! {
                #sum_name => {
                    #read_guard
                    select = select.column_as(#module::Column::#column.sum(), #sum_alias);
                },
                #avg_name => {
                    #read_guard
                    select = select.column_as(#module::Column::#column.avg(), #avg_alias);
                }
            });
        }
        if supports_min_max(&field.ty) {
            arms.push(quote! {
                #min_name => {
                    #read_guard
                    select = select.column_as(#module::Column::#column.min(), #min_alias);
                },
                #max_name => {
                    #read_guard
                    select = select.column_as(#module::Column::#column.max(), #max_alias);
                }
            });
        }
    }
    Ok(arms)
}

fn group_arms(entity: &EntityIr, module: &syn::Ident) -> Result<Vec<TokenStream>, CodegenError> {
    entity
        .fields
        .iter()
        .filter(|field| field.capabilities.filterable && groupable(&field.ty))
        .map(|field| {
            let name = LitStr::new(&field.rust_name, Span::call_site());
            let column = column_ident(field)?;
            let alias = LitStr::new(&format!("group_{}", field.rust_name), Span::call_site());
            Ok(quote! {
                #name => {
                    if !field_read_allowed(&context, #name) {
                        return Err(access_denied(&context));
                    }
                    select = select
                        .column_as(#module::Column::#column, #alias)
                        .group_by(#module::Column::#column);
                }
            })
        })
        .collect()
}

fn aggregate_fields(entity: &EntityIr) -> impl Iterator<Item = &FieldIr> {
    entity.fields.iter().filter(|field| {
        field.capabilities.filterable
            && !field.primary_key
            && !matches!(field.ty, FieldTypeIr::Relation { .. } | FieldTypeIr::Json)
            && (supports_sum_avg(&field.ty) || supports_min_max(&field.ty))
    })
}

fn supports_sum_avg(field_type: &FieldTypeIr) -> bool {
    matches!(
        field_type,
        FieldTypeIr::Integer | FieldTypeIr::Bigint | FieldTypeIr::Decimal
    )
}

fn supports_min_max(field_type: &FieldTypeIr) -> bool {
    matches!(
        field_type,
        FieldTypeIr::Integer
            | FieldTypeIr::Bigint
            | FieldTypeIr::Decimal
            | FieldTypeIr::String
            | FieldTypeIr::Enum { .. }
            | FieldTypeIr::Date
            | FieldTypeIr::Datetime
    )
}

fn groupable(field_type: &FieldTypeIr) -> bool {
    !matches!(field_type, FieldTypeIr::Json | FieldTypeIr::Relation { .. })
}