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,
};
use super::{Located, SurfaceWebhookEndpoint, SurfaceWebhooks};
use crate::yaml::MappingEntry;
use appstruct_ir::Diagnostic;

pub(super) fn decode(entry: Option<&MappingEntry>) -> Result<SurfaceWebhooks, Diagnostic> {
    let Some(modules_entry) = entry else {
        return Ok(SurfaceWebhooks::default());
    };
    let modules = expect_mapping(&modules_entry.value, "`modules`")?;
    let Some(entry) = modules.get("webhooks") else {
        return Ok(SurfaceWebhooks::default());
    };
    let webhooks = expect_mapping(&entry.value, "`modules.webhooks`")?;
    ensure_known_keys(
        webhooks,
        &[
            "enabled",
            "poll_interval_ms",
            "connect_timeout_ms",
            "read_timeout_ms",
            "request_timeout_ms",
            "endpoints",
        ],
        "`modules.webhooks`",
    )?;
    let enabled = webhooks
        .get("enabled")
        .map(|value| expect_bool(&value.value, "`modules.webhooks.enabled`"))
        .transpose()?
        .unwrap_or(true);
    Ok(SurfaceWebhooks {
        enabled,
        poll_interval_ms: webhooks
            .get("poll_interval_ms")
            .map(|entry| expect_u64(&entry.value, "webhook poll interval"))
            .transpose()?,
        connect_timeout_ms: webhooks
            .get("connect_timeout_ms")
            .map(|entry| expect_u64(&entry.value, "webhook connect timeout"))
            .transpose()?,
        read_timeout_ms: webhooks
            .get("read_timeout_ms")
            .map(|entry| expect_u64(&entry.value, "webhook read timeout"))
            .transpose()?,
        request_timeout_ms: webhooks
            .get("request_timeout_ms")
            .map(|entry| expect_u64(&entry.value, "webhook request timeout"))
            .transpose()?,
        endpoints: webhooks
            .get("endpoints")
            .map(decode_endpoints)
            .transpose()?
            .unwrap_or_default(),
        span: Some(entry.value.span.clone()),
    })
}

fn decode_endpoints(entry: &MappingEntry) -> Result<Vec<SurfaceWebhookEndpoint>, Diagnostic> {
    let endpoints = expect_mapping(&entry.value, "`modules.webhooks.endpoints`")?;
    endpoints
        .iter()
        .map(|(name, entry)| {
            let endpoint = expect_mapping(&entry.value, "webhook endpoint")?;
            ensure_known_keys(
                endpoint,
                &[
                    "url",
                    "secret_env",
                    "events",
                    "max_attempts",
                    "backoff_seconds",
                ],
                "webhook endpoint",
            )?;
            let required = |key: &str| {
                endpoint
                    .get(key)
                    .map(|entry| expect_string(&entry.value, &format!("webhook `{key}`")))
                    .transpose()?
                    .ok_or_else(|| {
                        Diagnostic::error(
                            "AS3071",
                            format!("webhook endpoint requires `{key}`"),
                            entry.value.span.clone(),
                        )
                    })
            };
            let events = endpoint
                .get("events")
                .map(|entry| decode_events(&entry.value))
                .transpose()?
                .unwrap_or_default();
            Ok(SurfaceWebhookEndpoint {
                name: Located {
                    value: name.clone(),
                    span: entry.key_span.clone(),
                },
                url: required("url")?,
                secret_env: required("secret_env")?,
                events,
                max_attempts: endpoint
                    .get("max_attempts")
                    .map(|entry| expect_u64(&entry.value, "webhook max attempts"))
                    .transpose()?,
                backoff_seconds: endpoint
                    .get("backoff_seconds")
                    .map(|entry| expect_u64(&entry.value, "webhook backoff"))
                    .transpose()?,
            })
        })
        .collect()
}

fn decode_events(node: &crate::yaml::Node) -> Result<Vec<Located<String>>, Diagnostic> {
    expect_sequence(node, "webhook `events`")?
        .iter()
        .map(|event| expect_string(event, "webhook event"))
        .collect()
}