Method into_future

libs/@local/graph/authorization/src/policies/components.rs:585–731

(mut self)

    #[tracing::instrument(level = "info", skip(self))]
    fn into_future(mut self) -> Self::IntoFuture {
        async move {
            let actor_id = match self.actor {
                AuthenticatedActor::Id(actor_id) => Some(actor_id),
                AuthenticatedActor::Uuid(actor_uuid) => self
                    .store
                    .determine_actor(actor_uuid)
                    .await
                    .change_context(ContextCreationError::DetermineActor {
                        actor_id: actor_uuid,
                    })?,
            };

            if let Some(actor_id) = actor_id {
                self.store
                    .build_principal_context(actor_id, &mut self.context)
                    .await
                    .change_context(ContextCreationError::BuildPrincipalContext { actor_id })?;
            } else {
                self.context.add_public_actor();
            }

            let entity_resources;
            let mut entity_type_ids = self.entity_type_ids;
            if !self.entity_edition_ids.is_empty() {
                entity_resources = self
                    .store
                    .build_entity_context(
                        &self.entity_edition_ids.iter().copied().collect::<Vec<_>>(),
                    )
                    .await
                    .change_context(ContextCreationError::BuildEntityContext {
                        entity_edition_ids: self.entity_edition_ids,
                    })?;
                for entity_resource in &entity_resources {
                    self.context.add_entity(entity_resource);
                    entity_type_ids.extend(entity_resource.entity_types.iter().map(Cow::Borrowed));
                }
            }

            let tracked_entity_types = if entity_type_ids.is_empty() {
                HashSet::new()
            } else {
                let entity_type_ids = entity_type_ids.iter().map(Cow::as_ref).collect::<Vec<_>>();
                let entity_type_resources = self
                    .store
                    .build_entity_type_context(&entity_type_ids)
                    .await
                    .change_context_lazy(|| ContextCreationError::BuildEntityTypeContext {
                        entity_type_ids: entity_type_ids.into_iter().cloned().collect(),
                    })?;
                for entity_type_resource in &entity_type_resources {
                    self.context.add_entity_type(entity_type_resource);
                }
                entity_type_resources
                    .into_iter()
                    .map(|resource| resource.id.into_owned().into_url())
                    .collect::<HashSet<_>>()