infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

infrahub/graphql/mutations/profile.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from graphene import Boolean, InputObjectType, Mutation, String
+from graphql import GraphQLResolveInfo
+from opentelemetry import trace
+from typing_extensions import Self
+
+from infrahub.core.manager import NodeManager
+from infrahub.core.schema import ProfileSchema
+from infrahub.graphql.types.context import ContextInput
+from infrahub.log import get_logger
+from infrahub.profiles.node_applier import NodeProfilesApplier
+from infrahub.workflows.catalogue import PROFILE_REFRESH_MULTIPLE
+
+from .main import InfrahubMutationMixin, InfrahubMutationOptions
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.database import InfrahubDatabase
+    from infrahub.graphql.initialization import GraphqlContext
+    from infrahub.services.adapters.workflow import InfrahubWorkflow
+
+log = get_logger()
+
+
+class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: ProfileSchema,
+        _meta: InfrahubMutationOptions | None = None,
+        **options: dict[str, Any],
+    ) -> None:
+        # Make sure schema is a valid NodeSchema Node Class
+        if not isinstance(schema, ProfileSchema):
+            raise ValueError(f"You need to pass a valid ProfileSchema in '{cls.__name__}.Meta', received '{schema}'")
+
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def _send_profile_refresh_workflows(
+        cls,
+        db: InfrahubDatabase,
+        workflow_service: InfrahubWorkflow,
+        branch_name: str,
+        obj: Node,
+        node_ids: list[str] | None = None,
+    ) -> None:
+        if not node_ids:
+            related_nodes = await obj.related_nodes.get_relationships(db=db)  # type: ignore[attr-defined]
+            node_ids = [rel.peer_id for rel in related_nodes]
+        if node_ids:
+            await workflow_service.submit_workflow(
+                workflow=PROFILE_REFRESH_MULTIPLE,
+                parameters={
+                    "branch_name": branch_name,
+                    "node_ids": node_ids,
+                },
+            )
+
+    @classmethod
+    def _get_profile_attr_values_map(cls, obj: Node) -> dict[str, Any]:
+        attr_values_map = {}
+        for attr_schema in obj.get_schema().attributes:
+            # profile name update can be ignored
+            if attr_schema.name == "profile_name":
+                continue
+            attr_values_map[attr_schema.name] = getattr(obj, attr_schema.name).value
+        return attr_values_map
+
+    @classmethod
+    async def _get_profile_related_node_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
+        related_nodes = await obj.related_nodes.get_relationships(db=db)  # type: ignore[attr-defined]
+        if related_nodes:
+            related_node_ids = {rel.peer_id for rel in related_nodes}
+        else:
+            related_node_ids = set()
+        return related_node_ids
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+        override_data: dict[str, Any] | None = None,
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
+        workflow_service = graphql_context.active_service.workflow
+
+        obj, mutation = await super().mutate_create(
+            info=info, data=data, branch=branch, database=database, override_data=override_data
+        )
+        await cls._send_profile_refresh_workflows(
+            db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj
+        )
+
+        return obj, mutation
+
+    @classmethod
+    async def _call_mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        db: InfrahubDatabase,
+        obj: Node,
+        skip_uniqueness_check: bool = False,
+    ) -> tuple[Node, Self]:
+        workflow_service = info.context.active_service.workflow
+        original_attr_values = cls._get_profile_attr_values_map(obj=obj)
+        original_related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+
+        obj, mutation = await super()._call_mutate_update(
+            info=info, data=data, branch=branch, db=db, obj=obj, skip_uniqueness_check=skip_uniqueness_check
+        )
+
+        updated_attr_values = cls._get_profile_attr_values_map(obj=obj)
+        updated_related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+
+        if original_attr_values != updated_attr_values:
+            await cls._send_profile_refresh_workflows(
+                db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj
+            )
+        elif updated_related_node_ids != original_related_node_ids:
+            removed_node_ids = original_related_node_ids - updated_related_node_ids
+            added_node_ids = updated_related_node_ids - original_related_node_ids
+            await cls._send_profile_refresh_workflows(
+                db=db,
+                workflow_service=workflow_service,
+                branch_name=branch.name,
+                obj=obj,
+                node_ids=list(removed_node_ids) + list(added_node_ids),
+            )
+
+        return obj, mutation
+
+    @classmethod
+    async def _delete_obj(cls, graphql_context: GraphqlContext, branch: Branch, obj: Node) -> list[Node]:
+        db = graphql_context.db
+        workflow_service = graphql_context.active_service.workflow
+        related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+        deleted = await super()._delete_obj(graphql_context=graphql_context, branch=branch, obj=obj)
+        await cls._send_profile_refresh_workflows(
+            db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj, node_ids=list(related_node_ids)
+        )
+        return deleted
+
+
+class ProfilesRefreshInput(InputObjectType):
+    id = String(required=False)
+
+
+class InfrahubProfilesRefresh(Mutation):
+    class Arguments:
+        data = ProfilesRefreshInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @trace.get_tracer(__name__).start_as_current_span("profiles_refresh")
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: ProfilesRefreshInput,
+        context: ContextInput | None = None,  # noqa: ARG003
+    ) -> Self:
+        graphql_context: GraphqlContext = info.context
+        db = graphql_context.db
+        branch = graphql_context.branch
+        obj = await NodeManager.get_one(
+            db=db,
+            branch=branch,
+            id=str(data.id),
+            include_source=True,
+        )
+        node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+        updated_fields = await node_profiles_applier.apply_profiles(node=obj)
+        if updated_fields:
+            await obj.save(db=db, fields=updated_fields)
+
+        return cls(ok=True)

