infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub/graphql/mutations/relationship.py

@@ -1,35 +1,56 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from enum import Enum
+from typing import TYPE_CHECKING, Self
 
 from graphene import Boolean, InputField, InputObjectType, List, Mutation, String
 from infrahub_sdk.utils import compare_lists
 
-from infrahub.core.constants import InfrahubKind, RelationshipCardinality
+from infrahub import config
+from infrahub.core.account import GlobalPermission, ObjectPermission
+from infrahub.core.changelog.models import NodeChangelog
+from infrahub.core.constants import (
+    InfrahubKind,
+    MutationAction,
+    PermissionAction,
+    PermissionDecision,
+    RelationshipCardinality,
+)
 from infrahub.core.manager import NodeManager
+from infrahub.core.query.node import NodeGetKindQuery
 from infrahub.core.query.relationship import (
     RelationshipGetPeerQuery,
     RelationshipPeerData,
 )
 from infrahub.core.relationship import Relationship
 from infrahub.database import retry_db_transaction
+from infrahub.events import EventMeta, NodeMutatedEvent
+from infrahub.events.group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent
+from infrahub.events.models import EventNode
 from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.permissions import get_global_permission_for_kind
 
 from ..types import RelatedNodeInput
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
+    from infrahub.core.node import Node
     from infrahub.core.relationship import RelationshipManager
+    from infrahub.core.schema.relationship_schema import RelationshipSchema
 
     from ..initialization import GraphqlContext
 
 
-# pylint: disable=unused-argument,too-many-branches
-
 RELATIONSHIP_PEERS_TO_IGNORE = [InfrahubKind.NODE]
 
 
+class GroupUpdateType(str, Enum):
+    NONE = "none"
+    MEMBERS = "members"
+    MEMBER_OF_GROUPS = "member_of_groups"
+
+
 class RelationshipNodesInput(InputObjectType):
     id = InputField(String(required=True), description="ID of the node at the source of the relationship")
     name = InputField(String(required=True), description="Name of the relationship to add or remove nodes")
@@ -38,131 +59,307 @@ class RelationshipNodesInput(InputObjectType):
     )
 
 
-class RelationshipMixin:
+class RelationshipAdd(Mutation):
+    class Arguments:
+        data = RelationshipNodesInput(required=True)
+
+    ok = Boolean()
+
     @classmethod
+    @retry_db_transaction(name="relationship_add")
     async def mutate(
         cls,
-        root: dict,
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: RelationshipNodesInput,
-    ):
-        context: GraphqlContext = info.context
-        input_id = str(data.id)
-
-        if not (
-            source := await NodeManager.get_one(
-                db=context.db,
-                id=input_id,
-                branch=context.branch,
-                include_owner=True,
-                include_source=True,
-            )
-        ):
-            raise NodeNotFoundError(context.branch, None, input_id)
-
-        # Check if the name of the relationship provided exist for this node and is of cardinality Many
-        if data.get("name") not in source._schema.relationship_names:
-            raise ValidationError(
-                {"name": f"'{data.get('name')}' is not a valid relationship for '{source.get_kind()}'"}
-            )
-
-        rel_schema = source._schema.get_relationship(name=data.get("name"))
-        if rel_schema.cardinality != RelationshipCardinality.MANY:
-            raise ValidationError({"name": f"'{data.get('name')}' must be a relationship of cardinality Many"})
-
-        # Query the node in the database and validate that all of them exist and are if the correct kind
-        node_ids: list[str] = [node_data["id"] for node_data in data.get("nodes") if "id" in node_data]
-        nodes = await NodeManager.get_many(
-            db=context.db, ids=node_ids, fields={"display_label": None}, branch=context.branch
+    ) -> Self:
+        graphql_context: GraphqlContext = info.context
+        relationship_name = str(data.name)
+
+        source = await _validate_node(info=info, data=data)
+        nodes = await _validate_peers(info=info, data=data)
+        await _validate_permissions(info=info, source_node=source, peers=nodes)
+        await _validate_peer_types(info=info, data=data, source_node=source, peers=nodes)
+
+        rel_schema = source.get_schema().get_relationship(name=relationship_name)
+        display_label: str = await source.render_display_label(db=graphql_context.db)
+        node_changelog = NodeChangelog(
+            node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
         )
 
