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

infrahub/graphql/mutations/main.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
@@ -9,13 +9,15 @@ from typing_extensions import Self
 
 from infrahub import config, lock
 from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind, MutationAction
+from infrahub.core.changelog.models import RelationshipChangelogGetter
+from infrahub.core.constants import InfrahubKind, MutationAction, RelationshipCardinality, RelationshipKind
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
-from infrahub.core.schema import NodeSchema
+from infrahub.core.schema import NodeSchema, RelationshipSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
+from infrahub.core.schema.template_schema import TemplateSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import retry_db_transaction
 from infrahub.dependencies.registry import get_component_registry
@@ -33,13 +35,14 @@ if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
     from infrahub.core.branch import Branch
+    from infrahub.core.protocols import CoreObjectTemplate
+    from infrahub.core.relationship.model import RelationshipManager
     from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
 
     from ..initialization import GraphqlContext
     from .node_getter.interface import MutationNodeGetterInterface
 
-# pylint: disable=unused-argument
 
 log = get_logger()
 
@@ -55,60 +58,86 @@ class InfrahubMutationOptions(MutationOptions):
 
 class InfrahubMutationMixin:
     @classmethod
-    async def mutate(cls, root: dict, info: GraphQLResolveInfo, data: InputObjectType, *args: Any, **kwargs):
-        context: GraphqlContext = info.context
+    async def mutate(cls, root: dict, info: GraphQLResolveInfo, data: InputObjectType, *args: Any, **kwargs):  # noqa: ARG003
+        graphql_context: GraphqlContext = info.context
 
         obj = None
         mutation = None
         action = MutationAction.UNDEFINED
 
         if "Create" in cls.__name__:
-            obj, mutation = await cls.mutate_create(info=info, branch=context.branch, data=data, **kwargs)
-            action = MutationAction.ADDED
+            obj, mutation = await cls.mutate_create(info=info, branch=graphql_context.branch, data=data, **kwargs)
+            action = MutationAction.CREATED
         elif "Update" in cls.__name__:
-            obj, mutation = await cls.mutate_update(info=info, branch=context.branch, data=data, **kwargs)
+            obj, mutation = await cls.mutate_update(info=info, branch=graphql_context.branch, data=data, **kwargs)
             action = MutationAction.UPDATED
         elif "Upsert" in cls.__name__:
             node_manager = NodeManager()
             node_getters = [
-                MutationNodeGetterById(db=context.db, node_manager=node_manager),
-                MutationNodeGetterByHfid(db=context.db, node_manager=node_manager),
-                MutationNodeGetterByDefaultFilter(db=context.db, node_manager=node_manager),
+                MutationNodeGetterById(db=graphql_context.db, node_manager=node_manager),
+                MutationNodeGetterByHfid(db=graphql_context.db, node_manager=node_manager),
+                MutationNodeGetterByDefaultFilter(db=graphql_context.db, node_manager=node_manager),
             ]
             obj, mutation, created = await cls.mutate_upsert(
-                info=info, branch=context.branch, data=data, node_getters=node_getters, **kwargs
+                info=info, branch=graphql_context.branch, data=data, node_getters=node_getters, **kwargs
             )
             if created:
-                action = MutationAction.ADDED
+                action = MutationAction.CREATED
             else:
                 action = MutationAction.UPDATED
         elif "Delete" in cls.__name__:
-            obj, mutation = await cls.mutate_delete(info=info, branch=context.branch, data=data, **kwargs)
-            action = MutationAction.REMOVED
+            obj, mutation = await cls.mutate_delete(info=info, branch=graphql_context.branch, data=data, **kwargs)
+            action = MutationAction.DELETED
         else:
             raise ValueError(
                 f"Unexpected class Name: {cls.__name__}, should end with Create, Update, Upsert, or Delete"
             )
 
         # Reset the time of the query to guarantee that all resolvers executed after this point will account for the changes
-        context.at = Timestamp()
+        graphql_context.at = Timestamp()
 
-        if config.SETTINGS.broker.enable and context.background:
+        if config.SETTINGS.broker.enable and graphql_context.background and obj.node_changelog.has_changes:
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")
 