infrahub/graphql/mutations/proposed_change.py

@@ -29,13 +29,14 @@ from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, Vali
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
 from infrahub.graphql.types.task import TaskInfo
-from infrahub.lock import InfrahubLock, build_object_lock_name
+from infrahub.lock import InfrahubLock
 from infrahub.proposed_change.approval_revoker import do_revoke_approvals_on_updated_pcs
 from infrahub.proposed_change.constants import ProposedChangeApprovalDecision, ProposedChangeState
 from infrahub.proposed_change.models import RequestProposedChangePipeline
 from infrahub.workers.dependencies import get_event_service
 from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE, REQUEST_PROPOSED_CHANGE_PIPELINE
 
+from ...core.node.lock_utils import build_object_lock_name
 from .main import InfrahubMutationOptions
 
 if TYPE_CHECKING:

infrahub/graphql/mutations/repository.py

@@ -7,14 +7,11 @@ import httpx
 from graphene import Boolean, Field, InputObjectType, Mutation, String
 
 from infrahub import config
-from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
+from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
-from infrahub.core.protocols import CoreGenericRepository, CoreReadOnlyRepository, CoreRepository
+from infrahub.core.protocols import CoreReadOnlyRepository, CoreRepository
 from infrahub.core.schema import NodeSchema
-from infrahub.exceptions import ValidationError
 from infrahub.git.models import (
-    GitRepositoryAdd,
-    GitRepositoryAddReadOnly,
     GitRepositoryImportObjects,
     GitRepositoryPullReadOnly,
 )
@@ -22,15 +19,15 @@ from infrahub.graphql.types.common import IdentifierInput
 from infrahub.log import get_logger
 from infrahub.message_bus import messages
 from infrahub.message_bus.messages.git_repository_connectivity import GitRepositoryConnectivityResponse
+from infrahub.repositories.create_repository import RepositoryFinalizer
 from infrahub.workflows.catalogue import (
     GIT_REPOSITORIES_IMPORT_OBJECTS,
     GIT_REPOSITORIES_PULL_READ_ONLY,
-    GIT_REPOSITORY_ADD,
-    GIT_REPOSITORY_ADD_READ_ONLY,
 )
 
+from ...core.node.create import create_node
 from ..types.task import TaskInfo
-from .main import InfrahubMutationMixin, InfrahubMutationOptions
+from .main import InfrahubMutationMixin, InfrahubMutationOptions, build_graphql_response
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -63,86 +60,28 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: InfrahubDatabase | None = None,  # noqa: ARG003
+        database: InfrahubDatabase | None = None,
         override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
-
         cleanup_payload(data)
