appstruct-compiler 0.2.0

Parser, validator, and typed IR compiler for AppStruct application specifications
Documentation
use super::value::{
    ensure_known_keys, expect_bool, expect_mapping, expect_sequence, expect_string, expect_u64,
    required,
};
use super::{Located, SurfaceReport, SurfaceReportTemplate};
use crate::yaml::MappingEntry;
use appstruct_ir::Diagnostic;

pub(super) fn decode(entry: Option<&MappingEntry>) -> Result<SurfaceReport, Diagnostic> {
    let Some(modules_entry) = entry else {
        return Ok(SurfaceReport::default());
    };
    let modules = expect_mapping(&modules_entry.value, "`modules`")?;
    let Some(entry) = modules.get("report") else {
        return Ok(SurfaceReport::default());
    };
    let report = expect_mapping(&entry.value, "`modules.report`")?;
    ensure_known_keys(
        report,
        &[
            "enabled",
            "renderer",
            "queue",
            "max_input_bytes",
            "retention_days",
            "reader_roles",
            "templates",
        ],
        "`modules.report`",
    )?;
    let enabled = report
        .get("enabled")
        .map(|value| expect_bool(&value.value, "`modules.report.enabled`"))
        .transpose()?
        .unwrap_or(true);
    Ok(SurfaceReport {
        enabled,
        renderer: string(report.get("renderer"), "report renderer")?,
        queue: string(report.get("queue"), "report queue")?,
        max_input_bytes: number(report.get("max_input_bytes"), "report max input bytes")?,
        retention_days: number(report.get("retention_days"), "report retention days")?,
        reader_roles: report
            .get("reader_roles")
            .map(|value| {
                expect_sequence(&value.value, "`modules.report.reader_roles`")?
                    .iter()
                    .map(|item| expect_string(item, "report reader role"))
                    .collect()
            })
            .transpose()?
            .unwrap_or_default(),
        templates: report
            .get("templates")
            .map(decode_templates)
            .transpose()?
            .unwrap_or_default(),
        span: Some(entry.value.span.clone()),
    })
}

fn decode_templates(entry: &MappingEntry) -> Result<Vec<SurfaceReportTemplate>, Diagnostic> {
    let templates = expect_mapping(&entry.value, "`modules.report.templates`")?;
    templates
        .iter()
        .map(|(name, entry)| {
            let template = expect_mapping(&entry.value, "report template")?;
            ensure_known_keys(
                template,
                &["version", "body", "input_schema", "data_schema_version"],
                "report template",
            )?;
            Ok(SurfaceReportTemplate {
                name: Located {
                    value: name.clone(),
                    span: entry.key_span.clone(),
                },
                version: expect_u64(
                    &required(template, "version", &entry.value.span)?.value,
                    "report template version",
                )?,
                body: expect_string(
                    &required(template, "body", &entry.value.span)?.value,
                    "report template body",
                )?,
                input_schema: expect_string(
                    &required(template, "input_schema", &entry.value.span)?.value,
                    "report template input schema",
                )?,
                data_schema_version: number(
                    template.get("data_schema_version"),
                    "report data schema version",
                )?,
            })
        })
        .collect()
}

fn string(
    entry: Option<&MappingEntry>,
    context: &str,
) -> Result<Option<Located<String>>, Diagnostic> {
    entry
        .map(|entry| expect_string(&entry.value, context))
        .transpose()
}

fn number(entry: Option<&MappingEntry>, context: &str) -> Result<Option<Located<u64>>, Diagnostic> {
    entry
        .map(|entry| expect_u64(&entry.value, context))
        .transpose()
}