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,
};
use super::{Located, SurfaceAccess, SurfaceAccessRule, SurfaceFieldAccess};
use crate::yaml::{MappingEntry, Node};
use appstruct_ir::Diagnostic;
use std::collections::BTreeMap;

pub(super) fn decode_crud_access(node: &Node) -> Result<SurfaceAccess, Diagnostic> {
    let mapping = expect_mapping(node, "entity `access`")?;
    ensure_known_keys(
        mapping,
        &["list", "read", "create", "update", "delete"],
        "entity `access`",
    )?;
    Ok(SurfaceAccess {
        list: optional_rule(mapping, "list")?,
        read: optional_rule(mapping, "read")?,
        create: optional_rule(mapping, "create")?,
        update: optional_rule(mapping, "update")?,
        delete: optional_rule(mapping, "delete")?,
        span: node.span.clone(),
    })
}

pub(super) fn decode_field_access(node: &Node) -> Result<SurfaceFieldAccess, Diagnostic> {
    let mapping = expect_mapping(node, "field `access`")?;
    ensure_known_keys(mapping, &["read", "write"], "field `access`")?;
    Ok(SurfaceFieldAccess {
        read: optional_rule(mapping, "read")?,
        write: optional_rule(mapping, "write")?,
    })
}

pub(super) fn decode_rule(node: &Node) -> Result<Located<SurfaceAccessRule>, Diagnostic> {
    let rule = expect_mapping(node, "access rule")?;
    ensure_known_keys(
        rule,
        &["role", "public", "authenticated", "owner", "any", "all"],
        "access rule",
    )?;
    if rule.len() != 1 {
        return Err(Diagnostic::error(
            "AS1007",
            "access rule must contain exactly one expression",
            node.span.clone(),
        ));
    }
    let value = if let Some(role) = rule.get("role") {
        SurfaceAccessRule::Role(expect_string(&role.value, "access `role`")?.value)
    } else if let Some(owner) = rule.get("owner") {
        SurfaceAccessRule::Owner(expect_string(&owner.value, "access `owner`")?.value)
    } else if let Some(public) = rule.get("public") {
        if !expect_bool(&public.value, "access `public`")? {
            return Err(Diagnostic::error(
                "AS1007",
                "`public` must be true when present",
                public.value.span.clone(),
            ));
        }
        SurfaceAccessRule::Public
    } else if let Some(authenticated) = rule.get("authenticated") {
        if !expect_bool(&authenticated.value, "access `authenticated`")? {
            return Err(Diagnostic::error(
                "AS1007",
                "`authenticated` must be true when present",
                authenticated.value.span.clone(),
            ));
        }
        SurfaceAccessRule::Authenticated
    } else if let Some(any) = rule.get("any") {
        SurfaceAccessRule::Any(decode_children(&any.value, "access `any`")?)
    } else if let Some(all) = rule.get("all") {
        SurfaceAccessRule::All(decode_children(&all.value, "access `all`")?)
    } else {
        return Err(Diagnostic::error(
            "AS1007",
            "access rule requires a supported expression",
            node.span.clone(),
        ));
    };
    Ok(Located {
        value,
        span: node.span.clone(),
    })
}

fn decode_children(
    node: &Node,
    context: &str,
) -> Result<Vec<Located<SurfaceAccessRule>>, Diagnostic> {
    let children = expect_sequence(node, context)?;
    if children.is_empty() {
        return Err(Diagnostic::error(
            "AS1007",
            format!("{context} must contain at least one rule"),
            node.span.clone(),
        ));
    }
    children.iter().map(decode_rule).collect()
}

fn optional_rule(
    mapping: &BTreeMap<String, MappingEntry>,
    operation: &str,
) -> Result<Option<Located<SurfaceAccessRule>>, Diagnostic> {
    mapping
        .get(operation)
        .map(|entry| decode_rule(&entry.value))
        .transpose()
}