clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Three-valued guard evaluator delegating to `layer0::guard_term_eval` (`INV-627`).

use serde_json::{Value, json};

use crate::layer0::guard_grammar::{
    AUTH_POLICY_STRICT, PROFILE_GUARD, RESOLVER_KIND_FIELD, RESOLVER_KIND_GATE, RESOLVER_KIND_RLCD,
};
use crate::layer0::guard_term_eval::{ResolverReply, evaluate_compiled_term, get_compiled_guard};
use crate::layer0::vocabulary::{
    AUTH_DECISION_ALLOWED, AUTH_DECISION_DENIED, AUTH_MODE_NOT_REQUIRED, AUTH_MODE_UNAVAILABLE,
    GATE_AUTHORIZED, GATE_PAYLOAD_NONEMPTY, GATE_RESULT_SEALED, GUARD_CAUSE_AUTHORIZATION,
    GUARD_DOT, GUARD_KIND_ABSENT, GUARD_OUTCOME_FAIL, GUARD_OUTCOME_PASS, GUARD_OUTCOME_UNMATCHED,
    GUARD_PREFIX_EXISTS, GUARD_PREFIX_TYPE, GUARD_PROP_CONTENT, GUARD_PROP_DATA,
    GUARD_PROP_DECISION, GUARD_PROP_HASH, GUARD_PROP_MCARD, GUARD_PROP_METADATA, GUARD_PROP_MODE,
    GUARD_PROP_PAYLOAD, GUARD_PROP_PAYLOAD_KIND, GUARD_PROP_POLICY_ID, GUARD_PROP_POLICY_ID_SNAKE,
    GUARD_PROP_PRINCIPAL, GUARD_PROP_PROB, GUARD_PROP_RLCD_ADMISSIBLE, GUARD_PROP_RLCD_CONFIDENCE,
    GUARD_PROP_RLCD_IS_ADMISSIBLE, GUARD_PROP_SEALED, GUARD_VAR_INPUT, GUARD_VAR_INPUT_PREFIX,
    GUARD_VAR_OUTPUT, GUARD_VAR_OUTPUT_PREFIX, GUARD_VAR_VARIABLES, GUARD_VAR_VCARD,
    PAYLOAD_KIND_BINARY, PAYLOAD_KIND_SCALAR, PAYLOAD_KIND_STRUCTURED, PAYLOAD_KIND_TEXT,
    POLICY_MODE_REQUIRED, RESOLVER_OUTCOME_VALUE,
};
use crate::layer0::vocabulary_types::PROVIDER_FIELD_KIND;

pub use super::guard_parser::{
    GuardAst, GuardVerdict, compile_guard_cache_key, compile_guard_to_term, eval_kleene_and,
    eval_kleene_not, eval_kleene_or, evaluate_guard_ast, parse_guard_expression,
};

#[inline]
fn is_reserved_root_key(key: &str) -> bool {
    key == GUARD_VAR_INPUT
        || key == GUARD_VAR_OUTPUT
        || key == GUARD_VAR_VCARD
        || key == GUARD_VAR_VARIABLES
        || key == GUARD_CAUSE_AUTHORIZATION
}

type PayloadEmptyFn = fn(&Value, Option<&Value>) -> bool;

const PAYLOAD_EMPTY_TABLE: &[(&str, PayloadEmptyFn)] = &[
    (PAYLOAD_KIND_SCALAR, |v, _| v.is_null() || v.as_str() == Some("")),
    (PAYLOAD_KIND_TEXT, |v, _| v.as_str().map(|s| s.trim().is_empty()).unwrap_or(true)),
    (PAYLOAD_KIND_BINARY, |v, d| {
        let bin = d.unwrap_or(v);
        bin.as_array().map(|a| a.is_empty()).or_else(|| bin.as_str().map(|s| s.is_empty())).unwrap_or(true)
    }),
    (PAYLOAD_KIND_STRUCTURED, |v, _| {
        v.is_null() || v.as_array().is_some_and(|a| a.is_empty()) || v.as_object().is_some_and(|o| o.is_empty())
    }),
];

pub(crate) fn is_card_payload_empty(card: &Value) -> bool {
    let Some(obj) = card.as_object() else { return card.is_null(); };
    if let Some(kind) = obj.get(GUARD_PROP_PAYLOAD_KIND).and_then(|v| v.as_str()) {
        let p = obj.get(GUARD_PROP_PAYLOAD).unwrap_or(&Value::Null);
        return PAYLOAD_EMPTY_TABLE.iter().find(|&&(k, _)| k == kind).is_some_and(|&(_, f)| f(p, None));
    }
    let payload = obj.get(GUARD_PROP_PAYLOAD).or_else(|| obj.get(GUARD_PROP_CONTENT)).unwrap_or(card);
    match payload {
        Value::Null => true,
        Value::String(s) => s.trim().is_empty(),
        Value::Array(a) => a.is_empty(),
        Value::Object(po) => match po.get(PROVIDER_FIELD_KIND).and_then(|v| v.as_str()) {
            Some(kind) => PAYLOAD_EMPTY_TABLE
                .iter()
                .find(|&&(k, _)| k == kind)
                .is_some_and(|&(_, f)| f(po.get(RESOLVER_OUTCOME_VALUE).unwrap_or(&Value::Null), po.get(GUARD_PROP_DATA))),
            None => po.is_empty(),
        },
        _ => false,
    }
}