-        # Create the object in the database
-        obj, result = await super().mutate_create(info, data, branch, override_data=override_data)
-        obj = cast(CoreGenericRepository, obj)
-
-        # First check the connectivity to the remote repository
-        # If the connectivity is not good, we remove the repository to allow the user to add a new one
-        if graphql_context.service:
-            message = messages.GitRepositoryConnectivity(
-                repository_name=obj.name.value,
-                repository_location=obj.location.value,
-            )
-            response = await graphql_context.service.message_bus.rpc(
-                message=message, response_class=GitRepositoryConnectivityResponse
-            )
-
-            if response.data.success is False:
-                await obj.delete(db=graphql_context.db)
-                raise ValidationError(response.data.message)
-
-        # If we are in the default branch, we set the sync status to Active
-        # If we are in another branch, we set the sync status to Staging
-        if branch.is_default:
-            obj.internal_status.value = RepositoryInternalStatus.ACTIVE.value
-        else:
-            obj.internal_status.value = RepositoryInternalStatus.STAGING.value
-        await obj.save(db=graphql_context.db)
-
-        # Create the new repository in the filesystem.
-        log.info("create_repository", name=obj.name.value)
-        authenticated_user = None
-        if graphql_context.account_session and graphql_context.account_session.authenticated:
-            authenticated_user = graphql_context.account_session.account_id
-        if obj.get_kind() == InfrahubKind.READONLYREPOSITORY:
-            obj = cast(CoreReadOnlyRepository, obj)
-            model = GitRepositoryAddReadOnly(
-                repository_id=obj.id,
-                repository_name=obj.name.value,
-                location=obj.location.value,
-                ref=obj.ref.value,
-                infrahub_branch_name=branch.name,
-                infrahub_branch_id=str(branch.get_uuid()),
-                internal_status=obj.internal_status.value,
-                created_by=authenticated_user,
-            )
-            if graphql_context.service:
-                await graphql_context.service.workflow.submit_workflow(
-                    workflow=GIT_REPOSITORY_ADD_READ_ONLY,
-                    context=graphql_context.get_context(),
-                    parameters={"model": model},
-                )
-
-        else:
-            obj = cast(CoreRepository, obj)
-            git_repo_add_model = GitRepositoryAdd(
-                repository_id=obj.id,
-                repository_name=obj.name.value,
-                location=obj.location.value,
-                default_branch_name=obj.default_branch.value,
-                infrahub_branch_name=branch.name,
-                infrahub_branch_id=str(branch.get_uuid()),
-                internal_status=obj.internal_status.value,
-                created_by=authenticated_user,
-            )
-
-            if graphql_context.service:
-                await graphql_context.service.workflow.submit_workflow(
-                    workflow=GIT_REPOSITORY_ADD,
-                    context=graphql_context.get_context(),
-                    parameters={"model": git_repo_add_model},
-                )
-
-        # TODO Validate that the creation of the repository went as expected
+        db = database or graphql_context.db
+        create_data = dict(data)
+        create_data.update(override_data or {})
+        obj = await create_node(data=create_data, db=db, branch=branch, schema=cls._meta.active_schema)
+
+        await RepositoryFinalizer(
+            account_session=graphql_context.active_account_session,
+            services=graphql_context.active_service,
+            context=graphql_context.get_context(),
+        ).post_create(
+            obj=obj,  # type: ignore
+            branch=branch,
+            db=db,
+        )
 
