appstruct-compiler 0.1.0

Parser, validator, and typed IR compiler for AppStruct application specifications
Documentation
use crate::surface::{SurfaceJobQueue, SurfaceJobs};
use appstruct_ir::{Diagnostic, JobQueueIr, JobsIr, SourceSpan};

pub(crate) fn lower_jobs(
    jobs: &SurfaceJobs,
    fallback: &SourceSpan,
    diagnostics: &mut Vec<Diagnostic>,
) -> JobsIr {
    if !jobs.enabled {
        return disabled();
    }
    let span = jobs.span.as_ref().unwrap_or(fallback);
    if jobs.queues.is_empty() {
        diagnostics.push(Diagnostic::error(
            "AS3047",
            "enabled jobs module requires at least one queue",
            span.clone(),
        ));
    }
    let poll_interval_ms = jobs.poll_interval_ms.as_ref().map_or(250, |value| {
        check_range(
            value.value,
            10,
            60_000,
            "AS3048",
            "poll_interval_ms",
            &value.span,
            diagnostics,
        )
    });
    let lease_seconds = jobs.lease_seconds.as_ref().map_or(30, |value| {
        check_range(
            value.value,
            1,
            3_600,
            "AS3049",
            "lease_seconds",
            &value.span,
            diagnostics,
        )
    });
    let queues = jobs
        .queues
        .iter()
        .map(|queue| lower_queue(queue, diagnostics))
        .collect();
    JobsIr {
        enabled: true,
        poll_interval_ms,
        lease_seconds,
        queues,
    }
}

fn disabled() -> JobsIr {
    JobsIr {
        enabled: false,
        poll_interval_ms: 250,
        lease_seconds: 30,
        queues: Vec::new(),
    }
}

fn lower_queue(queue: &SurfaceJobQueue, diagnostics: &mut Vec<Diagnostic>) -> JobQueueIr {
    if !valid_name(&queue.name.value) {
        diagnostics.push(Diagnostic::error(
            "AS3050",
            "job queue name must use lowercase letters, digits, `_`, or `-`",
            queue.name.span.clone(),
        ));
    }
    let max_attempts = queue.max_attempts.as_ref().map_or(5, |value| {
        check_range(
            value.value,
            1,
            100,
            "AS3051",
            "max_attempts",
            &value.span,
            diagnostics,
        )
    });
    let backoff_seconds = queue.backoff_seconds.as_ref().map_or(2, |value| {
        check_range(
            value.value,
            1,
            3_600,
            "AS3052",
            "backoff_seconds",
            &value.span,
            diagnostics,
        )
    });
    JobQueueIr {
        name: queue.name.value.clone(),
        max_attempts: u32::try_from(max_attempts).unwrap_or(100),
        backoff_seconds,
    }
}

fn check_range(
    value: u64,
    minimum: u64,
    maximum: u64,
    code: &'static str,
    name: &str,
    span: &SourceSpan,
    diagnostics: &mut Vec<Diagnostic>,
) -> u64 {
    if !(minimum..=maximum).contains(&value) {
        diagnostics.push(Diagnostic::error(
            code,
            format!("`{name}` must be between {minimum} and {maximum}"),
            span.clone(),
        ));
    }
    value.clamp(minimum, maximum)
}

fn valid_name(value: &str) -> bool {
    !value.is_empty()
        && value.chars().all(|character| {
            character.is_ascii_lowercase()
                || character.is_ascii_digit()
                || matches!(character, '_' | '-')
        })
}