-        _, _, in_list2 = compare_lists(list1=list(nodes.keys()), list2=node_ids)
-        if in_list2:
-            for node_id in in_list2:
-                raise ValidationError(f"{node_id!r}: Unable to find the node in the database.")
-
-        for node_id, node in nodes.items():
-            if rel_schema.peer in RELATIONSHIP_PEERS_TO_IGNORE:
-                continue
-            if rel_schema.peer not in node.get_labels():
-                raise ValidationError(f"{node_id!r} {node.get_kind()!r} is not a valid peer for '{rel_schema.peer}'")
-
-            peer_relationships = [rel for rel in node._schema.relationships if rel.identifier == rel_schema.identifier]
-            if (
-                rel_schema.identifier
-                and len(peer_relationships) == 1
-                and peer_relationships[0].cardinality == RelationshipCardinality.ONE
-            ):
-                peer_relationship: RelationshipManager = getattr(node, peer_relationships[0].name)
-                if peer := await peer_relationship.get_peer(db=context.db):
-                    if peer.id != input_id:
-                        raise ValidationError(
-                            f"{node_id!r} {node.get_kind()!r} is already related to another peer on '{peer_relationships[0].name}'"
+        existing_peers = await _collect_current_peers(info=info, data=data, source_node=source)
+
+        async with graphql_context.db.start_transaction() as db:
+            peers: list[EventNode] = []
+            for node_data in data.get("nodes"):
+                # Instantiate and resolve a relationship
+                # This will take care of allocating a node from a pool if needed
+                rel = Relationship(schema=rel_schema, branch=graphql_context.branch, node=source)
+                await rel.new(db=db, data=node_data)
+                await rel.resolve(db=db)
+                # Save it only if it does not exist
+                if rel.get_peer_id() not in existing_peers.keys():
+                    peers.append(EventNode(id=rel.get_peer_id(), kind=rel.get_peer_kind()))
+                    node_changelog.create_relationship(relationship=rel)
+                    await rel.save(db=db)
+
+        if config.SETTINGS.broker.enable and graphql_context.background and node_changelog.has_changes:
+            group_event_type = _get_group_event_type(
+                node=source, relationship_schema=rel_schema, relationship_name=relationship_name
+            )
+            if group_event_type == GroupUpdateType.MEMBERS:
+                group_add_event = GroupMemberAddedEvent(
+                    node_id=source.id,
+                    kind=source.get_schema().kind,
+                    members=peers,
+                    meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
+                )
+                graphql_context.background.add_task(graphql_context.active_service.event.send, group_add_event)
+
+            elif group_event_type == GroupUpdateType.MEMBER_OF_GROUPS:
+                group_ids = [node.id for node in peers]
+                async with graphql_context.db.start_session() as db:
+                    node_kind_query = await NodeGetKindQuery.init(db=db, branch=graphql_context.branch, ids=group_ids)
+                    await node_kind_query.execute(db=db)
+                    node_kind_map = await node_kind_query.get_node_kind_map()
+
+                    for node_id, node_kind in node_kind_map.items():
+                        group_add_event = GroupMemberAddedEvent(
+                            node_id=node_id,
+                            kind=node_kind,
+                            members=[EventNode(id=source.get_id(), kind=source.get_kind())],
+                            meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
                         )
-
-        # The nodes that are already present in the db
-        query = await RelationshipGetPeerQuery.init(
-            db=context.db,
-            source=source,
-            rel=Relationship(schema=rel_schema, branch=context.branch, node=source),
-        )
-        await query.execute(db=context.db)
-        existing_peers: dict[str, RelationshipPeerData] = {peer.peer_id: peer for peer in query.get_peers()}
-
-        async with context.db.start_transaction() as db:
-            if cls.__name__ == "RelationshipAdd":
-                for node_data in data.get("nodes"):
-                    # Instantiate and resolve a relationship
-                    # This will take care of allocating a node from a pool if needed
-                    rel = Relationship(schema=rel_schema, branch=context.branch, node=source)
-                    await rel.new(db=db, data=node_data)
-                    await rel.resolve(db=db)
-                    # Save it only if it does not exist
-                    if rel.get_peer_id() not in existing_peers.keys():
-                        await rel.save(db=db)
-
-            elif cls.__name__ == "RelationshipRemove":
-                for node_data in data.get("nodes"):
-                    if node_data.get("id") in existing_peers.keys():
-                        # TODO once https://github.com/opsmill/infrahub/issues/792 has been fixed
-                        # we should use RelationshipDataDeleteQuery to delete the relationship
-                        # it would be more query efficient
-                        rel = Relationship(schema=rel_schema, branch=context.branch, node=source)
-                        await rel.load(db=db, data=existing_peers[node_data.get("id")])
-                        await rel.delete(db=db)
+                        graphql_context.background.add_task(graphql_context.active_service.event.send, group_add_event)
+
+            else:
+                event = NodeMutatedEvent(
+                    kind=source.get_schema().kind,
+                    node_id=source.id,
+                    data=node_changelog,
+                    action=MutationAction.UPDATED,
+                    fields=[relationship_name],
+                    meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
+                )
+                graphql_context.background.add_task(graphql_context.active_service.event.send, event)
 
         return cls(ok=True)
 
 
-class RelationshipAdd(RelationshipMixin, Mutation):
+class RelationshipRemove(Mutation):
     class Arguments:
         data = RelationshipNodesInput(required=True)
 
     ok = Boolean()
 
     @classmethod
-    @retry_db_transaction(name="relationship_add")
+    @retry_db_transaction(name="relationship_remove")
     async def mutate(
         cls,
-        root: dict,
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: RelationshipNodesInput,
-    ):
-        return await super().mutate(root=root, info=info, data=data)
+    ) -> Self:
+        graphql_context: GraphqlContext = info.context
+        relationship_name = str(data.name)
+
+        source = await _validate_node(info=info, data=data)
+        nodes = await _validate_peers(info=info, data=data)
+        await _validate_permissions(info=info, source_node=source, peers=nodes)
+        await _validate_peer_types(info=info, data=data, source_node=source, peers=nodes)
+
+        rel_schema = source.get_schema().get_relationship(name=relationship_name)
+        display_label: str = await source.render_display_label(db=graphql_context.db)
+        node_changelog = NodeChangelog(
+            node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
+        )
+
+        existing_peers = await _collect_current_peers(info=info, data=data, source_node=source)
+
+        async with graphql_context.db.start_transaction() as db:
+            peers: list[EventNode] = []
+
+            for node_data in data.get("nodes"):
+                if node_data.get("id") in existing_peers.keys():
+                    # TODO once https://github.com/opsmill/infrahub/issues/792 has been fixed
+                    # we should use RelationshipDataDeleteQuery to delete the relationship
+                    # it would be more query efficient
+                    rel = Relationship(schema=rel_schema, branch=graphql_context.branch, node=source)
+                    await rel.load(db=db, data=existing_peers[node_data.get("id")])
+                    peers.append(EventNode(id=rel.get_peer_id(), kind=rel.get_peer_kind()))
+                    node_changelog.delete_relationship(relationship=rel)
+                    await rel.delete(db=db)
+
+        if config.SETTINGS.broker.enable and graphql_context.background and node_changelog.has_changes:
+            group_event_type = _get_group_event_type(
+                node=source, relationship_schema=rel_schema, relationship_name=relationship_name
+            )
+            if group_event_type == GroupUpdateType.MEMBERS:
+                group_remove_event = GroupMemberRemovedEvent(
+                    node_id=source.id,
+                    kind=source.get_schema().kind,
+                    members=peers,
+                    meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
+                )
+                graphql_context.background.add_task(graphql_context.active_service.event.send, group_remove_event)
+            elif group_event_type == GroupUpdateType.MEMBER_OF_GROUPS:
+                group_ids = [node.id for node in peers]
+                async with graphql_context.db.start_session() as db:
+                    node_kind_query = await NodeGetKindQuery.init(db=db, branch=graphql_context.branch, ids=group_ids)
+                    await node_kind_query.execute(db=db)
+                    node_kind_map = await node_kind_query.get_node_kind_map()
+
+                    for node_id, node_kind in node_kind_map.items():
+                        group_remove_event = GroupMemberRemovedEvent(
+                            node_id=node_id,
+                            kind=node_kind,
+                            members=[EventNode(id=source.get_id(), kind=source.get_kind())],
+                            meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
+                        )
+                        graphql_context.background.add_task(
+                            graphql_context.active_service.event.send, group_remove_event
+                        )
+            else:
+                event = NodeMutatedEvent(
+                    kind=source.get_schema().kind,
+                    node_id=source.id,
+                    data=node_changelog,
+                    action=MutationAction.UPDATED,
+                    fields=[relationship_name],
+                    meta=EventMeta(branch=graphql_context.branch, context=graphql_context.get_context()),
+                )
+                graphql_context.background.add_task(graphql_context.active_service.event.send, event)
 
