appstruct-codegen 0.1.0

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

pub(super) fn validation_rules(
    entity: &EntityIr,
    update: bool,
) -> Result<Vec<TokenStream>, CodegenError> {
    let mut rules = Vec::new();
    for field in entity
        .fields
        .iter()
        .filter(|field| field.generated.is_none() && (!update || !field.primary_key))
    {
        rules.extend(text_validation(field, update)?);
        rules.extend(enum_validation(field, update)?);
        rules.extend(numeric_validation(field, update)?);
    }
    Ok(rules)
}

fn text_validation(field: &FieldIr, update: bool) -> Result<Vec<TokenStream>, CodegenError> {
    if !matches!(field.ty, FieldTypeIr::String | FieldTypeIr::Text) {
        return Ok(Vec::new());
    }
    let name = parse_ident(&field.rust_name)?;
    let field_name = LitStr::new(&field.api_name, Span::call_site());
    let value = input_value(field, update, &name);
    let mut rules = Vec::new();
    if let Some(limit) = field.validation.min_length {
        let message = LitStr::new(
            &format!("must contain at least {limit} characters"),
            Span::call_site(),
        );
        rules.push(quote! {
            if let Some(value) = #value && value.chars().count() < #limit as usize {
                violations.push(FieldViolation {
                    field: #field_name.to_owned(), message: #message.to_owned()
                });
            }
        });
    }
    if let Some(limit) = field.validation.max_length {
        let message = LitStr::new(
            &format!("must contain at most {limit} characters"),
            Span::call_site(),
        );
        rules.push(quote! {
            if let Some(value) = #value && value.chars().count() > #limit as usize {
                violations.push(FieldViolation {
                    field: #field_name.to_owned(), message: #message.to_owned()
                });
            }
        });
    }
    Ok(rules)
}

fn enum_validation(field: &FieldIr, update: bool) -> Result<Vec<TokenStream>, CodegenError> {
    let FieldTypeIr::Enum { values } = &field.ty else {
        return Ok(Vec::new());
    };
    let name = parse_ident(&field.rust_name)?;
    let field_name = LitStr::new(&field.api_name, Span::call_site());
    let value = input_value(field, update, &name);
    let allowed = values
        .iter()
        .map(|value| LitStr::new(value, Span::call_site()))
        .collect::<Vec<_>>();
    Ok(vec![quote! {
        if let Some(value) = #value && ![#(#allowed),*].contains(&value.as_str()) {
            violations.push(FieldViolation {
                field: #field_name.to_owned(),
                message: "must be one of the configured enum values".to_owned(),
            });
        }
    }])
}

fn numeric_validation(field: &FieldIr, update: bool) -> Result<Vec<TokenStream>, CodegenError> {
    if !matches!(
        field.ty,
        FieldTypeIr::Integer | FieldTypeIr::Bigint | FieldTypeIr::Decimal
    ) {
        return Ok(Vec::new());
    }
    let name = parse_ident(&field.rust_name)?;
    let field_name = LitStr::new(&field.api_name, Span::call_site());
    let value = input_value(field, update, &name);
    let mut rules = Vec::new();
    if let Some(minimum) = &field.validation.minimum {
        let bound = numeric_bound(field, minimum);
        let message = LitStr::new(&format!("must be at least {minimum}"), Span::call_site());
        rules.push(quote! {
            if let Some(value) = #value && value < &#bound {
                violations.push(FieldViolation {
                    field: #field_name.to_owned(), message: #message.to_owned()
                });
            }
        });
    }
    if let Some(maximum) = &field.validation.maximum {
        let bound = numeric_bound(field, maximum);
        let message = LitStr::new(&format!("must be at most {maximum}"), Span::call_site());
        rules.push(quote! {
            if let Some(value) = #value && value > &#bound {
                violations.push(FieldViolation {
                    field: #field_name.to_owned(), message: #message.to_owned()
                });
            }
        });
    }
    Ok(rules)
}

fn input_value(field: &FieldIr, update: bool, name: &syn::Ident) -> TokenStream {
    if update && field.nullable {
        quote! { input.#name.as_ref().and_then(Option::as_ref) }
    } else if update || field.nullable || field.default.is_some() {
        quote! { input.#name.as_ref() }
    } else {
        quote! { Some(&input.#name) }
    }
}

fn numeric_bound(field: &FieldIr, value: &str) -> TokenStream {
    match field.ty {
        FieldTypeIr::Integer => {
            let value = value.parse::<i32>().expect("compiler validated bound");
            quote! { #value }
        }
        FieldTypeIr::Bigint => {
            let value = value.parse::<i64>().expect("compiler validated bound");
            quote! { #value }
        }
        FieldTypeIr::Decimal => {
            quote! { rust_decimal::Decimal::from_str_exact(#value).expect("validated bound") }
        }
        _ => unreachable!(),
    }
}