Method create_policy

libs/@local/graph/postgres-store/src/store/postgres/mod.rs:1422–1475

(
        &mut self,
        authenticated_actor: AuthenticatedActor,
        policy: PolicyCreationParams,
    )

    C: AsClient,
{
    async fn create_policy(
        &mut self,
        authenticated_actor: AuthenticatedActor,
        policy: PolicyCreationParams,
    ) -> Result<PolicyId, Report<CreatePolicyError>> {
        let transaction = self
            .transaction()
            .await
            .change_context(CreatePolicyError::StoreError)?;

        let policy_ids = transaction.insert_policies_into_database([&policy]).await?;
        let &[policy_id] = policy_ids.as_slice() else {
            unreachable!("Expected exactly one policy ID");
        };

        let policy_components = PolicyComponents::builder(&transaction)
            .with_actor(authenticated_actor)
            .with_action(ActionName::CreatePolicy, MergePolicies::No)
            .with_policy_meta_resource(&PolicyMetaResource {
                id: policy_id,
                actions: &policy.actions,
                resource: policy.resource.as_ref(),
            })
            .await
            .change_context(CreatePolicyError::BuildPolicyComponents)?;

        match policy_components
            .build_policy_set([ActionName::CreatePolicy])
            .change_context(CreatePolicyError::PolicySetCreation)?
            .evaluate(
                &Request {
                    actor: policy_components.actor_id(),
                    action: ActionName::CreatePolicy,
                    resource: &ResourceId::Policy(policy_id),
                    context: RequestContext::default(),
                },
                policy_components.context(),
            )
            .change_context(CreatePolicyError::StoreError)?
        {
            Authorized::Always => {}
            Authorized::Never => {
                return Err(Report::new(CreatePolicyError::NotAuthorized))
                    .attach(StatusCode::PermissionDenied);
            }
        }

        transaction
            .commit()
            .await
            .change_context(CreatePolicyError::StoreError)?;

        Ok(policy_id)
    }

    async fn get_policy_by_id(
        &self,