appstruct-compiler 0.2.0

Parser, validator, and typed IR compiler for AppStruct application specifications
Documentation
use crate::surface::{SurfaceChart, SurfaceEntity};
use appstruct_ir::{
    ChartDimensionIr, ChartIr, ChartKindIr, ChartMeasureIr, Diagnostic, FieldIr, FieldTypeIr,
};

pub(super) fn build_charts(
    entity: &SurfaceEntity,
    fields: &[FieldIr],
    diagnostics: &mut Vec<Diagnostic>,
) -> Vec<ChartIr> {
    entity
        .charts
        .iter()
        .filter_map(|chart| lower_chart(chart, fields, diagnostics))
        .collect()
}

fn lower_chart(
    chart: &SurfaceChart,
    fields: &[FieldIr],
    diagnostics: &mut Vec<Diagnostic>,
) -> Option<ChartIr> {
    let kind = match chart.kind.value.as_str() {
        "kpi" => ChartKindIr::Kpi,
        "bar" => ChartKindIr::Bar,
        "horizontal_bar" => ChartKindIr::HorizontalBar,
        "donut" => ChartKindIr::Donut,
        _ => {
            diagnostics.push(Diagnostic::error(
                "AS2044",
                "chart type must be `kpi`, `bar`, `horizontal_bar`, or `donut`",
                chart.kind.span.clone(),
            ));
            return None;
        }
    };
    let dimension = chart
        .dimension
        .as_ref()
        .map(|dimension| lower_dimension(dimension.value.as_str(), fields))
        .transpose()
        .unwrap_or_else(|message| {
            diagnostics.push(Diagnostic::error(
                "AS2044",
                message,
                chart
                    .dimension
                    .as_ref()
                    .map_or_else(|| chart.span.clone(), |value| value.span.clone()),
            ));
            None
        });
    let measure = match lower_measure(&chart.measure.value, fields) {
        Ok(measure) => measure,
        Err(message) => {
            diagnostics.push(Diagnostic::error(
                "AS2044",
                message,
                chart.measure.span.clone(),
            ));
            return None;
        }
    };
    Some(ChartIr {
        name: chart.name.clone(),
        label: chart
            .label
            .as_ref()
            .map_or_else(|| humanize(&chart.name), |label| label.value.clone()),
        kind,
        dimension,
        measure,
        limit: chart.limit,
    })
}

fn lower_dimension(value: &str, fields: &[FieldIr]) -> Result<ChartDimensionIr, String> {
    let parts = value.split('.').collect::<Vec<_>>();
    match parts.as_slice() {
        [field_name] => find_field(fields, field_name)
            .map(|field| ChartDimensionIr::Field {
                field: field.id.clone(),
            })
            .ok_or_else(|| format!("chart dimension references unknown field `{field_name}`")),
        [relation_name, target_field] => {
            let relation = find_field(fields, relation_name).ok_or_else(|| {
                format!("chart dimension references unknown relation `{relation_name}`")
            })?;
            let FieldTypeIr::Relation { target } = &relation.ty else {
                return Err(format!(
                    "chart dimension `{value}` must start with a relation field"
                ));
            };
            Ok(ChartDimensionIr::RelationField {
                relation: relation.id.clone(),
                field: appstruct_ir::FieldId(format!("{}.{target_field}", target.0)),
            })
        }
        _ => Err("chart dimensions support at most one relation hop".to_owned()),
    }
}

fn lower_measure(value: &str, fields: &[FieldIr]) -> Result<ChartMeasureIr, String> {
    if value == "count" {
        return Ok(ChartMeasureIr::Count);
    }
    let (operation, field_name) = value.split_once(':').ok_or_else(|| {
        "chart measure must be `count` or an operation such as `sum:amount`".to_owned()
    })?;
    if field_name.contains(':') {
        return Err("chart measure contains too many `:` separators".to_owned());
    }
    let field = find_field(fields, field_name)
        .ok_or_else(|| format!("chart measure references unknown field `{field_name}`"))?;
    match operation {
        "sum" => Ok(ChartMeasureIr::Sum {
            field: field.id.clone(),
        }),
        "avg" => Ok(ChartMeasureIr::Avg {
            field: field.id.clone(),
        }),
        "min" => Ok(ChartMeasureIr::Min {
            field: field.id.clone(),
        }),
        "max" => Ok(ChartMeasureIr::Max {
            field: field.id.clone(),
        }),
        _ => Err(format!("unsupported chart measure operation `{operation}`")),
    }
}

fn find_field<'fields>(fields: &'fields [FieldIr], name: &str) -> Option<&'fields FieldIr> {
    fields
        .iter()
        .find(|field| field.api_name == name || field.rust_name == name)
}

fn humanize(value: &str) -> String {
    let mut output = String::new();
    for (index, word) in value.split('_').filter(|word| !word.is_empty()).enumerate() {
        if index > 0 {
            output.push(' ');
        }
        let mut characters = word.chars();
        if let Some(first) = characters.next() {
            output.extend(first.to_uppercase());
            output.extend(characters);
        }
    }
    output
}