-            graphql_payload = await obj.to_graphql(db=context.db, filter_sensitive=True)
-            event = NodeMutatedEvent(
-                branch=context.branch.name,
+            account_id: str | None = None
+            if graphql_context.account_session:
+                account_id = graphql_context.account_session.account_id
+
+            meta = EventMeta(
+                account_id=account_id,
+                initiator_id=WORKER_IDENTITY,
+                request_id=request_id,
+                branch=graphql_context.branch,
+                context=graphql_context.get_context(),
+            )
+            main_event = NodeMutatedEvent(
                 kind=obj._schema.kind,
                 node_id=obj.id,
-                data=graphql_payload,
+                data=obj.node_changelog,
                 action=action,
                 fields=_get_data_fields(data),
-                meta=EventMeta(initiator_id=WORKER_IDENTITY, request_id=request_id),
+                meta=meta,
             )
-
-            context.background.add_task(context.active_service.event.send, event)
+            relationship_changelogs = RelationshipChangelogGetter(db=graphql_context.db, branch=graphql_context.branch)
+            node_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=obj.node_changelog)
+
+            events = [main_event]
+
+            for node_changelog in node_changelogs:
+                meta = EventMeta.from_parent(parent=main_event)
+                event = NodeMutatedEvent(
+                    kind=node_changelog.node_kind,
+                    node_id=node_changelog.node_id,
+                    data=node_changelog,
+                    action=MutationAction.UPDATED,
+                    fields=node_changelog.updated_fields,
+                    meta=meta,
+                )
+                events.append(event)
+
+            for event in events:
+                graphql_context.background.add_task(graphql_context.active_service.event.send, event)
 
         return mutation
 
@@ -127,7 +156,7 @@ class InfrahubMutationMixin:
             return obj
         current_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
         if previous_profile_ids is None or previous_profile_ids != current_profile_ids:
