use std::collections::HashSet;
use serde::Deserialize;
use serde_json::{Map, Value, json};
use crate::error::RpcError;
use crate::server::SharedConfium;
use confium_attributes::{SignerAttributes, evaluate, parse as dsl_parse};
#[derive(Debug, Deserialize)]
struct AttributesEvaluateRequest {
predicate: String,
signers: Vec<Map<String, Value>>,
}
fn signer_from_json(obj: &Map<String, Value>) -> Result<SignerAttributes, RpcError> {
let mut attrs = SignerAttributes::new();
for (key, value) in obj {
let arr = value.as_array().ok_or_else(|| RpcError::InvalidParams {
detail: format!("attribute '{key}' value must be a JSON array of strings"),
})?;
let mut set = HashSet::new();
for v in arr {
let s = v.as_str().ok_or_else(|| RpcError::InvalidParams {
detail: format!("attribute '{key}' has a non-string value"),
})?;
set.insert(s.to_string());
}
attrs.attrs.insert(key.clone(), set);
}
Ok(attrs)
}
pub async fn attributes_evaluate(
_cfm: SharedConfium,
params: Value,
) -> std::result::Result<Value, RpcError> {
let req: AttributesEvaluateRequest =
serde_json::from_value(params).map_err(|e| RpcError::InvalidParams {
detail: format!("attributes_evaluate params: {e}"),
})?;
let predicate = dsl_parse(&req.predicate).map_err(|e| RpcError::InvalidParams {
detail: format!("predicate parse error: {e}"),
})?;
let mut signers = Vec::with_capacity(req.signers.len());
for obj in &req.signers {
signers.push(signer_from_json(obj)?);
}
let refs: Vec<&SignerAttributes> = signers.iter().collect();
let satisfied = evaluate(&predicate, &refs);
Ok(json!({ "satisfied": satisfied }))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_util::test_confium;
#[tokio::test]
async fn attributes_evaluate_satisfied() {
let params = json!({
"predicate": "min_count(\"role:director\", 3)",
"signers": [
{"role:director": ["yes"]},
{"role:director": ["yes"]},
{"role:director": ["yes"]},
]
});
let result = attributes_evaluate(test_confium(), params).await.unwrap();
assert_eq!(result["satisfied"], json!(true));
}
#[tokio::test]
async fn attributes_evaluate_not_satisfied() {
let params = json!({
"predicate": "min_count(\"role:director\", 5)",
"signers": [
{"role:director": ["yes"]},
{"role:director": ["yes"]},
]
});
let result = attributes_evaluate(test_confium(), params).await.unwrap();
assert_eq!(result["satisfied"], json!(false));
}
#[tokio::test]
async fn attributes_evaluate_distinct_values() {
let params = json!({
"predicate": "min_distinct(\"region\", 3)",
"signers": [
{"region": ["europe"]},
{"region": ["americas"]},
{"region": ["asia-pacific"]},
]
});
let result = attributes_evaluate(test_confium(), params).await.unwrap();
assert_eq!(result["satisfied"], json!(true));
}
#[tokio::test]
async fn attributes_evaluate_rejects_bad_predicate() {
let params = json!({
"predicate": "bogus_function(\"arg\")",
"signers": [],
});
let result = attributes_evaluate(test_confium(), params).await;
assert!(result.is_err());
}
#[tokio::test]
async fn attributes_evaluate_rejects_missing_fields() {
let result = attributes_evaluate(test_confium(), json!({})).await;
assert!(result.is_err());
}
#[tokio::test]
async fn attributes_evaluate_rejects_non_array_signer_value() {
let params = json!({
"predicate": "any(\"x\")",
"signers": [{"x": "scalar"}],
});
let result = attributes_evaluate(test_confium(), params).await;
assert!(result.is_err());
}
}