-        return obj, result
+        graphql_response = await build_graphql_response(info=info, db=db, obj=obj)
+        return obj, cls(**graphql_response)
 
     @classmethod
     async def mutate_update(

infrahub/graphql/mutations/webhook.py

@@ -127,7 +127,7 @@ class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
 
 
 def _validate_input(graphql_context: GraphqlContext, branch: Branch, input_data: WebhookCreate) -> None:
-    if input_data.node_kind:
+    if input_data.node_kind and input_data.node_kind.value:
         # Validate that the requested node_kind exists, will raise an error if not
         graphql_context.db.schema.get(name=input_data.node_kind.value, branch=branch, duplicate=False)
 

infrahub/graphql/registry.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from infrahub.core.timestamp import Timestamp
+from infrahub.exceptions import InitializationError
+
+if TYPE_CHECKING:
+    import graphene
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.graphql.manager import GraphQLSchemaManager, InterfaceReference
+
+    from .mutations.main import InfrahubMutation
+    from .types import InfrahubObject
+
+
+@dataclass
+class BranchDetails:
+    schema_changed_at: Timestamp
+    schema_hash: str
+    gql_manager: GraphQLSchemaManager
+
+
+@dataclass
+class GraphQLSchemaRegistry:
+    _branch_details_by_hash: dict[str, BranchDetails] = field(default_factory=dict)
+    _branch_name_by_hash: dict[str, set[str]] = field(default_factory=dict)
+    _branch_hash_activation_by_branch_name: dict[str, dict[str, str]] = field(default_factory=dict)
+    _registered_interface_types: dict[str, type[graphene.Interface]] = field(default_factory=dict)
+    _reference_hash_schema_map: dict[str, set[str]] = field(default_factory=dict)
+    _registered_edge_types: dict[str, type[InfrahubObject]] = field(default_factory=dict)
+    _registered_paginated_types: dict[str, type[InfrahubObject]] = field(default_factory=dict)
+    _registered_input_types: dict[str, type[graphene.InputObjectType]] = field(default_factory=dict)
+    _registered_object_types: dict[str, type[InfrahubObject]] = field(default_factory=dict)
+    _registered_mutation_types: dict[str, type[InfrahubMutation]] = field(default_factory=dict)
+
+    _manager_class: type[GraphQLSchemaManager] | None = None
+
+    def _add_branch_hash(self, branch_name: str, schema_hash: str) -> None:
+        if schema_hash not in self._branch_name_by_hash:
+            self._branch_name_by_hash[schema_hash] = set()
+
+        self._branch_name_by_hash[schema_hash].add(branch_name)
+
+    def _register_manager(self, manager: type[GraphQLSchemaManager]) -> None:
+        self._manager_class = manager
+
+    @property
+    def manager(self) -> type[GraphQLSchemaManager]:
+        if self._manager_class:
+            return self._manager_class
+        raise InitializationError
+
+    def clear_cache(self) -> None:
+        """Clear internal cache stored within this registry."""
+        self._branch_details_by_hash = {}
+        self._branch_name_by_hash = {}
+        self._branch_hash_activation_by_branch_name = {}
+        self._registered_interface_types = {}
+        self._reference_hash_schema_map = {}
+        self._registered_edge_types = {}
+        self._registered_paginated_types = {}
+        self._registered_input_types = {}
+        self._registered_object_types = {}
+        self._registered_mutation_types = {}
+
+    def _add_schema_to_reference_hash(self, reference_hash: str, schema_hash: str) -> None:
+        """Add the schema hash to a map containing the referenced object.
+
+        The goal of this is to be able to see all schemas that use a given reference type,
+        once no schemas use a specific type it's safe to remove the type from the registry.
+        """
+        if reference_hash not in self._reference_hash_schema_map:
+            self._reference_hash_schema_map[reference_hash] = set()
+        self._reference_hash_schema_map[reference_hash].add(schema_hash)
+
+    def get_edge_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubObject] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_edge_types.get(reference_hash)
+
+    def set_edge_type(self, reference: type[InfrahubObject], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_edge_types[reference_hash] = reference
+
+    def get_input_type(self, reference_hash: str, schema_hash: str) -> type[graphene.InputObjectType] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_input_types.get(reference_hash)
+
+    def set_input_type(self, reference: type[graphene.InputObjectType], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_input_types[reference_hash] = reference
+
+    def get_interface_type(self, reference_hash: str, schema_hash: str) -> type[graphene.Interface] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_interface_types.get(reference_hash)
+
+    def set_interface_type(self, reference: InterfaceReference, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference.reference_hash, schema_hash=schema_hash)
+        self._registered_interface_types[reference.reference_hash] = reference.reference
+
+    def get_mutation_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubMutation] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_mutation_types.get(reference_hash)
+
+    def set_mutation_type(self, reference: type[InfrahubMutation], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_mutation_types[reference_hash] = reference
+
+    def get_object_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubObject] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_object_types.get(reference_hash)
+
+    def set_object_type(self, reference: type[InfrahubObject], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_object_types[reference_hash] = reference
+
+    def get_paginated_type(self, reference_hash: str, schema_hash: str) -> type[InfrahubObject] | None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        return self._registered_paginated_types.get(reference_hash)
+
+    def set_paginated_type(self, reference: type[InfrahubObject], reference_hash: str, schema_hash: str) -> None:
+        self._add_schema_to_reference_hash(reference_hash=reference_hash, schema_hash=schema_hash)
+        self._registered_paginated_types[reference_hash] = reference
+
+    def purge_inactive(self, active_branches: list[str]) -> set[str]:
+        """Return inactive branches that were purged"""
+        inactive_branches: set[str] = set()
+        for schema_hash in list(self._branch_name_by_hash.keys()):
+            branches = list(self._branch_name_by_hash[schema_hash])
+            for branch in branches:
+                if branch not in active_branches and branch in self._branch_name_by_hash[schema_hash]:
+                    inactive_branches.add(branch)
+                    self._branch_name_by_hash[schema_hash].discard(branch)
+
+        for schema_hash in list(self._branch_name_by_hash.keys()):
+            if not self._branch_name_by_hash[schema_hash]:
+                # If no remaining branch is using the schema remove it completely
+                del self._branch_name_by_hash[schema_hash]
+                del self._branch_details_by_hash[schema_hash]
+
+        return inactive_branches
+
+    def cache_branch(self, branch: Branch, schema_branch: SchemaBranch, schema_hash: str) -> BranchDetails:
+        branch_details = BranchDetails(
+            schema_changed_at=Timestamp(branch.schema_changed_at) if branch.schema_changed_at else Timestamp(),
+            schema_hash=schema_hash,
+            gql_manager=self.manager(schema=schema_branch),
+        )
+
+        self._branch_details_by_hash[schema_hash] = branch_details
+
+        return branch_details
+
+    def get_manager_for_branch(self, branch: Branch, schema_branch: SchemaBranch) -> GraphQLSchemaManager:
+        if branch.schema_hash:
+            schema_hash = branch.schema_hash.main
+        else:
+            schema_hash = schema_branch.get_hash()
+
+        if schema_hash in self._branch_details_by_hash:
+            branch_details = self._branch_details_by_hash[schema_hash]
+        else:
+            branch_details = self.cache_branch(branch=branch, schema_branch=schema_branch, schema_hash=schema_hash)
+
+        self._add_branch_hash(branch_name=branch.name, schema_hash=schema_hash)
+
+        return branch_details.gql_manager
+
+
+registry = GraphQLSchemaRegistry()

infrahub/graphql/schema.py

@@ -15,11 +15,12 @@ from .mutations.branch import (
     BranchUpdate,
     BranchValidate,
 )
-from .mutations.computed_attribute import UpdateComputedAttribute
+from .mutations.computed_attribute import RecomputeComputedAttribute, UpdateComputedAttribute
 from .mutations.convert_object_type import ConvertObjectType
 from .mutations.diff import DiffUpdateMutation
 from .mutations.diff_conflict import ResolveDiffConflict
 from .mutations.generator import GeneratorDefinitionRequestRun
+from .mutations.profile import InfrahubProfilesRefresh
 from .mutations.proposed_change import (
     ProposedChangeCheckForApprovalRevoke,
     ProposedChangeMerge,
@@ -113,6 +114,7 @@ class InfrahubBaseMutation(ObjectType):
     InfrahubRepositoryProcess = ProcessRepository.Field()
     InfrahubRepositoryConnectivity = ValidateRepositoryConnectivity.Field()
     InfrahubUpdateComputedAttribute = UpdateComputedAttribute.Field()
+    InfrahubRecomputeComputedAttribute = RecomputeComputedAttribute.Field()
 
     RelationshipAdd = RelationshipAdd.Field()
     RelationshipRemove = RelationshipRemove.Field()
@@ -124,3 +126,4 @@ class InfrahubBaseMutation(ObjectType):
 
     ConvertObjectType = ConvertObjectType.Field()
     CoreProposedChangeCheckForApprovalRevoke = ProposedChangeCheckForApprovalRevoke.Field()
+    InfrahubProfilesRefresh = InfrahubProfilesRefresh.Field()