Add Entity::into_inner method

Author: 0x00A5

cedar-policy-core/src/ast/entity.rs

@@ -356,6 +356,26 @@ impl Entity {
     pub fn add_ancestor(&mut self, uid: EntityUID) {
         self.ancestors.insert(uid);
     }
+
+    /// Consume the entity and return the entity's owned Uid, attributes and parents.
+    pub fn into_inner(
+        self,
+    ) -> (
+        EntityUID,
+        HashMap<SmolStr, PartialValue>,
+        HashSet<EntityUID>,
+    ) {
+        let Self {
+            uid,
+            attrs,
+            ancestors,
+        } = self;
+        (
+            uid,
+            attrs.into_iter().map(|(k, v)| (k, v.0)).collect(),
+            ancestors,
+        )
+    }
 }
 
 impl PartialEq for Entity {

cedar-policy/CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `wasm` Cargo feature for targeting Wasm
 - For the `partial-eval` experimental feature: added
 `Authorizer::evaluate_policies_partial()` (#474)
+- `Entity::into_inner` (resolving #636)
 
 ### Changed
 

cedar-policy/src/api.rs

@@ -210,6 +210,40 @@ impl Entity {
         };
         Some(Ok(EvalResult::from(v)))
     }
+
+    /// Consume the entity and return the entity's owned Uid, attributes and parents.
+    pub fn into_inner(
+        self,
+    ) -> (
+        EntityUid,
+        HashMap<String, RestrictedExpression>,
+        HashSet<EntityUid>,
+    ) {
+        let (uid, attrs, ancestors) = self.0.into_inner();
+
+        let attrs = attrs
+            .into_iter()
+            .map(|(k, v)| {
+                (
+                    k.to_string(),
+                    match v {
+                        ast::PartialValue::Value(val) => RestrictedExpression::new(
+                            ast::RestrictedExpr::new_unchecked(ast::Expr::from(val)),
+                        ),
+                        ast::PartialValue::Residual(exp) => {
+                            RestrictedExpression::new(ast::RestrictedExpr::new_unchecked(exp))
+                        }
+                    },
+                )
+            })
+            .collect();
+
+        (
+            EntityUid(uid),
+            attrs,
+            ancestors.into_iter().map(EntityUid).collect(),
+        )
+    }
 }
 
 impl std::fmt::Display for Entity {
@@ -759,7 +793,7 @@ impl Authorizer {
         EvaluationResponse {
             satisfied_permits: satisfied_permits.into_iter().map(PolicyId).collect(),
             satisfied_forbids: satisfied_forbids.into_iter().map(PolicyId).collect(),
-            errors: errors.into_iter().map(|e| e.into()).collect(),
+            errors: errors.into_iter().map(Into::into).collect(),
             permit_residuals: PolicySet::from_ast(permit_residuals),
             forbid_residuals: PolicySet::from_ast(forbid_residuals),
         }
@@ -3571,6 +3605,11 @@ impl RestrictedExpression {
             [src_expr],
         ))
     }
+
+    /// Create an expression from the AST expression
+    pub fn new(exp: ast::RestrictedExpr) -> Self {
+        Self(exp)
+    }
 }
 
 fn decimal_extension_name() -> ast::Name {

cedar-policy/src/tests.rs

@@ -1585,7 +1585,9 @@ mod entity_validate_tests {
             HashSet::new(),
         )
         .unwrap();
-        validate_entity(entity, &schema()).unwrap();
+        validate_entity(entity.clone(), &schema()).unwrap();
+        let (uid, attrs, parents) = entity.into_inner();
+        validate_entity(Entity::new(uid, attrs, parents).unwrap(), &schema()).unwrap();
     }
 
     #[test]