+        return cls(ok=True)
 
-class RelationshipRemove(RelationshipMixin, Mutation):
-    class Arguments:
-        data = RelationshipNodesInput(required=True)
 
-    ok = Boolean()
+async def _validate_node(info: GraphQLResolveInfo, data: RelationshipNodesInput) -> Node:
+    graphql_context: GraphqlContext = info.context
+    input_id = str(data.id)
+    relationship_name = str(data.name)
 
-    @classmethod
-    @retry_db_transaction(name="relationship_remove")
-    async def mutate(
-        cls,
-        root: dict,
-        info: GraphQLResolveInfo,
-        data: RelationshipNodesInput,
+    if not (
+        source := await NodeManager.get_one(
+            db=graphql_context.db,
+            id=input_id,
+            branch=graphql_context.branch,
+            include_owner=False,
+            include_source=False,
+        )
     ):
-        return await super().mutate(root=root, info=info, data=data)
+        raise NodeNotFoundError(node_type="node", identifier=input_id, branch_name=graphql_context.branch.name)
+
+    # Check if the name of the relationship provided exist for this node and is of cardinality Many
+    if relationship_name not in source.get_schema().relationship_names:
+        raise ValidationError({"name": f"'{relationship_name}' is not a valid relationship for '{source.get_kind()}'"})
+
+    rel_schema = source.get_schema().get_relationship(name=relationship_name)
+    if rel_schema.cardinality != RelationshipCardinality.MANY:
+        raise ValidationError({"name": f"'{relationship_name}' must be a relationship of cardinality Many"})
+
+    return source
+
+
+async def _validate_peers(info: GraphQLResolveInfo, data: RelationshipNodesInput) -> dict[str, Node]:
+    graphql_context: GraphqlContext = info.context
+
+    # Query the node in the database and validate that all of them exist and are if the correct kind
+    node_ids: list[str] = [node_data["id"] for node_data in data.get("nodes") if "id" in node_data]
+    nodes = await NodeManager.get_many(
+        db=graphql_context.db, ids=node_ids, fields={"display_label": None}, branch=graphql_context.branch
+    )
+    _, _, in_list2 = compare_lists(list1=list(nodes.keys()), list2=node_ids)
+    if in_list2:
+        for node_id in in_list2:
+            raise ValidationError(f"{node_id!r}: Unable to find the node in the database.")
+    return nodes
+
+
+async def _validate_permissions(info: GraphQLResolveInfo, source_node: Node, peers: dict[str, Node]) -> None:
+    graphql_context: GraphqlContext = info.context
+
+    if graphql_context.account_session:
+        impacted_schemas = {node.get_schema() for node in [source_node] + list(peers.values())}
+        required_permissions: list[GlobalPermission | ObjectPermission] = []
+        decision = (
+            PermissionDecision.ALLOW_DEFAULT.value
+            if graphql_context.branch.is_default
+            else PermissionDecision.ALLOW_OTHER.value
+        )
+
+        for impacted_schema in impacted_schemas:
+            global_action = get_global_permission_for_kind(schema=impacted_schema)
+
+            if global_action:
+                required_permissions.append(GlobalPermission(action=global_action, decision=decision))
+            else:
+                required_permissions.append(
+                    ObjectPermission(
+                        namespace=impacted_schema.namespace,
+                        name=impacted_schema.name,
+                        action=PermissionAction.UPDATE.value,
+                        decision=decision,
+                    )
+                )
+
+        graphql_context.active_permissions.raise_for_permissions(permissions=required_permissions)
+
+
+async def _validate_peer_types(
+    info: GraphQLResolveInfo, data: RelationshipNodesInput, source_node: Node, peers: dict[str, Node]
+) -> None:
+    graphql_context: GraphqlContext = info.context
+    relationship_name = str(data.name)
+    input_id = str(data.id)
+    rel_schema = source_node.get_schema().get_relationship(name=relationship_name)
+    for node_id, node in peers.items():
+        if rel_schema.peer in RELATIONSHIP_PEERS_TO_IGNORE:
+            continue
+        if rel_schema.peer not in node.get_labels():
+            raise ValidationError(f"{node_id!r} {node.get_kind()!r} is not a valid peer for '{rel_schema.peer}'")
+
+        peer_relationships = [rel for rel in node.get_schema().relationships if rel.identifier == rel_schema.identifier]
+        if (
+            rel_schema.identifier
+            and len(peer_relationships) == 1
+            and peer_relationships[0].cardinality == RelationshipCardinality.ONE
+        ):
+            peer_relationship: RelationshipManager = getattr(node, peer_relationships[0].name)
+            if peer := await peer_relationship.get_peer(db=graphql_context.db):
+                if peer.id != input_id:
+                    raise ValidationError(
+                        f"{node_id!r} {node.get_kind()!r} is already related to another peer on '{peer_relationships[0].name}'"
+                    )
+
+
+async def _collect_current_peers(
+    info: GraphQLResolveInfo, data: RelationshipNodesInput, source_node: Node
+) -> dict[str, RelationshipPeerData]:
+    graphql_context: GraphqlContext = info.context
+    relationship_name = str(data.name)
+
+    rel_schema = source_node.get_schema().get_relationship(name=relationship_name)
+
+    # The nodes that are already present in the db
+    query = await RelationshipGetPeerQuery.init(
+        db=graphql_context.db,
+        source=source_node,
+        rel=Relationship(schema=rel_schema, branch=graphql_context.branch, node=source_node),
+    )
+    await query.execute(db=graphql_context.db)
+    return {str(peer.peer_id): peer for peer in query.get_peers()}
+
+
+def _get_group_event_type(
+    node: Node, relationship_schema: RelationshipSchema, relationship_name: str
+) -> GroupUpdateType:
+    group_event_type = GroupUpdateType.NONE
+    if relationship_schema.identifier == "group_member":
+        if "CoreGroup" in node.get_schema().inherit_from and relationship_name == "members":
+            # Updating members of a group
+            group_event_type = GroupUpdateType.MEMBERS
+
+        elif relationship_name == "member_of_groups":
+            # Modifying the membership of the current node
+            group_event_type = GroupUpdateType.MEMBER_OF_GROUPS
+    return group_event_type

infrahub/graphql/mutations/repository.py

@@ -45,7 +45,7 @@ log = get_logger()
 
 class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(cls, schema: Optional[NodeSchema] = None, _meta=None, **options):  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(cls, schema: Optional[NodeSchema] = None, _meta=None, **options):
         # Make sure schema is a valid NodeSchema Node Class
         if not isinstance(schema, NodeSchema):
             raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
@@ -63,9 +63,9 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
     ):
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         cleanup_payload(data)
         # Create the object in the database