pub(crate) fn walk_json_str<'a>(root: &'a Value, dotted: &str) -> Option<&'a Value> {
    let mut curr = root;
    for p in dotted.split(GUARD_DOT) {
        let obj = curr.as_object()?;
        curr = obj
            .get(p)
            .or_else(|| obj.get(GUARD_PROP_PAYLOAD)?.as_object()?.get(p))
            .or_else(|| obj.get(GUARD_PROP_PAYLOAD)?.get(RESOLVER_OUTCOME_VALUE)?.as_object()?.get(p))
            .or_else(|| obj.get(GUARD_PROP_METADATA)?.as_object()?.get(p))?;
    }
    Some(curr)
}

pub(crate) fn resolve_json_field_ref<'a>(key: &str, context: &'a Value, strict_root: bool) -> Option<&'a Value> {
    let key = key.trim();
    if key.is_empty() || (strict_root && is_reserved_root_key(key)) {
        return None;
    }
    if let Some(v) = context.get(GUARD_VAR_VARIABLES).and_then(|vars| walk_json_str(vars, key)) {
        return Some(v);
    }
    if (!strict_root || key.contains(GUARD_DOT) || !is_reserved_root_key(key))
        && let Some(v) = walk_json_str(context, key)
    {
        return Some(v);
    }
    let (card, clean_key) = if let Some(stripped) = key.strip_prefix(GUARD_VAR_OUTPUT_PREFIX) {
        (context.get(GUARD_VAR_OUTPUT).or_else(|| context.get(GUARD_VAR_INPUT)), stripped)
    } else if let Some(stripped) = key.strip_prefix(GUARD_VAR_INPUT_PREFIX) {
        (context.get(GUARD_VAR_INPUT).or_else(|| context.get(GUARD_VAR_OUTPUT)), stripped)
    } else {
        (context.get(GUARD_VAR_OUTPUT).or_else(|| context.get(GUARD_VAR_INPUT)), key)
    };
    card.and_then(|c| walk_json_str(c, clean_key))
}

