appstruct-compiler 0.2.0

Parser, validator, and typed IR compiler for AppStruct application specifications
Documentation
use super::super::surface::SurfaceEntity;
use appstruct_ir::{Diagnostic, EntityId, FieldIr, FieldTypeIr, SeedIr};
use std::collections::BTreeMap;

pub(super) fn build_seeds(
    entity: &SurfaceEntity,
    entity_id: &EntityId,
    fields: &[FieldIr],
    diagnostics: &mut Vec<Diagnostic>,
) -> Vec<SeedIr> {
    entity
        .seeds
        .iter()
        .filter_map(|seed| {
            if !appstruct_core::is_sql_name(&seed.name.value) {
                diagnostics.push(Diagnostic::error(
                    "AS2060",
                    format!("invalid seed name `{}`", seed.name.value),
                    seed.name.span.clone(),
                ));
                return None;
            }
            let mut values = BTreeMap::new();
            let mut valid = true;
            for (field, value) in &seed.values {
                let Some(found) = fields.iter().find(|candidate| {
                    candidate.api_name == field.value || candidate.rust_name == field.value
                }) else {
                    diagnostics.push(Diagnostic::error(
                        "AS2061",
                        format!(
                            "seed `{}` references unknown field `{}`",
                            seed.name.value, field.value
                        ),
                        field.span.clone(),
                    ));
                    valid = false;
                    continue;
                };
                if !value_is_valid(&value.value, &found.ty) {
                    diagnostics.push(Diagnostic::error(
                        "AS2064",
                        format!(
                            "seed `{}` has an invalid value for field `{}`",
                            seed.name.value, field.value
                        ),
                        value.span.clone(),
                    ));
                    valid = false;
                    continue;
                }
                values.insert(found.api_name.clone(), value.value.clone());
            }
            if let Some(key) = fields.iter().find(|field| field.primary_key)
                && !values.contains_key(&key.api_name)
            {
                diagnostics.push(Diagnostic::error(
                    "AS2062",
                    format!(
                        "seed `{}` must provide primary-key field `{}`",
                        seed.name.value, key.api_name
                    ),
                    seed.span.clone(),
                ));
                valid = false;
            }
            for field in fields.iter().filter(|field| {
                !field.nullable && field.generated.is_none() && field.default.is_none()
            }) {
                if !values.contains_key(&field.api_name) {
                    diagnostics.push(Diagnostic::error(
                        "AS2063",
                        format!(
                            "seed `{}` is missing required field `{}`",
                            seed.name.value, field.api_name
                        ),
                        seed.span.clone(),
                    ));
                    valid = false;
                }
            }
            if !valid || values.is_empty() {
                return None;
            }
            Some(SeedIr {
                id: format!("app::{}::{}", entity.name.value, seed.name.value),
                entity: entity_id.clone(),
                values,
            })
        })
        .collect()
}

fn value_is_valid(value: &str, ty: &FieldTypeIr) -> bool {
    match ty {
        FieldTypeIr::Integer => value.parse::<i32>().is_ok(),
        FieldTypeIr::Bigint => value.parse::<i64>().is_ok(),
        FieldTypeIr::Decimal => value.parse::<f64>().is_ok_and(f64::is_finite),
        FieldTypeIr::Boolean => matches!(value, "true" | "false"),
        FieldTypeIr::Enum { values } => values.iter().any(|candidate| candidate == value),
        _ => true,
    }
}