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)
}