Struct cedar_policy::Context

pub struct Context(/* private fields */);

the Context object for an authorization request

Implementations

impl Context

pub fn empty() -> Self

Create an empty Context

use cedar_policy::Context;
let c = Context::empty();
// let request: Request = Request::new(Some(principal), Some(action), Some(resource), c);

pub fn from_pairs( pairs: impl IntoIterator<Item = (String, RestrictedExpression)>, ) -> Self

Create a Context from a map of key to “restricted expression”, or a Vec of (key, restricted expression) pairs, or any other iterator of (key, restricted expression) pairs.

use cedar_policy::{Context, RestrictedExpression};
use std::collections::HashMap;
use std::str::FromStr;
let data : serde_json::Value = serde_json::json!({
    "sub": "1234",
    "groups": {
        "1234": {
            "group_id": "abcd",
            "group_name": "test-group"
        }
    }
});
let mut groups: HashMap<String, RestrictedExpression> = HashMap::new();
groups.insert("key".to_string(), RestrictedExpression::from_str(&data.to_string()).unwrap());
groups.insert("age".to_string(), RestrictedExpression::from_str("18").unwrap());
let context = Context::from_pairs(groups);
let request: Request = Request::new(Some(p), Some(a), Some(r), context);

pub fn from_json_str( json: &str, schema: Option<(&Schema, &EntityUid)>, ) -> Result<Self, ContextJsonError>

Create a Context from a string containing JSON (which must be a JSON object, not any other JSON type, or you will get an error here). JSON here must use the __entity and __extn escapes for entity references, extension values, etc.

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer). Since different Actions have different schemas for Context, you also must specify the Action for schema-based parsing.

use cedar_policy::{Context, RestrictedExpression};
use std::collections::HashMap;
use std::str::FromStr;
let data =r#"{
    "sub": "1234",
    "groups": {
        "1234": {
            "group_id": "abcd",
            "group_name": "test-group"
        }
    }
}"#;
let context = Context::from_json_str(data, None).unwrap();
let request: Request = Request::new(Some(p), Some(a), Some(r), context);

pub fn from_json_value( json: Value, schema: Option<(&Schema, &EntityUid)>, ) -> Result<Self, ContextJsonError>

Create a Context from a serde_json::Value (which must be a JSON object, not any other JSON type, or you will get an error here). JSON here must use the __entity and __extn escapes for entity references, extension values, etc.

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer). Since different Actions have different schemas for Context, you also must specify the Action for schema-based parsing.

use cedar_policy::{Context, RestrictedExpression, Schema};
use std::collections::HashMap;
use std::str::FromStr;
let data = serde_json::json!(
{
    "sub": "1234"
});
let schema_data =r#"
    {
      "": {
        "entityTypes": {},
          "actions": {
            "view": {
               "appliesTo": {
                 "principalTypes": [],
                  "resourceTypes": [],
                  "context": {
                    "type": "Record",
                    "attributes": {
                      "sub": { "type": "Long" }
                    }
                  }
                }
              }
          }
      }
    }"#;
let a_eid = EntityId::from_str("view").unwrap();
let a_name: EntityTypeName = EntityTypeName::from_str("Action").unwrap();
let action = EntityUid::from_type_name_and_id(a_name, a_eid);
let schema = Schema::from_str(schema_data).unwrap();
let context = Context::from_json_value(data, Some((&schema, &action))).unwrap();
let request: Request = Request::new(Some(principal), Some(action), Some(resource), context);

pub fn from_json_file( json: impl Read, schema: Option<(&Schema, &EntityUid)>, ) -> Result<Self, ContextJsonError>

Create a Context from a JSON file. The JSON file must contain a JSON object, not any other JSON type, or you will get an error here. JSON here must use the __entity and __extn escapes for entity references, extension values, etc.

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer). Since different Actions have different schemas for Context, you also must specify the Action for schema-based parsing.

let mut json = File::open("json_file.txt").expect("failed");
let context = Context::from_json_file(&json, None).unwrap();
let request: Request = Request::new(Some(p), Some(a), Some(r), context);

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Context

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl RefCast for Context

type From = Context

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self