appstruct-codegen 0.2.0

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

pub(in crate::backend) fn support(
    entity: &EntityIr,
    module: &syn::Ident,
    policy: &syn::Ident,
) -> Result<TokenStream, CodegenError> {
    let arms = entity.fields.iter().filter(|field| field.capabilities.filterable && !matches!(field.ty, FieldTypeIr::Json)).map(|field| {
        let name = &field.rust_name;
        let column = super::helpers::column_ident(field)?;
        let template = if matches!(field.ty, FieldTypeIr::Bigint | FieldTypeIr::Decimal) { "to_jsonb($1::text)" } else { "to_jsonb($1)" };
        Ok(quote! { #name => select.select_only()
            .column_as(sea_query::Expr::cust_with_exprs(#template, [sea_query::SimpleExpr::from(#module::Column::#column)]), "value")
            .column_as(sea_query::Expr::cust("count(*)"), "count")
            .group_by(#module::Column::#column)
            .order_by_desc(sea_query::Expr::cust("count(*)"))
            .order_by_asc(#module::Column::#column)
        })
    }).collect::<Result<Vec<_>, CodegenError>>()?;
    if arms.is_empty() {
        return Ok(quote! {
            async fn facets(State(state): State<AppState>, headers: HeaderMap, axum::extract::Query(_query): axum::extract::Query<ListQuery>) -> Result<Json<serde_json::Value>, ApiError> {
                let context = state.context(&headers).await?;
                if !state.extensions.#policy().can_list(&context).await? { return Err(access_denied(&context)); }
                Err(ApiError::InvalidQuery("this resource has no facet fields".to_owned()))
            }
        });
    }
    Ok(quote! {
        #[derive(Debug, Default, Deserialize)]
        struct FacetQuery {
            facet: Option<String>, limit: Option<u64>, q: Option<String>,
            #[serde(rename = "where")] expression: Option<String>,
            #[serde(flatten)] filters: BTreeMap<String, String>,
        }
        async fn facets(State(state): State<AppState>, headers: HeaderMap, axum::extract::Query(query): axum::extract::Query<FacetQuery>) -> Result<Json<serde_json::Value>, ApiError> {
            let context = state.context(&headers).await?;
            if !state.extensions.#policy().can_list(&context).await? { return Err(access_denied(&context)); }
            let names = query.facet.as_deref().unwrap_or("").split(',').collect::<Vec<_>>();
            let limit = query.limit.unwrap_or(10);
            if names.is_empty() || names.len() > 5 || names.iter().any(|name| name.is_empty()) || !(1..=20).contains(&limit) {
                return Err(ApiError::InvalidQuery("facets require 1 to 5 fields and limit between 1 and 20".to_owned()));
            }
            let filters = ListQuery { q: query.q, expression: query.expression, filters: query.filters, ..Default::default() };
            let select = filtered_select(&context, &filters)?;
            let transaction = state.database.begin().await?;
            transaction.execute_unprepared("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY").await?;
            let total = select.count(&transaction).await?;
            let mut data = serde_json::Map::new();
            for name in names {
                if data.contains_key(name) { return Err(ApiError::InvalidQuery("duplicate facet field".to_owned())); }
                if !field_read_allowed(&context, name) { return Err(access_denied(&context)); }
                let select = select.clone();
                let facet: crate::database::Select<#module::Model> = match name { #(#arms,)* _ => return Err(ApiError::InvalidQuery(format!("field `{name}` cannot be used as a facet"))) };
                let buckets = facet.limit(limit).into_json().all(&transaction).await?;
                let included = buckets.iter().map(|bucket| bucket["count"].as_u64().unwrap_or(0)).sum::<u64>();
                data.insert(name.to_owned(), serde_json::json!({ "buckets": buckets, "other_count": total.saturating_sub(included) }));
            }
            transaction.rollback().await?;
            Ok(Json(serde_json::json!({ "data": data })))
        }
    })
}