Skip to main content

qualia_core_db/poet_host/invoke/cooperative/
permits.rs

1//! `CooperativeDelegation.permits` — fail-closed ABAC over `delegation_permits`.
2
3use qualia_cooperative_core::agency_delegation::{
4    delegation_permits, AccessDecision, AccessRequest, AgencyDelegation,
5};
6use qualia_cooperative_core::agency_domain::agency_domain_taxonomy;
7use qualia_cooperative_core::trigger::TriggerContext;
8use vibe::{Span, Value};
9
10use super::super::args;
11use super::codec::decode_field;
12#[cfg(test)]
13use super::codec::encode_json;
14
15/// Evaluate whether a delegation permits an access request.
16///
17/// Args (record):
18/// - `delegation` — full [`AgencyDelegation`] JSON record
19/// - `request` — [`AccessRequest`] JSON record
20/// - `context` — optional [`TriggerContext`] (defaults to `now_unix: 0`)
21///
22/// Result: `{ permitted: bool, decision: "permit"|"deny", reason?: string }`
23pub fn permits(args_v: &Value, span: Span) -> Result<Value, vibe::Diagnostic> {
24    let delegation: AgencyDelegation =
25        decode_field(args_v, "delegation", span, "CooperativeDelegation.permits")?;
26    let request: AccessRequest =
27        decode_field(args_v, "request", span, "CooperativeDelegation.permits")?;
28    let ctx: TriggerContext = match args::rec(args_v, "context") {
29        Some(_) => decode_field(args_v, "context", span, "CooperativeDelegation.permits")?,
30        None => TriggerContext::at(0),
31    };
32
33    let domains = agency_domain_taxonomy();
34    let decision = delegation_permits(&delegation, &domains, &request, &ctx);
35    decision_value(&decision, span)
36}
37
38fn decision_value(decision: &AccessDecision, _span: Span) -> Result<Value, vibe::Diagnostic> {
39    match decision {
40        AccessDecision::Permit => Ok(args::record([
41            ("permitted", Value::Bool(true)),
42            ("decision", Value::String("permit".into())),
43        ])),
44        AccessDecision::Deny(reason) => Ok(args::record([
45            ("permitted", Value::Bool(false)),
46            ("decision", Value::String("deny".into())),
47            ("reason", Value::String(reason.clone())),
48        ])),
49    }
50}
51
52#[cfg(test)]
53mod tests {
54    use super::*;
55    use qualia_cooperative_core::agency_delegation::ConsentState;
56    use qualia_cooperative_core::agency_domain::ids as dom;
57    use std::collections::BTreeMap;
58
59    fn rec(pairs: &[(&str, Value)]) -> Value {
60        let mut m = BTreeMap::new();
61        for (k, v) in pairs {
62            m.insert((*k).into(), v.clone());
63        }
64        Value::Record(m)
65    }
66
67    fn granted_delegation(domain: &str) -> Value {
68        let mut d = AgencyDelegation::new("did:wf:alice", domain, "urn:un:hr:udhr", 100);
69        d.consent = ConsentState::Granted;
70        d.id = "test-delegation".into();
71        encode_json(&d, Span { start: 0, end: 0 }, "test").expect("encode delegation")
72    }
73
74    fn read_request(domain: &str) -> Value {
75        let req = AccessRequest {
76            domain: domain.into(),
77            data_class: "x".into(),
78            action: "read".into(),
79            sphere: Default::default(),
80            jurisdiction: None,
81            provenance: None,
82        };
83        encode_json(&req, Span { start: 0, end: 0 }, "test").expect("encode request")
84    }
85
86    #[test]
87    fn permits_when_valid_and_consented() {
88        let args_v = rec(&[
89            ("delegation", granted_delegation(dom::PERSONAL_WELFARE)),
90            ("request", read_request(dom::PERSONAL_WELFARE)),
91            ("context", rec(&[("now_unix", Value::U64(200))])),
92        ]);
93        let out = permits(&args_v, Span { start: 0, end: 0 }).expect("ok");
94        let Value::Record(m) = out else {
95            panic!("expected record");
96        };
97        assert_eq!(m.get("permitted"), Some(&Value::Bool(true)));
98        assert_eq!(m.get("decision"), Some(&Value::String("permit".into())));
99    }
100
101    #[test]
102    fn denies_wrong_domain_fail_closed() {
103        let args_v = rec(&[
104            ("delegation", granted_delegation(dom::FINANCIAL)),
105            ("request", read_request(dom::MEDICAL)),
106            ("context", rec(&[("now_unix", Value::U64(200))])),
107        ]);
108        let out = permits(&args_v, Span { start: 0, end: 0 }).expect("ok");
109        let Value::Record(m) = out else {
110            panic!("expected record");
111        };
112        assert_eq!(m.get("permitted"), Some(&Value::Bool(false)));
113        assert_eq!(m.get("decision"), Some(&Value::String("deny".into())));
114        assert!(matches!(m.get("reason"), Some(Value::String(s)) if !s.is_empty()));
115    }
116
117    #[test]
118    fn missing_delegation_fails_closed() {
119        let args_v = rec(&[("request", read_request(dom::PERSONAL_WELFARE))]);
120        let err = permits(&args_v, Span { start: 0, end: 0 }).expect_err("needs delegation");
121        assert!(err.message.contains("delegation"));
122    }
123}