@@ -74,17 +74,17 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
 
         # 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 context.service:
+        if graphql_context.service:
             message = messages.GitRepositoryConnectivity(
                 repository_name=obj.name.value,
                 repository_location=obj.location.value,
             )
-            response = await context.service.message_bus.rpc(
+            response = await graphql_context.service.message_bus.rpc(
                 message=message, response_class=GitRepositoryConnectivityResponse
             )
 
             if response.data.success is False:
-                await obj.delete(db=context.db)
+                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
@@ -93,13 +93,13 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
             obj.internal_status.value = RepositoryInternalStatus.ACTIVE.value
         else:
             obj.internal_status.value = RepositoryInternalStatus.STAGING.value
-        await obj.save(db=context.db)
+        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 context.account_session and context.account_session.authenticated:
-            authenticated_user = context.account_session.account_id
+        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(
@@ -112,9 +112,11 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
                 internal_status=obj.internal_status.value,
                 created_by=authenticated_user,
             )
-            if context.service:
-                await context.service.workflow.submit_workflow(
-                    workflow=GIT_REPOSITORY_ADD_READ_ONLY, parameters={"model": model}
+            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:
@@ -130,9 +132,11 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
                 created_by=authenticated_user,
             )
 
-            if context.service:
-                await context.service.workflow.submit_workflow(
-                    workflow=GIT_REPOSITORY_ADD, parameters={"model": git_repo_add_model}
+            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
@@ -145,15 +149,15 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
         node: Optional[Node] = None,
     ):
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         cleanup_payload(data)
         if not node:
             node: CoreReadOnlyRepository | CoreRepository = await NodeManager.get_one_by_id_or_default_filter(
-                db=context.db,
+                db=graphql_context.db,
                 kind=cls._meta.schema.kind,
                 id=data.get("id"),
                 branch=branch,
@@ -161,7 +165,7 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
                 include_source=True,
             )
         if node.get_kind() != InfrahubKind.READONLYREPOSITORY:
-            return await super().mutate_update(info, data, branch, database=context.db, node=node)
+            return await super().mutate_update(info, data, branch, database=graphql_context.db, node=node)
 
         node = cast(CoreReadOnlyRepository, node)
         current_commit = node.commit.value
@@ -173,7 +177,7 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         if data.ref and data.ref.value:
             new_ref = data.ref.value
 
-        obj, result = await super().mutate_update(info, data, branch, database=context.db, node=node)
+        obj, result = await super().mutate_update(info, data, branch, database=graphql_context.db, node=node)
         obj = cast(CoreReadOnlyRepository, obj)
 
         send_update_message = (new_commit and new_commit != current_commit) or (new_ref and new_ref != current_ref)
@@ -196,9 +200,11 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
             infrahub_branch_name=branch.name,
             infrahub_branch_id=str(branch.get_uuid()),
         )