type GateResolverFn = fn(&Value) -> (&'static str, String);

const GATE_RESOLVERS: &[(&str, GateResolverFn)] = &[
    (GATE_PAYLOAD_NONEMPTY, |ctx| {
        let inp = ctx.get(GUARD_VAR_INPUT).or_else(|| ctx.get(GUARD_PROP_MCARD));
        match inp {
            Some(c) => (if is_card_payload_empty(c) { GUARD_OUTCOME_FAIL } else { GUARD_OUTCOME_PASS }, String::new()),
            None => match ctx.get(GUARD_PROP_PAYLOAD) {
                Some(p) => (if is_card_payload_empty(&json!({ GUARD_PROP_PAYLOAD: p })) { GUARD_OUTCOME_FAIL } else { GUARD_OUTCOME_PASS }, String::new()),
                None => (GUARD_KIND_ABSENT, String::new()),
            },
        }
    }),
    (GATE_RESULT_SEALED, |ctx| {
        let out = ctx.get(GUARD_VAR_OUTPUT).or_else(|| ctx.get(GUARD_VAR_INPUT));
        let sealed = out.and_then(|o| o.as_object()).is_some_and(|obj| {
            obj.get(GUARD_PROP_SEALED) == Some(&Value::Bool(true))
                || obj.get(GUARD_PROP_HASH).and_then(|h| h.as_str()).is_some_and(|s| !s.is_empty())
        });
        (if sealed { GUARD_OUTCOME_PASS } else { GUARD_OUTCOME_FAIL }, String::new())
    }),
    (GATE_AUTHORIZED, |ctx| {
        let Some(auth) = ctx.get(GUARD_CAUSE_AUTHORIZATION).and_then(|v| v.as_object()) else {
            return (GUARD_OUTCOME_UNMATCHED, String::new());
        };
        let Some(mode) = auth.get(GUARD_PROP_MODE).and_then(|v| v.as_str()) else {
            return (GUARD_OUTCOME_UNMATCHED, String::new());
        };
        if mode == AUTH_MODE_NOT_REQUIRED { return (GUARD_OUTCOME_PASS, String::new()); }
        if mode == POLICY_MODE_REQUIRED {
            let decision = auth.get(GUARD_PROP_DECISION).and_then(|v| v.as_str()).unwrap_or("");
            let has_p = auth.get(GUARD_PROP_PRINCIPAL).and_then(|v| v.as_str()).is_some_and(|s| !s.trim().is_empty());
            let has_pol = auth.get(GUARD_PROP_POLICY_ID).or_else(|| auth.get(GUARD_PROP_POLICY_ID_SNAKE)).and_then(|v| v.as_str()).is_some_and(|s| !s.trim().is_empty());
            if decision != AUTH_MODE_UNAVAILABLE && has_p && has_pol {
                if decision == AUTH_DECISION_ALLOWED { return (GUARD_OUTCOME_PASS, String::new()); }
                if decision == AUTH_DECISION_DENIED { return (GUARD_OUTCOME_FAIL, String::new()); }
            }
        }
        (GUARD_OUTCOME_UNMATCHED, String::new())
    }),
];

pub(crate) fn eval_with_json_context(expression: &str, context: &Value, profile: &str, strict_root: bool) -> GuardVerdict {
    let trimmed = expression.trim();
    if trimmed.is_empty() {
        return GuardVerdict::Unmatched(expression.to_string());
    }
    let Ok(compiled) = get_compiled_guard(trimmed, profile) else {
        return GuardVerdict::Unmatched(expression.to_string());
    };
    let mut resolver = |kind: &str, arg: &str, arg2: &str, _extra: &[String]| -> ResolverReply<'_> {
        if kind == RESOLVER_KIND_FIELD {
            return ResolverReply::FieldRef(resolve_json_field_ref(arg, context, strict_root));
        }
        if kind == RESOLVER_KIND_RLCD {
            let Some(target) = resolve_json_field_ref(arg, context, strict_root) else { return ResolverReply::FieldRef(None); };
            let Some(obj) = target.as_object() else { return ResolverReply::FieldRef(None); };
            if arg2 == GUARD_PROP_RLCD_CONFIDENCE {
                let n = obj.get(GUARD_PROP_RLCD_CONFIDENCE).or_else(|| obj.get(GUARD_PROP_PROB)).and_then(|v| v.as_f64()).unwrap_or(0.0);
                return ResolverReply::Field(Some(json!(n)));
            }
            if arg2 == GUARD_PROP_RLCD_IS_ADMISSIBLE {
                let b = obj.get(GUARD_PROP_RLCD_IS_ADMISSIBLE).or_else(|| obj.get(GUARD_PROP_RLCD_ADMISSIBLE)).and_then(|v| v.as_bool()).unwrap_or(false);
                return ResolverReply::Field(Some(Value::Bool(b)));
            }
            return ResolverReply::FieldRef(obj.get(arg2));
        }
        if kind == RESOLVER_KIND_GATE {
            if let Some(&(_, f)) = GATE_RESOLVERS.iter().find(|&&(k, _)| k == arg) {
                let (st, dt) = f(context);
                return ResolverReply::Gate(st, dt);
            }
            return ResolverReply::Gate(GUARD_OUTCOME_UNMATCHED, String::new());
        }
        if kind == GUARD_PREFIX_EXISTS {
            let in_meta = context.get(GUARD_VAR_INPUT).and_then(|i| i.as_object()).is_some_and(|obj| {
                obj.contains_key(arg) || obj.get(GUARD_PROP_METADATA).and_then(|m| m.as_object()).is_some_and(|m| m.contains_key(arg))
            });
            let in_vars = context.get(GUARD_VAR_VARIABLES).and_then(|v| v.as_object()).is_some_and(|v| v.contains_key(arg));
            let in_root = !is_reserved_root_key(arg) && context.as_object().is_some_and(|o| o.contains_key(arg));
            return ResolverReply::Exists(in_meta || in_vars || in_root);
        }
        if kind == GUARD_PREFIX_TYPE {
            let actual = context.get(GUARD_VAR_INPUT).and_then(|i| i.as_object()).and_then(|obj| {
                obj.get(GUARD_PROP_PAYLOAD_KIND).and_then(|v| v.as_str())
                    .or_else(|| obj.get(GUARD_PROP_PAYLOAD).and_then(|p| p.get(PROVIDER_FIELD_KIND)).and_then(|v| v.as_str()))
                    .or_else(|| obj.get(PROVIDER_FIELD_KIND).and_then(|v| v.as_str()))
            });
            return ResolverReply::PayloadKind(actual == Some(arg), actual.map(str::to_string));
        }
        ResolverReply::FieldRef(None)
    };
    match evaluate_compiled_term(&compiled, &mut resolver, GUARD_OUTCOME_UNMATCHED, AUTH_POLICY_STRICT) {
        Ok(v) if v.outcome == GUARD_OUTCOME_PASS => GuardVerdict::Pass,
        Ok(v) if v.outcome == GUARD_OUTCOME_UNMATCHED => {
            GuardVerdict::Unmatched(if v.invariant_code.is_empty() { expression.to_string() } else { v.invariant_code.into_owned() })
        }
        Ok(v) => GuardVerdict::Fail(v.reason.into_owned()),
        Err(e) => GuardVerdict::Unmatched(e),
    }
}

pub fn evaluate_guard_atom(raw_expr: &str, context: &Value) -> GuardVerdict {
    eval_with_json_context(raw_expr, context, PROFILE_GUARD, true)
}

pub fn evaluate_guard(expression: &str, context: &Value) -> GuardVerdict {
    eval_with_json_context(expression, context, PROFILE_GUARD, true)
}