use serde_json::Value;
use crate::layer0::limits::{SPEC_GUARD_FLOAT_TOLERANCE_RECIPROCAL, SPEC_U16_BYTES};
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_CMP_EQ, GUARD_CMP_GE, GUARD_CMP_GT, GUARD_CMP_LE, GUARD_CMP_LT, GUARD_CMP_NE, GUARD_DOT,
GUARD_DQUOTE, GUARD_LIT_FALSE, GUARD_LIT_NONE, GUARD_LIT_NULL, GUARD_LIT_TRUE,
GUARD_OUTCOME_FAIL, GUARD_OUTCOME_PASS, GUARD_PREFIX_EXISTS, GUARD_PREFIX_SIZE_CALL,
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_CALL,
GUARD_PROP_RLCD_CLOSE, GUARD_PROP_RLCD_CONFIDENCE, GUARD_PROP_RLCD_IS_ADMISSIBLE,
GUARD_PROP_SEALED, GUARD_RPAREN, GUARD_SQUOTE, 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;
use super::guard_parser::is_lhs_byte;
pub use super::guard_parser::{
GuardAst, GuardVerdict, eval_kleene_and, eval_kleene_not, eval_kleene_or, evaluate_guard_ast,
parse_guard_expression,
};
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
}
fn is_typed_payload_empty(kind: &str, val: &Value, data: Option<&Value>) -> bool {
if kind == PAYLOAD_KIND_SCALAR {
val.is_null() || val.as_str() == Some("")
} else if kind == PAYLOAD_KIND_TEXT {
val.as_str().map(|s| s.trim().is_empty()).unwrap_or(true)
} else if kind == PAYLOAD_KIND_BINARY {
let bin = data.unwrap_or(val);
bin.as_array()
.map(|a| a.is_empty())
.or_else(|| bin.as_str().map(|s| s.is_empty()))
.unwrap_or(true)
} else if kind == PAYLOAD_KIND_STRUCTURED {
val.is_null()
|| val.as_array().is_some_and(|a| a.is_empty())
|| val.as_object().is_some_and(|o| o.is_empty())
} else {
false
}
}
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 is_typed_payload_empty(kind, 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) => is_typed_payload_empty(
kind,
po.get(RESOLVER_OUTCOME_VALUE).unwrap_or(&Value::Null),
po.get(GUARD_PROP_DATA),
),
None => po.is_empty(),
},
_ => false,
}
}
fn walk_json_path<'a>(root: &'a Value, parts: &[&str]) -> Option<&'a Value> {
let mut curr = root;
for &p in parts {
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)
}
fn resolve_guard_value(key: &str, context: &Value) -> Option<Value> {
let key = key.trim();
if let Some(rest) = key.strip_prefix(GUARD_PROP_RLCD_CALL)
&& let Some(close) = rest.find(GUARD_PROP_RLCD_CLOSE)
{
let target_name = &rest[..close];
let prop = &rest[close + GUARD_PROP_RLCD_CLOSE.len()..];
let target = resolve_guard_value(target_name, context)?;
let obj = target.as_object()?;
if prop == 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 Some(serde_json::json!(n));
}
if prop == 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 Some(Value::Bool(b));
}
return obj.get(prop).cloned();
}
let parts: Vec<&str> = key.split(GUARD_DOT).collect();
if let Some(v) = context
.get(GUARD_VAR_VARIABLES)
.and_then(|vars| walk_json_path(vars, &parts))
{
return Some(v.clone());
}
if parts.len() > 1 || !is_reserved_root_key(key) {
if let Some(v) = walk_json_path(context, &parts) {
return Some(v.clone());
}
}
let (card, clean_parts) = if let Some(stripped) = key.strip_prefix(GUARD_VAR_OUTPUT_PREFIX) {
(
context
.get(GUARD_VAR_OUTPUT)
.or_else(|| context.get(GUARD_VAR_INPUT)),
stripped.split(GUARD_DOT).collect::<Vec<_>>(),
)
} 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.split(GUARD_DOT).collect::<Vec<_>>(),
)
} else {
(
context
.get(GUARD_VAR_OUTPUT)
.or_else(|| context.get(GUARD_VAR_INPUT)),
parts,
)
};
card.and_then(|c| walk_json_path(c, &clean_parts)).cloned()
}
fn try_parse_rhs_token(raw: &str, context: &Value) -> Option<Value> {
let s = raw.trim();
if s.is_empty() {
return None;
}
if s.eq_ignore_ascii_case(GUARD_LIT_TRUE) {
return Some(Value::Bool(true));
}
if s.eq_ignore_ascii_case(GUARD_LIT_FALSE) {
return Some(Value::Bool(false));
}
if s.eq_ignore_ascii_case(GUARD_LIT_NULL) || s.eq_ignore_ascii_case(GUARD_LIT_NONE) {
return Some(Value::Null);
}
let quote_pair_len = SPEC_U16_BYTES as usize;
if s.len() >= quote_pair_len
&& ((s.starts_with(GUARD_DQUOTE) && s.ends_with(GUARD_DQUOTE))
|| (s.starts_with(GUARD_SQUOTE) && s.ends_with(GUARD_SQUOTE)))
{
return Some(Value::String(s[1..s.len() - 1].to_string()));
}
if let Ok(i) = s.parse::<i64>() {
return Some(Value::from(i));
}
if let Ok(f) = s.parse::<f64>() {
return Some(serde_json::json!(f));
}
if s.bytes().all(is_lhs_byte) {
return Some(
resolve_guard_value(s, context).unwrap_or_else(|| Value::String(s.to_string())),
);
}
None
}
fn compare_json_values(left: &Value, op: &str, right: &Value) -> bool {
let eps = 1.0 / (SPEC_GUARD_FLOAT_TOLERANCE_RECIPROCAL as f64);
if let (Some(lf), Some(rf)) = (left.as_f64(), right.as_f64()) {
return match op {
o if o == GUARD_CMP_EQ => (lf - rf).abs() < eps,
o if o == GUARD_CMP_NE => (lf - rf).abs() >= eps,
o if o == GUARD_CMP_LT => lf < rf,
o if o == GUARD_CMP_LE => lf <= rf,
o if o == GUARD_CMP_GT => lf > rf,
o if o == GUARD_CMP_GE => lf >= rf,
_ => false,
};
}
match op {
o if o == GUARD_CMP_EQ => left == right,
o if o == GUARD_CMP_NE => left != right,
o if o == GUARD_CMP_LT => left
.as_str()
.zip(right.as_str())
.is_some_and(|(a, b)| a < b),
o if o == GUARD_CMP_LE => left
.as_str()
.zip(right.as_str())
.is_some_and(|(a, b)| a <= b),
o if o == GUARD_CMP_GT => left
.as_str()
.zip(right.as_str())
.is_some_and(|(a, b)| a > b),
o if o == GUARD_CMP_GE => left
.as_str()
.zip(right.as_str())
.is_some_and(|(a, b)| a >= b),
_ => false,
}
}
fn split_cmp_tail(tail: &str) -> Option<(&'static str, &str)> {
let trimmed = tail.trim_start();
for op in [
GUARD_CMP_EQ,
GUARD_CMP_NE,
GUARD_CMP_LE,
GUARD_CMP_GE,
GUARD_CMP_LT,
GUARD_CMP_GT,
] {
if let Some(rest) = trimmed.strip_prefix(op) {
return Some((op, rest.trim_start()));
}
}
None
}
fn evaluate_auth_gate(expr: &str, context: &Value) -> GuardVerdict {
let Some(auth) = context
.get(GUARD_CAUSE_AUTHORIZATION)
.and_then(|v| v.as_object())
else {
return GuardVerdict::Unmatched(expr.to_string());
};
let Some(mode) = auth.get(GUARD_PROP_MODE).and_then(|v| v.as_str()) else {
return GuardVerdict::Unmatched(expr.to_string());
};
if mode == AUTH_MODE_NOT_REQUIRED {
return GuardVerdict::Pass;
}
if mode == AUTH_MODE_UNAVAILABLE {
return GuardVerdict::Unmatched(expr.to_string());
}
if mode == POLICY_MODE_REQUIRED {
let decision = auth
.get(GUARD_PROP_DECISION)
.and_then(|v| v.as_str())
.unwrap_or("");
if decision == AUTH_MODE_UNAVAILABLE {
return GuardVerdict::Unmatched(expr.to_string());
}
let has_principal = auth
.get(GUARD_PROP_PRINCIPAL)
.and_then(|v| v.as_str())
.is_some_and(|s| !s.trim().is_empty());
let has_policy = 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 !has_principal || !has_policy {
return GuardVerdict::Unmatched(expr.to_string());
}
if decision == AUTH_DECISION_ALLOWED {
return GuardVerdict::Pass;
}
if decision == AUTH_DECISION_DENIED {
return GuardVerdict::Fail(expr.to_string());
}
}
GuardVerdict::Unmatched(expr.to_string())
}
pub fn evaluate_guard_atom(raw_expr: &str, context: &Value) -> GuardVerdict {
let expr = raw_expr.trim();
if expr.is_empty() {
return GuardVerdict::Unmatched(raw_expr.to_string());
}
let lower = expr.to_ascii_lowercase();
if lower == GUARD_LIT_TRUE || lower == GUARD_OUTCOME_PASS {
return GuardVerdict::Pass;
}
if lower == GUARD_LIT_FALSE || lower == GUARD_OUTCOME_FAIL {
return GuardVerdict::Fail(expr.to_string());
}
if lower == GATE_PAYLOAD_NONEMPTY {
let Some(inp) = context
.get(GUARD_VAR_INPUT)
.or_else(|| context.get(GUARD_PROP_MCARD))
else {
return GuardVerdict::Fail(expr.to_string());
};
return if is_card_payload_empty(inp) {
GuardVerdict::Fail(expr.to_string())
} else {
GuardVerdict::Pass
};
}
if lower == GATE_RESULT_SEALED {
let out = context
.get(GUARD_VAR_OUTPUT)
.or_else(|| context.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())
});
return if sealed {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(expr.to_string())
};
}
if lower == GATE_AUTHORIZED {
return evaluate_auth_gate(expr, context);
}
if lower.starts_with(GUARD_PREFIX_EXISTS) {
let field = expr[GUARD_PREFIX_EXISTS.len()..].trim();
let in_meta = context
.get(GUARD_VAR_INPUT)
.and_then(|i| i.as_object())
.is_some_and(|obj| {
obj.contains_key(field)
|| obj
.get(GUARD_PROP_METADATA)
.and_then(|m| m.as_object())
.is_some_and(|m| m.contains_key(field))
});
let in_vars = context
.get(GUARD_VAR_VARIABLES)
.and_then(|v| v.as_object())
.is_some_and(|v| v.contains_key(field));
let in_root = !is_reserved_root_key(field)
&& context.as_object().is_some_and(|o| o.contains_key(field));
return if in_meta || in_vars || in_root {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(expr.to_string())
};
}
if lower.starts_with(GUARD_PREFIX_TYPE) {
let expected = expr[GUARD_PREFIX_TYPE.len()..].trim();
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 if actual == Some(expected) {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(expr.to_string())
};
}
if let Some(rest) = expr.strip_prefix(GUARD_PREFIX_SIZE_CALL)
&& let Some(close) = rest.find(GUARD_RPAREN)
&& close > 0
&& let Some((op, rhs_str)) = split_cmp_tail(&rest[close + 1..])
{
let var_name = rest[..close].trim();
let len = match resolve_guard_value(var_name, context) {
Some(Value::String(s)) => s.chars().count(),
Some(Value::Array(a)) => a.len(),
Some(Value::Object(o)) => o.len(),
_ => 0,
};
let Some(rhs) = try_parse_rhs_token(rhs_str, context) else {
return GuardVerdict::Unmatched(expr.to_string());
};
return if compare_json_values(&Value::from(len as i64), op, &rhs) {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(expr.to_string())
};
}
let lhs_end = expr.bytes().take_while(|&b| is_lhs_byte(b)).count();
if lhs_end > 0
&& let Some((op, rhs_str)) = split_cmp_tail(&expr[lhs_end..])
{
let Some(rhs_val) = try_parse_rhs_token(rhs_str, context) else {
return GuardVerdict::Unmatched(expr.to_string());
};
let lhs_key = &expr[..lhs_end];
let lhs_val = resolve_guard_value(lhs_key, context)
.or_else(|| try_parse_rhs_token(lhs_key, context))
.unwrap_or_else(|| Value::String(lhs_key.to_string()));
return if compare_json_values(&lhs_val, op, &rhs_val) {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(expr.to_string())
};
}
if !is_reserved_root_key(expr)
&& let Some(val) = resolve_guard_value(expr, context)
{
let truth = match &val {
Value::Bool(b) => *b,
Value::Number(n) => n.as_f64().unwrap_or(0.0) != 0.0,
Value::String(s) => !s.is_empty(),
Value::Array(a) => !a.is_empty(),
Value::Object(o) => !o.is_empty(),
Value::Null => false,
};
return if truth {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(expr.to_string())
};
}
GuardVerdict::Unmatched(expr.to_string())
}
pub fn evaluate_guard(expression: &str, context: &Value) -> GuardVerdict {
match parse_guard_expression(expression.trim(), false) {
Ok(ast) => evaluate_guard_ast(&ast, &|atom| evaluate_guard_atom(atom, context)),
Err(_) => GuardVerdict::Unmatched(expression.to_string()),
}
}