pub use wami_core::error;
pub mod context;
pub mod evaluator;
pub mod keys;
pub mod operators;
mod validate;
#[cfg(test)]
mod tests;
pub use context::ConditionContext;
pub use evaluator::{evaluate_condition_block, ConditionError};
pub use keys::get_context_value;
pub use operators::ConditionOperator;
use serde_json::Value;
use std::collections::HashMap;
pub type ConditionBlock = HashMap<String, HashMap<String, ConditionValue>>;
#[derive(Debug, Clone, PartialEq)]
pub enum ConditionValue {
String(String),
Number(f64),
Boolean(bool),
Array(Vec<String>),
}
impl ConditionValue {
pub fn kind(&self) -> &'static str {
match self {
ConditionValue::String(_) => "String",
ConditionValue::Number(_) => "Number",
ConditionValue::Boolean(_) => "Boolean",
ConditionValue::Array(_) => "Array",
}
}
fn mismatch(&self, expected: &str) -> ConditionError {
ConditionError::TypeMismatch {
expected: expected.to_string(),
actual: self.kind().to_string(),
}
}
pub fn as_string(&self) -> Result<String, ConditionError> {
match self {
ConditionValue::String(s) => Ok(s.clone()),
ConditionValue::Number(n) => Ok(n.to_string()),
ConditionValue::Boolean(b) => Ok(b.to_string()),
ConditionValue::Array(_) => Err(self.mismatch("String")),
}
}
pub fn as_number(&self) -> Result<f64, ConditionError> {
match self {
ConditionValue::Number(n) if n.is_finite() => Ok(*n),
ConditionValue::String(s) => s
.parse::<f64>()
.ok()
.filter(|n| n.is_finite())
.ok_or_else(|| self.mismatch("a finite Number")),
_ => Err(self.mismatch("a finite Number")),
}
}
pub fn as_boolean(&self) -> Result<bool, ConditionError> {
match self {
ConditionValue::Boolean(b) => Ok(*b),
ConditionValue::String(s) => match s.as_str() {
"true" => Ok(true),
"false" => Ok(false),
_ => Err(ConditionError::InvalidBooleanValue),
},
_ => Err(self.mismatch("Boolean")),
}
}
pub fn as_array(&self) -> Result<&Vec<String>, ConditionError> {
match self {
ConditionValue::Array(arr) => Ok(arr),
_ => Err(self.mismatch("Array")),
}
}
}
impl From<Value> for ConditionValue {
fn from(value: Value) -> Self {
match value {
Value::String(s) => ConditionValue::String(s),
Value::Number(n) => ConditionValue::Number(n.as_f64().unwrap_or(0.0)),
Value::Bool(b) => ConditionValue::Boolean(b),
Value::Array(arr) => {
let strings: Vec<String> = arr
.into_iter()
.filter_map(|v| v.as_str().map(String::from))
.collect();
ConditionValue::Array(strings)
}
Value::Null => ConditionValue::String("".to_string()),
Value::Object(_) => ConditionValue::String("".to_string()), }
}
}
pub mod wami {
pub mod policies {
pub mod condition {
pub use crate::{
context, evaluate_condition_block, evaluator, get_context_value, keys, operators,
ConditionBlock, ConditionContext, ConditionOperator, ConditionValue,
};
}
}
}