-            return await NodeManager.get_one_by_id_or_default_filter(
+            refreshed_node = await NodeManager.get_one_by_id_or_default_filter(
                 db=db,
                 kind=cls._meta.schema.kind,
                 id=obj.get_id(),
@@ -135,6 +164,8 @@ class InfrahubMutationMixin:
                 include_owner=True,
                 include_source=True,
             )
+            refreshed_node._node_changelog = obj.node_changelog
+            return refreshed_node
         return obj
 
     @classmethod
@@ -152,6 +183,95 @@ class InfrahubMutationMixin:
 
         return await cls.mutate_create_object(data=data, db=db, branch=branch)
 
+    @classmethod
+    async def _get_template_relationship_peers(
+        cls, db: InfrahubDatabase, template: CoreObjectTemplate, relationship: RelationshipSchema
+    ) -> Mapping[str, Node]:
+        """For a given relationship on the template, fetch the related peers."""
+        template_relationship_manager: RelationshipManager = getattr(template, relationship.name)
+        if relationship.cardinality == RelationshipCardinality.MANY:
+            return await template_relationship_manager.get_peers(db=db)
+
+        peers: dict[str, Node] = {}
+        template_relationship_peer = await template_relationship_manager.get_peer(db=db)
+        if template_relationship_peer:
+            peers[template_relationship_peer.id] = template_relationship_peer
+        return peers
+
+    @classmethod
+    async def _extract_peer_data(
+        cls,
+        db: InfrahubDatabase,
+        template_peer: Node,
+        obj_peer_schema,
+        parent_obj: Node,
+        current_template: CoreObjectTemplate,
+    ) -> Mapping[str, Any]:
+        obj_peer_data: dict[str, Any] = {}
+
+        for attr in template_peer.get_schema().attribute_names:
+            if attr not in obj_peer_schema.attribute_names:
+                continue
+            obj_peer_data[attr] = {"value": getattr(template_peer, attr).value}
+
+        for rel in template_peer.get_schema().relationship_names:
+            rel_manager: RelationshipManager = getattr(template_peer, rel)
+            if (
+                rel_manager.schema.kind not in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
+                or rel_manager.schema.name not in obj_peer_schema.relationship_names
+            ):
+                continue
+
+            if list(await rel_manager.get_peers(db=db)) == [current_template.id]:
+                obj_peer_data[rel] = {"id": parent_obj.id}
+
+        return obj_peer_data
+
+    @classmethod
+    async def _handle_template_relationships(
+        cls,
+        db: InfrahubDatabase,
+        branch: Branch,
+        obj: Node,
+        template: CoreObjectTemplate,
+        data: InputObjectType,
+        constraint_runner: NodeConstraintRunner | None = None,
+    ) -> None:
+        if constraint_runner is None:
+            component_registry = get_component_registry()
+            constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
+
+        for relationship in obj.get_relationships(kind=RelationshipKind.COMPONENT, exclude=list(data)):
+            template_relationship_peers = await cls._get_template_relationship_peers(
+                db=db, template=template, relationship=relationship
+            )
+            if not template_relationship_peers:
+                continue
+
+            obj_peer_schema = relationship.get_peer_schema(db=db, branch=branch)
+            for template_relationship_peer in template_relationship_peers.values():
+                obj_peer_data = await cls._extract_peer_data(
+                    db=db,
+                    template_peer=template_relationship_peer,
+                    obj_peer_schema=obj_peer_schema,
+                    parent_obj=obj,
+                    current_template=template,
+                )
+
+                obj_peer = await Node.init(schema=obj_peer_schema, db=db)
+                await obj_peer.new(db=db, **obj_peer_data)
+                await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
+                await obj_peer.save(db=db)
+
+                await cls._handle_template_relationships(
+                    db=db,
+                    branch=branch,
+                    constraint_runner=constraint_runner,
+                    obj=obj_peer,
+                    template=template_relationship_peer,
+                    data=data,
+                )
+
     @classmethod
     async def mutate_create(
         cls,
@@ -160,8 +280,8 @@ class InfrahubMutationMixin:
         branch: Branch,
         database: Optional[InfrahubDatabase] = None,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
         obj = await cls._call_mutate_create_object(data=data, db=db, branch=branch)
         result = await cls.mutate_create_to_graphql(info=info, db=db, obj=obj)
         return obj, result
@@ -175,22 +295,46 @@ class InfrahubMutationMixin:
         branch: Branch,
     ) -> Node:
         component_registry = get_component_registry()
-        node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
+        node_constraint_runner = await component_registry.get_component(
+            NodeConstraintRunner, db=db.start_session(), branch=branch
+        )
         node_class = Node
         if cls._meta.schema.kind in registry.node:
             node_class = registry.node[cls._meta.schema.kind]
 
+        fields_to_validate = list(data)
         try:
-            obj = await node_class.init(db=db, schema=cls._meta.schema, branch=branch)
-            await obj.new(db=db, **data)
-            fields_to_validate = list(data)
-            await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
             if db.is_transaction:
+                obj = await node_class.init(db=db, schema=cls._meta.schema, branch=branch)
+                await obj.new(db=db, **data)
+                await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
                 await obj.save(db=db)
+
+                object_template = await obj.get_object_template(db=db)
+                if object_template:
+                    await cls._handle_template_relationships(
+                        db=db,
+                        branch=branch,
+                        template=object_template,
+                        obj=obj,
+                        data=data,
+                    )
             else:
                 async with db.start_transaction() as dbt:
+                    obj = await node_class.init(db=dbt, schema=cls._meta.schema, branch=branch)
+                    await obj.new(db=dbt, **data)
+                    await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
                     await obj.save(db=dbt)
 
+                    object_template = await obj.get_object_template(db=dbt)
+                    if object_template:
+                        await cls._handle_template_relationships(
+                            db=dbt,
+                            branch=branch,
+                            template=object_template,
+                            obj=obj,
+                            data=data,
+                        )
         except ValidationError as exc:
             raise ValueError(str(exc)) from exc
 
@@ -253,8 +397,8 @@ class InfrahubMutationMixin:
         database: Optional[InfrahubDatabase] = None,
         node: Optional[Node] = None,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
 
         obj = node or await NodeManager.find_object(
             db=db, kind=cls._meta.schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
@@ -269,7 +413,12 @@ class InfrahubMutationMixin:
 
     @classmethod
     async def mutate_update_object(
-        cls, db: InfrahubDatabase, info: GraphQLResolveInfo, data: InputObjectType, branch: Branch, obj: Node
+        cls,
+        db: InfrahubDatabase,
+        info: GraphQLResolveInfo,  # noqa: ARG003
+        data: InputObjectType,
+        branch: Branch,
+        obj: Node,
     ) -> Node:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
@@ -285,6 +434,7 @@ class InfrahubMutationMixin:
                 fields.remove(field)
 
         await obj.save(db=db, fields=fields)
+
         obj = await cls._refresh_for_profile_update(
             db=db, branch=branch, obj=obj, previous_profile_ids=before_mutate_profile_ids
         )
@@ -316,8 +466,8 @@ class InfrahubMutationMixin:
     ) -> tuple[Node, Self, bool]:
         schema_name = cls._meta.schema.kind
 
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
 
         node_schema = db.schema.get(name=schema_name, branch=branch)
 
@@ -345,14 +495,14 @@ class InfrahubMutationMixin:
         data: InputObjectType,
         branch: Branch,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         obj = await NodeManager.find_object(
-            db=context.db, kind=cls._meta.schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
+            db=graphql_context.db, kind=cls._meta.schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
         )
 
         try:
-            async with context.db.start_transaction() as db:
+            async with graphql_context.db.start_transaction() as db:
                 deleted = await NodeManager.delete(db=db, branch=branch, nodes=[obj])
         except ValidationError as exc:
             raise ValueError(str(exc)) from exc
@@ -367,11 +517,14 @@ class InfrahubMutationMixin:
 
 class InfrahubMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
-        cls, schema: Optional[Union[NodeSchema, GenericSchema, ProfileSchema]] = None, _meta=None, **options
+    def __init_subclass_with_meta__(
+        cls,
+        schema: Optional[Union[NodeSchema, GenericSchema, ProfileSchema, TemplateSchema]] = None,
+        _meta=None,
+        **options,
     ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
-        if not isinstance(schema, (NodeSchema, GenericSchema, ProfileSchema)):
+        if not isinstance(schema, NodeSchema | GenericSchema | ProfileSchema | TemplateSchema):
             raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
 
         if not _meta:

infrahub/graphql/mutations/menu.py

@@ -34,7 +34,7 @@ def validate_namespace(data: InputObjectType) -> None:
 
 class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls, schema: NodeSchema, _meta: Optional[Any] = None, **options: dict[str, Any]
     ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
@@ -53,7 +53,7 @@ class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
     ) -> tuple[Node, Self]:
         validate_namespace(data=data)
 
@@ -67,13 +67,13 @@ class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
-        node: Optional[Node] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
+        node: Optional[Node] = None,  # noqa: ARG003
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         obj = await NodeManager.find_object(
-            db=context.db, kind=CoreMenuItem, id=data.get("id"), hfid=data.get("hfid"), branch=branch
+            db=graphql_context.db, kind=CoreMenuItem, id=data.get("id"), hfid=data.get("hfid"), branch=branch
         )
         validate_namespace(data=data)
 
@@ -90,9 +90,9 @@ class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
         obj = await NodeManager.find_object(
-            db=context.db, kind=CoreMenuItem, id=data.get("id"), hfid=data.get("hfid"), branch=branch
+            db=graphql_context.db, kind=CoreMenuItem, id=data.get("id"), hfid=data.get("hfid"), branch=branch
         )
         if obj.protected.value:
             raise ValidationError(input_value="This object is protected, it can't be deleted.")

infrahub/graphql/mutations/proposed_change.py

@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 
 class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(cls, schema: NodeSchema = None, _meta=None, **options):  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(cls, schema: 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}'")
@@ -49,12 +49,11 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
     ):
