appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::{column_ident, parsed_value, primary_key, supports_range};
use crate::CodegenError;
use crate::backend::{access, find_entity, module_name, parse_ident};
use appstruct_ir::{AppIr, EntityIr, FieldIr, FieldTypeIr};
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::LitStr;

pub(super) fn filter_rules(
    ir: &AppIr,
    entity: &EntityIr,
    module: &syn::Ident,
) -> Result<Vec<TokenStream>, CodegenError> {
    let mut rules = Vec::new();
    for relation_field in relation_fields(entity) {
        let FieldTypeIr::Relation { target } = &relation_field.ty else {
            continue;
        };
        let target = find_entity(ir, &target.0)?;
        let target_module = parse_ident(&module_name(target))?;
        let source_column = column_ident(relation_field)?;
        let target_primary = column_ident(primary_key(target)?)?;
        let target_scope = access::related_scope(target, &target_module, &target.access.list)?;
        for target_field in filterable_fields(target) {
            let source_allowed = read_allowed(relation_field);
            let target_allowed = read_allowed(target_field);
            let filter_allowed = quote! { (#source_allowed) && (#target_allowed) };
            let target_column = column_ident(target_field)?;
            let exact_key = LitStr::new(
                &format!(
                    "filter[{}.{}]",
                    relation_field.api_name, target_field.rust_name
                ),
                Span::call_site(),
            );
            let value = parsed_value(target_field, &quote! { raw });
            rules.push(quote! {
                if let Some(raw) = query.filters.get(#exact_key) {
                    if !(#filter_allowed) {
                        return Err(access_denied(&context));
                    }
                    use crate::entities::#target_module;
                    let value = #value;
                    let mut relation_select = #target_module::select()
                        .select_only()
                        .column(#target_module::Column::#target_primary);
                    #target_scope
                    relation_select = relation_select
                        .filter(#target_module::Column::#target_column.eq(value));
                    select = select.filter(
                        #module::Column::#source_column.in_subquery(relation_select.into_query())
                    );
                }
            });
            rules.extend(range_rules(&RangeRuleTokens {
                relation_field,
                target_field,
                module,
                target_module: &target_module,
                source_column: &source_column,
                target_primary: &target_primary,
                target_column: &target_column,
                target_scope: &target_scope,
                filter_allowed: &filter_allowed,
            })?);
        }
    }
    Ok(rules)
}

struct RangeRuleTokens<'a> {
    relation_field: &'a appstruct_ir::FieldIr,
    target_field: &'a appstruct_ir::FieldIr,
    module: &'a syn::Ident,
    target_module: &'a syn::Ident,
    source_column: &'a syn::Ident,
    target_primary: &'a syn::Ident,
    target_column: &'a syn::Ident,
    target_scope: &'a TokenStream,
    filter_allowed: &'a TokenStream,
}

fn range_rules(tokens: &RangeRuleTokens<'_>) -> Result<Vec<TokenStream>, CodegenError> {
    let RangeRuleTokens {
        relation_field,
        target_field,
        module,
        target_module,
        source_column,
        target_primary,
        target_column,
        target_scope,
        filter_allowed,
    } = tokens;
    if !supports_range(&target_field.ty) {
        return Ok(Vec::new());
    }
    [("gte", "gte"), ("lte", "lte")]
        .into_iter()
        .map(|(operator, method)| {
            let key = LitStr::new(
                &format!(
                    "filter[{}.{}][{operator}]",
                    relation_field.api_name, target_field.rust_name
                ),
                Span::call_site(),
            );
            let method = parse_ident(method)?;
            let value = parsed_value(target_field, &quote! { raw });
            Ok(quote! {
                if let Some(raw) = query.filters.get(#key) {
                    if !(#filter_allowed) {
                        return Err(access_denied(&context));
                    }
                    use crate::entities::#target_module;
                    let value = #value;
                    let mut relation_select = #target_module::select()
                        .select_only()
                        .column(#target_module::Column::#target_primary);
                    #target_scope
                    relation_select = relation_select
                        .filter(#target_module::Column::#target_column.#method(value));
                    select = select.filter(
                        #module::Column::#source_column
                            .in_subquery(relation_select.into_query())
                    );
                }
            })
        })
        .collect()
}

pub(super) fn filter_keys(ir: &AppIr, entity: &EntityIr) -> Result<Vec<LitStr>, CodegenError> {
    let mut keys = Vec::new();
    for relation_field in relation_fields(entity) {
        let FieldTypeIr::Relation { target } = &relation_field.ty else {
            continue;
        };
        let target = find_entity(ir, &target.0)?;
        for target_field in filterable_fields(target) {
            keys.push(LitStr::new(
                &format!(
                    "filter[{}.{}]",
                    relation_field.api_name, target_field.rust_name
                ),
                Span::call_site(),
            ));
            if supports_range(&target_field.ty) {
                for operator in ["gte", "lte"] {
                    keys.push(LitStr::new(
                        &format!(
                            "filter[{}.{}][{operator}]",
                            relation_field.api_name, target_field.rust_name
                        ),
                        Span::call_site(),
                    ));
                }
            }
        }
    }
    Ok(keys)
}

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

fn filterable_fields(entity: &EntityIr) -> impl Iterator<Item = &appstruct_ir::FieldIr> {
    entity
        .fields
        .iter()
        .filter(|field| field.capabilities.filterable)
}

pub(super) fn read_allowed(field: &FieldIr) -> TokenStream {
    field
        .read_access
        .as_ref()
        .map_or_else(|| quote! { true }, access::operation_allowed)
}