cratestack-macros 0.4.4

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Procedure-side policy expressions: `@allow(...)` / `@deny(...)`
//! attributes on procedure declarations. Parses the AST (boolean
//! expressions of input-field / `auth()` predicates) and emits
//! `cratestack::ProcedurePolicy` const-eval values.
//!
//! Three submodules carve up the work:
//! - [`term`]: single-term recognition (builtins, null checks, lone
//!   boolean fields), with dispatch into [`comparison`] for `==`/`!=`.
//! - [`comparison`]: cross-product of (auth | input | literal) on both
//!   sides of a comparison.
//! - [`resolver`]: input-field resolution + literal parsing, shared
//!   between [`term`] and [`comparison`].

mod comparison;
mod resolver;
mod term;

use cratestack_core::{Procedure, TypeDecl};
use quote::quote;

use super::ast::{generate_policy_ast_tokens, parse_policy_ast};

use term::parse_procedure_policy_term;

pub(crate) fn parse_procedure_allow_expression(raw: &str) -> Option<Result<&str, String>> {
    parse_procedure_policy_expression(raw, "@allow")
}

pub(crate) fn parse_procedure_deny_expression(raw: &str) -> Option<Result<&str, String>> {
    parse_procedure_policy_expression(raw, "@deny")
}

pub(crate) fn generate_procedure_policy(
    expression: &str,
    procedure: &Procedure,
    types: &[TypeDecl],
    auth: Option<&cratestack_core::AuthBlock>,
) -> Result<proc_macro2::TokenStream, String> {
    let ast = parse_policy_ast(expression)?;
    let expr = generate_policy_ast_tokens(
        &ast,
        &|term| {
            parse_procedure_policy_term(term, procedure, types, auth).map(
                |predicate| quote! { ::cratestack::ProcedurePolicyExpr::Predicate(#predicate) },
            )
        },
        quote! { ::cratestack::ProcedurePolicyExpr::And },
        quote! { ::cratestack::ProcedurePolicyExpr::Or },
    )?;

    Ok(quote! {
        ::cratestack::ProcedurePolicy {
            expr: #expr,
        }
    })
}

fn parse_procedure_policy_expression<'a>(
    raw: &'a str,
    directive: &str,
) -> Option<Result<&'a str, String>> {
    let inner = raw
        .trim()
        .strip_prefix(directive)?
        .strip_prefix('(')?
        .strip_suffix(')')?
        .trim();
    Some(Ok(inner))
}