-        context: GraphqlContext = info.context
-        db: InfrahubDatabase = info.context.db
+        graphql_context: GraphqlContext = info.context
 
-        async with db.start_transaction() as dbt:
+        async with graphql_context.db.start_transaction() as dbt:
             proposed_change, result = await super().mutate_create(info=info, data=data, branch=branch, database=dbt)
             destination_branch = proposed_change.destination_branch.value
             source_branch = await _get_source_branch(db=dbt, name=proposed_change.source_branch.value)
@@ -65,34 +64,35 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
                     input_value="Currently only the 'main' branch is supported as a destination for a proposed change"
                 )
 
-        if context.service:
+        if graphql_context.service:
             message_list = [
                 messages.RequestProposedChangePipeline(
                     proposed_change=proposed_change.id,
                     source_branch=source_branch.name,
                     source_branch_sync_with_git=source_branch.sync_with_git,
                     destination_branch=destination_branch,
+                    context=graphql_context.get_context(),
                 ),
             ]
 
             for message in message_list:
-                await context.service.send(message=message)
+                await graphql_context.service.message_bus.send(message=message)
 
         return proposed_change, result
 
     @classmethod
-    async def mutate_update(  # pylint: disable=too-many-branches
+    async def mutate_update(
         cls,
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
-        node: Optional[Node] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
+        node: Optional[Node] = None,  # noqa: ARG003
     ):
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         obj = 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,
@@ -108,9 +108,9 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
             state.validate_state_transition(updated_state)
 
         # Check before starting a transaction, stopping in the middle of the transaction seems to break with memgraph
-        if updated_state == ProposedChangeState.MERGED and context.account_session:
+        if updated_state == ProposedChangeState.MERGED and graphql_context.account_session:
             try:
-                context.active_permissions.raise_for_permission(
+                graphql_context.active_permissions.raise_for_permission(
                     permission=GlobalPermission(
                         action=GlobalPermissions.MERGE_PROPOSED_CHANGE.value,
                         decision=PermissionDecision.ALLOW_ALL.value,
@@ -123,17 +123,22 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
             data["state"]["value"] = ProposedChangeState.MERGING.value
 
         proposed_change, result = await super().mutate_update(
-            info=info, data=data, branch=branch, database=context.db, node=obj
+            info=info, data=data, branch=branch, database=graphql_context.db, node=obj
         )
 
         if updated_state == ProposedChangeState.MERGED:
-            await context.service.workflow.execute_workflow(
+            await graphql_context.service.workflow.execute_workflow(
                 workflow=PROPOSED_CHANGE_MERGE,
+                context=graphql_context.get_context(),
                 parameters={
                     "proposed_change_id": proposed_change.id,
                     "proposed_change_name": proposed_change.name.value,
                 },
             )
+            # When the PROPOSED_CHANGE_MERGE succeeds it will have correctly changed the state
+            # from the overridden "merging" value, so here we change it back to reflect the
+            # correct value for the event that will be generated.
+            proposed_change.node_changelog.attributes["state"].value = ProposedChangeState.MERGED.value
 
         return proposed_change, result
 
@@ -152,23 +157,23 @@ class ProposedChangeRequestRunCheck(Mutation):
     @classmethod
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: dict[str, Any],
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         check_type = data.get("check_type") or CheckType.ALL
 
         identifier = data.get("id", "")
         proposed_change = await NodeManager.get_one_by_id_or_default_filter(
-            id=identifier, kind=InfrahubKind.PROPOSEDCHANGE, db=context.db
+            id=identifier, kind=InfrahubKind.PROPOSEDCHANGE, db=graphql_context.db
         )
         state = ProposedChangeState(proposed_change.state.value.value)
         state.validate_state_check_run()
 
         destination_branch = proposed_change.destination_branch.value
-        source_branch = await _get_source_branch(db=context.db, name=proposed_change.source_branch.value)
+        source_branch = await _get_source_branch(db=graphql_context.db, name=proposed_change.source_branch.value)
 
         message = messages.RequestProposedChangePipeline(
             proposed_change=proposed_change.id,
@@ -176,9 +181,10 @@ class ProposedChangeRequestRunCheck(Mutation):
             source_branch_sync_with_git=source_branch.sync_with_git,
             destination_branch=destination_branch,
             check_type=check_type,
+            context=graphql_context.get_context(),
         )
-        if context.service:
-            await context.service.send(message=message)
+        if graphql_context.service:
+            await graphql_context.service.message_bus.send(message=message)
 
         return {"ok": True}
 
@@ -198,37 +204,39 @@ class ProposedChangeMerge(Mutation):
     @classmethod
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: dict[str, Any],
         wait_until_completion: bool = True,
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
         task: dict | None = None
 
         identifier = data.get("id", "")
         proposed_change = await NodeManager.get_one(
-            id=identifier, kind=InfrahubKind.PROPOSEDCHANGE, db=context.db, raise_on_error=True
+            id=identifier, kind=InfrahubKind.PROPOSEDCHANGE, db=graphql_context.db, raise_on_error=True
         )
         state = ProposedChangeState(proposed_change.state.value.value)
         if state != ProposedChangeState.OPEN:
             raise ValidationError("Only proposed change in OPEN state can be merged")
 
-        async with context.db.start_session() as db:
+        async with graphql_context.db.start_session() as db:
             proposed_change.state.value = ProposedChangeState.MERGING.value
             proposed_change.save(db=db)
 
         if wait_until_completion:
-            await context.service.workflow.execute_workflow(
+            await graphql_context.service.workflow.execute_workflow(
                 workflow=PROPOSED_CHANGE_MERGE,
+                context=graphql_context.get_context(),
                 parameters={
                     "proposed_change_id": proposed_change.id,
                     "proposed_change_name": proposed_change.name.value,
                 },
             )
         else:
-            workflow = await context.service.workflow.submit_workflow(
+            workflow = await graphql_context.service.workflow.submit_workflow(
                 workflow=PROPOSED_CHANGE_MERGE,
+                context=graphql_context.get_context(),
                 parameters={
                     "proposed_change_id": proposed_change.id,
                     "proposed_change_name": proposed_change.name.value,