-        if context.service:
-            await context.service.workflow.submit_workflow(
-                workflow=GIT_REPOSITORIES_PULL_READ_ONLY, parameters={"model": model}
+        if graphql_context.service:
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=GIT_REPOSITORIES_PULL_READ_ONLY,
+                context=graphql_context.get_context(),
+                parameters={"model": model},
             )
         return obj, result
 
@@ -226,15 +232,15 @@ class ProcessRepository(Mutation):
     @classmethod
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: IdentifierInput,
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
-        branch = context.branch
+        graphql_context: GraphqlContext = info.context
+        branch = graphql_context.branch
         repository_id = str(data.id)
         repo: CoreReadOnlyRepository | CoreRepository = await NodeManager.get_one_by_id_or_default_filter(
-            db=context.db,
+            db=graphql_context.db,
             kind=InfrahubKind.GENERICREPOSITORY,
             id=str(data.id),
             branch=branch,
@@ -247,8 +253,8 @@ class ProcessRepository(Mutation):
             commit=str(repo.commit.value),
             infrahub_branch_name=branch.name,
         )
-        workflow = await context.active_service.workflow.submit_workflow(
-            workflow=GIT_REPOSITORIES_IMPORT_OBJECTS, parameters={"model": model}
+        workflow = await graphql_context.active_service.workflow.submit_workflow(
+            workflow=GIT_REPOSITORIES_IMPORT_OBJECTS, context=graphql_context.get_context(), parameters={"model": model}
         )
         task = {"id": workflow.id}
         return cls(ok=True, task=task)
@@ -264,15 +270,15 @@ class ValidateRepositoryConnectivity(Mutation):
     @classmethod
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: IdentifierInput,
     ) -> dict[str, Any]:
-        context: GraphqlContext = info.context
-        branch = context.branch
+        graphql_context: GraphqlContext = info.context
+        branch = graphql_context.branch
         repository_id = str(data.id)
         repo: CoreReadOnlyRepository | CoreRepository = await NodeManager.get_one_by_id_or_default_filter(
-            db=context.db,
+            db=graphql_context.db,
             kind=InfrahubKind.GENERICREPOSITORY,
             id=repository_id,
             branch=branch,
@@ -282,8 +288,8 @@ class ValidateRepositoryConnectivity(Mutation):
             repository_name=str(repo.name.value),
             repository_location=str(repo.location.value),
         )
-        if context.service:
-            response = await context.service.message_bus.rpc(
+        if graphql_context.service:
+            response = await graphql_context.service.message_bus.rpc(
                 message=message, response_class=GitRepositoryConnectivityResponse
             )