appstruct-compiler 0.2.0

Parser, validator, and typed IR compiler for AppStruct application specifications
Documentation
use super::SurfaceAuth;
use super::value::{
    ensure_known_keys, expect_bool, expect_mapping, expect_sequence, expect_string, required,
};
use crate::yaml::{MappingEntry, Node};
use appstruct_ir::Diagnostic;
use std::collections::BTreeMap;

type DecodedProviders = (Vec<super::Located<String>>, Vec<super::Located<String>>);

pub(super) fn decode(modules_entry: Option<&MappingEntry>) -> Result<SurfaceAuth, Diagnostic> {
    let Some(modules_entry) = modules_entry else {
        return Ok(SurfaceAuth::default());
    };
    let modules = expect_mapping(&modules_entry.value, "`modules`")?;
    ensure_known_keys(
        modules,
        &[
            "auth", "billing", "rbac", "tenant", "audit", "mail", "jobs", "webhooks", "realtime",
            "file", "report", "activity",
        ],
        "`modules`",
    )?;
    let mut output = decode_auth(modules.get("auth"))?;
    decode_rbac(modules.get("rbac"), &mut output)?;
    Ok(output)
}

fn decode_auth(entry: Option<&MappingEntry>) -> Result<SurfaceAuth, Diagnostic> {
    let Some(entry) = entry else {
        return Ok(SurfaceAuth::default());
    };
    let auth = expect_mapping(&entry.value, "`modules.auth`")?;
    ensure_known_keys(
        auth,
        &[
            "enabled",
            "user_entity",
            "registration",
            "password_reset",
            "oauth",
            "providers",
        ],
        "`modules.auth`",
    )?;
    let (oauth_providers, oauth_signup_disabled) = auth
        .get("providers")
        .map(|value| decode_providers(&value.value))
        .transpose()?
        .unwrap_or_default();
    Ok(SurfaceAuth {
        enabled: optional_bool(auth.get("enabled"), "`modules.auth.enabled`")?,
        user_entity: auth
            .get("user_entity")
            .map(|value| expect_string(&value.value, "`modules.auth.user_entity`"))
            .transpose()?,
        registration_enabled: optional_bool(
            auth.get("registration"),
            "`modules.auth.registration`",
        )?,
        password_reset_enabled: optional_bool(
            auth.get("password_reset"),
            "`modules.auth.password_reset`",
        )?,
        oauth_enabled: optional_bool(auth.get("oauth"), "`modules.auth.oauth`")?,
        oauth_providers,
        oauth_signup_disabled,
        ..SurfaceAuth::default()
    })
}

fn decode_providers(node: &Node) -> Result<DecodedProviders, Diagnostic> {
    let mut declarations = BTreeMap::new();
    let mut providers = Vec::new();
    let mut signup_disabled = Vec::new();
    for provider in expect_sequence(node, "`modules.auth.providers`")? {
        let (id, enabled, allow_signup) = if provider.scalar().is_some() {
            (expect_string(provider, "OAuth provider")?, true, true)
        } else {
            let mapping = expect_mapping(provider, "OAuth provider")?;
            ensure_known_keys(
                mapping,
                &["id", "type", "enabled", "allow_signup", "capabilities"],
                "OAuth provider",
            )?;
            let id = required(mapping, "id", &provider.span)
                .and_then(|entry| expect_string(&entry.value, "OAuth provider `id`"))?;
            let provider_type = required(mapping, "type", &provider.span)
                .and_then(|entry| expect_string(&entry.value, "OAuth provider `type`"))?;
            validate_provider_type(&id, &provider_type)?;
            let enabled = mapping
                .get("enabled")
                .map(|entry| expect_bool(&entry.value, "OAuth provider `enabled`"))
                .transpose()?
                .unwrap_or(true);
            let allow_signup = mapping
                .get("allow_signup")
                .map(|entry| expect_bool(&entry.value, "OAuth provider `allow_signup`"))
                .transpose()?
                .unwrap_or(true);
            if let Some(capabilities) = mapping.get("capabilities") {
                let capabilities =
                    expect_mapping(&capabilities.value, "OAuth provider `capabilities`")?;
                ensure_known_keys(
                    capabilities,
                    &["login", "signup", "account_linking"],
                    "OAuth provider `capabilities`",
                )?;
                for capability in ["login", "signup", "account_linking"] {
                    if let Some(entry) = capabilities.get(capability) {
                        expect_bool(
                            &entry.value,
                            &format!("OAuth provider capability `{capability}`"),
                        )?;
                    }
                }
            }
            (id, enabled, allow_signup)
        };
        if let Some(first) = declarations.insert(id.value.clone(), id.span.clone()) {
            return Err(Diagnostic::error(
                "AS3038",
                format!("OAuth provider `{}` is declared more than once", id.value),
                id.span,
            )
            .with_secondary(first, "first declared here"));
        }
        if enabled {
            if !allow_signup {
                signup_disabled.push(id.clone());
            }
            providers.push(id);
        }
    }
    Ok((providers, signup_disabled))
}

fn validate_provider_type(
    id: &super::Located<String>,
    provider_type: &super::Located<String>,
) -> Result<(), Diagnostic> {
    let expected = match id.value.as_str() {
        "oidc" | "google" => "oidc",
        "github" => "oauth",
        provider => {
            return Err(Diagnostic::error(
                "AS3027",
                format!("unsupported OAuth provider `{provider}`; use oidc, google, or github"),
                id.span.clone(),
            ));
        }
    };
    if provider_type.value != expected {
        return Err(Diagnostic::error(
            "AS3039",
            format!(
                "OAuth provider `{}` requires type `{expected}`, not `{}`",
                id.value, provider_type.value
            ),
            provider_type.span.clone(),
        ));
    }
    Ok(())
}

fn decode_rbac(entry: Option<&MappingEntry>, output: &mut SurfaceAuth) -> Result<(), Diagnostic> {
    let Some(entry) = entry else { return Ok(()) };
    let rbac = expect_mapping(&entry.value, "`modules.rbac`")?;
    ensure_known_keys(rbac, &["roles", "default_role"], "`modules.rbac`")?;
    output.roles = rbac
        .get("roles")
        .map(|value| {
            expect_sequence(&value.value, "`modules.rbac.roles`")?
                .iter()
                .map(|role| expect_string(role, "RBAC role"))
                .collect()
        })
        .transpose()?
        .unwrap_or_default();
    output.default_role = rbac
        .get("default_role")
        .map(|value| expect_string(&value.value, "`modules.rbac.default_role`"))
        .transpose()?;
    Ok(())
}

fn optional_bool(entry: Option<&MappingEntry>, context: &str) -> Result<bool, Diagnostic> {
    entry
        .map(|value| expect_bool(&value.value, context))
        .transpose()
        .map(Option::unwrap_or_default)
}