infrahub-server 1.3.7__py3-none-any.whl → 1.4.0__py3-none-any.whl

infrahub/graphql/mutations/proposed_change.py

@@ -1,8 +1,11 @@
+from __future__ import annotations
+
 from typing import TYPE_CHECKING, Any, Self
 
-from graphene import Boolean, Field, InputObjectType, Mutation, String
+from graphene import Boolean, Enum, Field, InputObjectType, List, Mutation, String
 from graphql import GraphQLResolveInfo
 
+from infrahub import lock
 from infrahub.core.account import GlobalPermission
 from infrahub.core.branch import Branch
 from infrahub.core.constants import (
@@ -12,26 +15,45 @@ from infrahub.core.constants import (
     PermissionDecision,
 )
 from infrahub.core.manager import NodeManager
-from infrahub.core.node import Node
+from infrahub.core.protocols import CoreProposedChange
 from infrahub.core.schema import NodeSchema
 from infrahub.database import InfrahubDatabase, retry_db_transaction
+from infrahub.events import (
+    EventMeta,
+    ProposedChangeApprovalRevokedEvent,
+    ProposedChangeApprovedEvent,
+    ProposedChangeRejectedEvent,
+    ProposedChangeRejectionRevokedEvent,
+)
 from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, ValidationError
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
-from infrahub.proposed_change.constants import ProposedChangeState
+from infrahub.graphql.types.task import TaskInfo
+from infrahub.lock import InfrahubLock, build_object_lock_name
+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 ...proposed_change.models import RequestProposedChangePipeline
-from ..types.task import TaskInfo
 from .main import InfrahubMutationOptions
 
 if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.node import Node
+    from infrahub.events.models import InfrahubEvent
+
     from ..initialization import GraphqlContext
 
+ProposedChangeApprovalDecisionInput = Enum.from_enum(ProposedChangeApprovalDecision)
+
 
 class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(cls, schema: NodeSchema = None, _meta=None, **options) -> None:
+    def __init_subclass_with_meta__(
+        cls, schema: NodeSchema, _meta: InfrahubMutationOptions | None = None, **options: dict[str, Any]
+    ) -> None:
         # 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}'")
@@ -50,11 +72,19 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
         database: InfrahubDatabase | None = None,  # noqa: ARG003
+        override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
 
+        override_data = {"created_by": {"id": graphql_context.active_account_session.account_id}}
+        state = data.get("state", {}).get("value")
+        if state and state != ProposedChangeState.OPEN.value:
+            raise ValidationError(input_value="A proposed change has to be in the open state during creation")
+
         async with graphql_context.db.start_transaction() as dbt:
-            proposed_change, result = await super().mutate_create(info=info, data=data, branch=branch, database=dbt)
+            proposed_change, result = await super().mutate_create(
+                info=info, data=data, branch=branch, database=dbt, override_data=override_data
+            )
             destination_branch = proposed_change.destination_branch.value
             source_branch = await _get_source_branch(db=dbt, name=proposed_change.source_branch.value)
             if destination_branch == source_branch.name:
@@ -100,13 +130,16 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
             include_source=True,
         )
         state = ProposedChangeState(obj.state.value.value)
-        state.validate_editability()
+        state.validate_updatable()
 
         updated_state = None
         if state_update := data.get("state", {}).get("value"):
             updated_state = ProposedChangeState(state_update)
             state.validate_state_transition(updated_state)
 
+        # Check if the draft state will change (defaults to current draft state)
+        will_be_draft = data.get("is_draft", {}).get("value", obj.is_draft.value)
+
         # Check before starting a transaction, stopping in the middle of the transaction seems to break with memgraph
         if updated_state == ProposedChangeState.MERGED and graphql_context.account_session:
             try:
@@ -120,6 +153,8 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
                 raise ValidationError(str(exc)) from exc
 
         if updated_state == ProposedChangeState.MERGED:
+            if will_be_draft:
+                raise ValidationError("A draft proposed change is not allowed to be merged")
             data["state"]["value"] = ProposedChangeState.MERGING.value
 
         proposed_change, result = await super().mutate_update(
@@ -192,6 +227,165 @@ class ProposedChangeRequestRunCheck(Mutation):
         return {"ok": True}
 
 
+class ProposedChangeReviewInput(InputObjectType):
+    id = String(required=True, description="The ID of the proposed change to review.")
+    decision = ProposedChangeApprovalDecisionInput(
+        required=True, description="The decision for the proposed change review."
+    )
+
+
+class ProposedChangeReview(Mutation):
+    class Arguments:
+        data = ProposedChangeReviewInput(required=True)
+
+    ok = Boolean()
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: ProposedChangeReviewInput,
+    ) -> dict[str, bool]:
+        """
+        This mutation is used to approve or reject a proposed change.
+        It can also be used to undo an approval or rejection.
+        """
+
+        graphql_context: GraphqlContext = info.context
+        graphql_context.active_permissions.raise_for_permission(
+            permission=GlobalPermission(
+                action=GlobalPermissions.REVIEW_PROPOSED_CHANGE.value, decision=PermissionDecision.ALLOW_ALL.value
+            )
+        )
+        pc_id = str(data.id)
+        lock_name = build_object_lock_name(pc_id)
+        async with InfrahubLock(name=lock_name, connection=lock.registry.connection):
+            proposed_change = await NodeManager.get_one_by_id_or_default_filter(
+                id=pc_id, kind=CoreProposedChange, db=graphql_context.db, prefetch_relationships=True
+            )
+            state = ProposedChangeState(proposed_change.state.value.value)
+            state.validate_reviewable()
+
+            created_by = await proposed_change.created_by.get_peer(db=graphql_context.db)
+            if created_by and created_by.id == graphql_context.active_account_session.account_id:
+                raise ValidationError(input_value="You cannot review your own proposed changes")
+
+            current_user = await NodeManager.get_one_by_id_or_default_filter(
+                id=graphql_context.active_account_session.account_id,
+                kind=InfrahubKind.GENERICACCOUNT,
+                db=graphql_context.db,
+            )
+
+            async with graphql_context.db.start_session() as db:
+                event = await cls._handle_decision(
+                    db=db,
+                    decision=data.decision,
+                    proposed_change=proposed_change,
+                    current_user=current_user,
+                    context=graphql_context,
+                )
+                await proposed_change.save(db=db)
+
+                if event:
+                    event_service = await get_event_service()
+                    await event_service.send(event=event)
+
+        return {"ok": True}
+
+    @classmethod
+    async def _handle_decision(
+        cls,
+        db: InfrahubDatabase,
+        decision: ProposedChangeApprovalDecision,
+        proposed_change: CoreProposedChange,
+        current_user: Node,
+        context: GraphqlContext,
+    ) -> InfrahubEvent | None:
+        """Modify approved_by and rejected_by relationships of the prpoposed change based on the decision."""
+
+        approved_by = await proposed_change.approved_by.get_peers(db=db)
+        rejected_by = await proposed_change.rejected_by.get_peers(db=db)
+        approved_by_ids = [node.id for _, node in approved_by.items()]
+        rejected_by_ids = [node.id for _, node in rejected_by.items()]
+        event: InfrahubEvent | None = None
+        event_meta = EventMeta.from_context(context=context.get_context())
+
+        match decision:
+            case ProposedChangeApprovalDecision.APPROVE:
+                if current_user.id in approved_by_ids:
+                    raise ValidationError(input_value="You have already approved this proposed change")
+                await proposed_change.approved_by.add(db=db, data=current_user)
+                if current_user.id in rejected_by_ids:
+                    await proposed_change.rejected_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeApprovedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_decision=decision.value,
+                    meta=event_meta,
+                )
+
+            case ProposedChangeApprovalDecision.CANCEL_APPROVE:
+                if current_user.id not in approved_by_ids:
+                    raise ValidationError(
+                        input_value="You did not approve this proposed change yet, it can't be un-approved"
+                    )
+                await proposed_change.approved_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeApprovalRevokedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_former_decision=ProposedChangeApprovalDecision.APPROVE.value,
+                    meta=event_meta,
+                )
+
+            case ProposedChangeApprovalDecision.REJECT:
+                if current_user.id in rejected_by_ids:
+                    raise ValidationError(input_value="You have already rejected this proposed change")
+                await proposed_change.rejected_by.add(db=db, data=current_user)
+                if current_user.id in approved_by_ids:
+                    await proposed_change.approved_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeRejectedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_decision=decision.value,
+                    meta=event_meta,
+                )
+
+            case ProposedChangeApprovalDecision.CANCEL_REJECT:
+                if current_user.id not in rejected_by_ids:
+                    raise ValidationError(
+                        input_value="You did not reject this proposed change yet, it can't be un-rejected"
+                    )
+                await proposed_change.rejected_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeRejectionRevokedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_former_decision=ProposedChangeApprovalDecision.REJECT.value,
+                    meta=event_meta,
+                )
+
+            case _:
+                raise ValidationError(input_value=f"Invalid decision {decision}")
+
+        return event
+
+
 class ProposedChangeMergeInput(InputObjectType):
     id = String(required=True)
 
@@ -250,6 +444,34 @@ class ProposedChangeMerge(Mutation):
         return cls(ok=True, task=task)
 
 
+class ProposedChangeCheckForApprovalRevokeInput(InputObjectType):
+    ids = Field(List(of_type=String, required=True), required=False)
+
+
+class ProposedChangeCheckForApprovalRevoke(Mutation):
+    class Arguments:
+        data = ProposedChangeCheckForApprovalRevokeInput(required=True)
+
+    ok = Boolean()
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: dict[str, Any],
+    ) -> dict[str, bool]:
+        db = info.context.db
+        ids: list[str] | None
+        try:
+            ids = data["ids"]
+        except KeyError:
+            ids = None
+
+        await do_revoke_approvals_on_updated_pcs(db=db, proposed_changes_ids=ids)
+        return cls(ok=True)
+
+
 async def _get_source_branch(db: InfrahubDatabase, name: str) -> Branch:
     try:
         return await Branch.get_by_name(name=name, db=db)

infrahub/graphql/mutations/relationship.py

@@ -332,6 +332,11 @@ async def _validate_node(info: GraphQLResolveInfo, data: RelationshipNodesInput)
     if rel_schema.cardinality != RelationshipCardinality.MANY:
         raise ValidationError({"name": f"'{relationship_name}' must be a relationship of cardinality Many"})
 
+    if rel_schema.read_only:
+        # These mutations should never be allowed to update read-only relationships, as those typically
+        # have custom code tied to them such as the approved_by relationship of a CoreProposedChange.
+        raise ValidationError({source.get_kind(): f"'{relationship_name}' is a read-only relationship"})
+
     return source
 
 

infrahub/graphql/mutations/repository.py

@@ -64,12 +64,13 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
         database: InfrahubDatabase | None = None,  # noqa: ARG003
+        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)
+        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

infrahub/graphql/mutations/tasks.py

@@ -15,16 +15,17 @@ from infrahub.core.validators.models.validate_migration import SchemaValidateMig
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.exceptions import ValidationError
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workers.dependencies import get_database, get_workflow
 from infrahub.workflows.catalogue import BRANCH_MERGE
 from infrahub.workflows.utils import add_tags
 
 
 @flow(name="merge-branch-mutation", flow_run_name="Merge branch graphQL mutation")
-async def merge_branch_mutation(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+async def merge_branch_mutation(branch: str, context: InfrahubContext) -> None:
     await add_tags(branches=[branch])
 
-    async with service.database.start_session() as db:
+    database = await get_database()
+    async with database.start_session() as db:
         obj = await Branch.get_by_name(db=db, name=branch)
         base_branch = await Branch.get_by_name(db=db, name=registry.default_branch)
 
@@ -52,7 +53,7 @@ async def merge_branch_mutation(branch: str, context: InfrahubContext, service:
             diff_repository=diff_repository,
             source_branch=obj,
             diff_locker=DiffLocker(),
-            service=service,
+            workflow=get_workflow(),
         )
         candidate_schema = merger.get_candidate_schema()
         determiner = ConstraintValidatorDeterminer(schema_branch=candidate_schema)
@@ -62,13 +63,10 @@ async def merge_branch_mutation(branch: str, context: InfrahubContext, service:
 
         if constraints:
             responses = await schema_validate_migrations(
-                message=SchemaValidateMigrationData(
-                    branch=obj, schema_branch=candidate_schema, constraints=constraints
-                ),
-                service=service,
+                message=SchemaValidateMigrationData(branch=obj, schema_branch=candidate_schema, constraints=constraints)
             )
             error_messages = [violation.message for response in responses for violation in response.violations]
             if error_messages:
                 raise ValidationError(",\n".join(error_messages))
 
-        await service.workflow.execute_workflow(workflow=BRANCH_MERGE, context=context, parameters={"branch": obj.name})
+        await get_workflow().execute_workflow(workflow=BRANCH_MERGE, context=context, parameters={"branch": obj.name})

infrahub/graphql/mutations/webhook.py

@@ -67,6 +67,7 @@ class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
         database: InfrahubDatabase | None = None,
+        override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
 
@@ -74,7 +75,9 @@ class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
 
         _validate_input(graphql_context=graphql_context, branch=branch, input_data=input_data)
 
-        obj, result = await super().mutate_create(info=info, data=data, branch=branch, database=database)
+        obj, result = await super().mutate_create(
+            info=info, data=data, branch=branch, database=database, override_data=override_data
+        )
 
         return obj, result
 

infrahub/graphql/parser.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 from graphql.language import (
     DirectiveNode,
     FieldNode,
+    FragmentSpreadNode,
     InlineFragmentNode,
     ListValueNode,
     NameNode,
@@ -15,7 +16,9 @@ from graphql.language import (
 from infrahub_sdk.utils import deep_merge_dict
 
 if TYPE_CHECKING:
-    from infrahub.core.schema import NodeSchema
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.schema import GenericSchema, NodeSchema
 
 
 @dataclass
@@ -26,14 +29,14 @@ class FieldEnricher:
     fields: dict = field(default_factory=dict)
 
 
-async def extract_selection(field_node: FieldNode, schema: NodeSchema) -> dict:
-    graphql_extractor = GraphQLExtractor(field_node=field_node, schema=schema)
+async def extract_selection(info: GraphQLResolveInfo, schema: NodeSchema | GenericSchema) -> dict:
+    graphql_extractor = GraphQLExtractor(info=info, schema=schema)
     return await graphql_extractor.get_fields()
 
 
 class GraphQLExtractor:
-    def __init__(self, field_node: FieldNode, schema: NodeSchema) -> None:
-        self.field_node = field_node
+    def __init__(self, info: GraphQLResolveInfo, schema: NodeSchema | GenericSchema) -> None:
+        self.info = info
         self.schema = schema
         self.typename_paths: dict[str, list[FieldEnricher]] = {}
         self.node_path: dict[str, list[FieldEnricher]] = {}
@@ -43,7 +46,7 @@ class GraphQLExtractor:
             self.node_path[path] = []
 
     async def get_fields(self) -> dict:
-        return await self.extract_fields(selection_set=self.field_node.selection_set) or {}
+        return await self.extract_fields(selection_set=self.info.field_nodes[0].selection_set) or {}
 
     def _process_expand_directive(self, path: str, directive: DirectiveNode) -> None:
         excluded_fields = []
@@ -204,6 +207,12 @@ class GraphQLExtractor:
                         elif isinstance(fields[sub_node.name.value], dict) and isinstance(value, dict):
                             fields[sub_node.name.value].update(value)  # type: ignore[union-attr]
 
+            elif isinstance(node, FragmentSpreadNode):
+                if node.name.value in self.info.fragments:
+                    fragment_fields = await self.extract_fields(self.info.fragments[node.name.value].selection_set)
+                    if fragment_fields:
+                        fields.update(fragment_fields)
+
         return self.apply_directives(selection_set=selection_set, fields=fields, path=path)
 
 

infrahub/graphql/queries/__init__.py

@@ -1,7 +1,13 @@
 from .account import AccountPermissions, AccountToken
 from .branch import BranchQueryList
 from .internal import InfrahubInfo
-from .ipam import InfrahubIPAddressGetNextAvailable, InfrahubIPPrefixGetNextAvailable
+from .ipam import (
+    DeprecatedIPAddressGetNextAvailable,
+    DeprecatedIPPrefixGetNextAvailable,
+    InfrahubIPAddressGetNextAvailable,
+    InfrahubIPPrefixGetNextAvailable,
+)
+from .proposed_change import ProposedChangeAvailableActions
 from .relationship import Relationship
 from .resource_manager import InfrahubResourcePoolAllocated, InfrahubResourcePoolUtilization
 from .search import InfrahubSearchAnywhere
@@ -12,6 +18,8 @@ __all__ = [
     "AccountPermissions",
     "AccountToken",
     "BranchQueryList",
+    "DeprecatedIPAddressGetNextAvailable",
+    "DeprecatedIPPrefixGetNextAvailable",
     "InfrahubIPAddressGetNextAvailable",
     "InfrahubIPPrefixGetNextAvailable",
     "InfrahubInfo",
@@ -19,6 +27,7 @@ __all__ = [
     "InfrahubResourcePoolUtilization",
     "InfrahubSearchAnywhere",
     "InfrahubStatus",
+    "ProposedChangeAvailableActions",
     "Relationship",
     "Task",
 ]

infrahub/graphql/queries/account.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from graphene import Field, Int, List, NonNull, ObjectType, String
-from infrahub_sdk.utils import extract_fields_first_node
 
 from infrahub.core.manager import NodeManager
 from infrahub.core.protocols import InternalAccountToken
 from infrahub.exceptions import PermissionDeniedError
+from infrahub.graphql.field_extractor import extract_graphql_fields
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -44,7 +44,7 @@ async def resolve_account_tokens(
     if not graphql_context.account_session.authenticated_by_jwt:
         raise PermissionDeniedError("This operation requires authentication with a JWT token")
 
-    fields = await extract_fields_first_node(info)
+    fields = extract_graphql_fields(info)
 
     filters = {"account__ids": [graphql_context.account_session.account_id]}
     response: dict[str, Any] = {}
@@ -121,7 +121,7 @@ async def resolve_account_permissions(
     if not graphql_context.account_session:
         raise ValueError("An account_session is mandatory to execute this query")
 
-    fields = await extract_fields_first_node(info)
+    fields = extract_graphql_fields(info)
 
     response: dict[str, dict[str, Any]] = {}
     if "global_permissions" in fields:

infrahub/graphql/queries/branch.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from graphene import ID, Field, List, NonNull, String
-from infrahub_sdk.utils import extract_fields_first_node
 
+from infrahub.graphql.field_extractor import extract_graphql_fields
 from infrahub.graphql.types import BranchType
 
 if TYPE_CHECKING:
@@ -16,7 +16,7 @@ async def branch_resolver(
     info: GraphQLResolveInfo,
     **kwargs: Any,
 ) -> list[dict[str, Any]]:
-    fields = await extract_fields_first_node(info)
+    fields = extract_graphql_fields(info)
     return await BranchType.get_list(graphql_context=info.context, fields=fields, **kwargs)
 
 

infrahub/graphql/queries/diff/tree.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from graphene import Argument, Boolean, DateTime, Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene import Enum as GrapheneEnum
-from infrahub_sdk.utils import extract_fields
 
 from infrahub.core import registry
-from infrahub.core.constants import DiffAction, RelationshipCardinality
+from infrahub.core.constants import DiffAction, RelationshipCardinality, RelationshipDirection
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.diff.model.path import NameTrackingId
 from infrahub.core.diff.query.filters import EnrichedDiffQueryFilters
@@ -16,6 +16,7 @@ from infrahub.core.query.diff import DiffCountChanges
 from infrahub.core.timestamp import Timestamp
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.graphql.enums import ConflictSelection as GraphQLConflictSelection
+from infrahub.graphql.field_extractor import extract_graphql_fields
 
 if TYPE_CHECKING:
     from datetime import datetime
@@ -38,6 +39,12 @@ GrapheneDiffActionEnum = GrapheneEnum.from_enum(DiffAction)
 GrapheneCardinalityEnum = GrapheneEnum.from_enum(RelationshipCardinality)
 
 
+@dataclass
+class ParentNodeInfo:
+    node: EnrichedDiffNode
+    relationship_name: str
+
+
 class ConflictDetails(ObjectType):
     uuid = String(required=True)
     base_branch_action = Field(GrapheneDiffActionEnum, required=True)
@@ -145,9 +152,16 @@ class DiffTreeSummary(DiffSummaryCounts):
 
 
 class DiffTreeResolver:
+    def __init__(self) -> None:
+        self.source_branch_name: str | None = None
+
+    def initialize(self, enriched_diff_root: EnrichedDiffRoot) -> None:
+        self.source_branch_name = enriched_diff_root.diff_branch_name
+
     async def to_diff_tree(
         self, enriched_diff_root: EnrichedDiffRoot, graphql_context: GraphqlContext | None = None
     ) -> DiffTree:
+        self.initialize(enriched_diff_root=enriched_diff_root)
         all_nodes = list(enriched_diff_root.nodes)
         tree_nodes = [self.to_diff_node(enriched_node=e_node, graphql_context=graphql_context) for e_node in all_nodes]
         name = None
@@ -166,6 +180,43 @@ class DiffTreeResolver:
             num_conflicts=enriched_diff_root.num_conflicts,
         )
 
+    def _get_parent_info(
+        self, diff_node: EnrichedDiffNode, graphql_context: GraphqlContext | None = None
+    ) -> ParentNodeInfo | None:
+        for r in diff_node.relationships:
+            for n in r.nodes:
+                relationship_name: str = "undefined"
+
+                if not graphql_context or not self.source_branch_name:
+                    return ParentNodeInfo(node=n, relationship_name=relationship_name)
+
+                node_schema = graphql_context.db.schema.get(
+                    name=diff_node.kind, branch=self.source_branch_name, duplicate=False
+                )
+                rel_schema = node_schema.get_relationship(name=r.name)
+
+                parent_schema = graphql_context.db.schema.get(
+                    name=n.kind, branch=self.source_branch_name, duplicate=False
+                )
+                rels_parent = parent_schema.get_relationships_by_identifier(id=rel_schema.get_identifier())
+
+                if rels_parent and len(rels_parent) == 1:
+                    relationship_name = rels_parent[0].name
+                elif rels_parent and len(rels_parent) > 1:
+                    for rel_parent in rels_parent:
+                        if (
+                            rel_schema.direction == RelationshipDirection.INBOUND
+                            and rel_parent.direction == RelationshipDirection.OUTBOUND
+                        ) or (
+                            rel_schema.direction == RelationshipDirection.OUTBOUND
+                            and rel_parent.direction == RelationshipDirection.INBOUND
+                        ):
+                            relationship_name = rel_parent.name
+                            break
+
+                return ParentNodeInfo(node=n, relationship_name=relationship_name)
+        return None
+
     def to_diff_node(self, enriched_node: EnrichedDiffNode, graphql_context: GraphqlContext | None = None) -> DiffNode:
         diff_attributes = [
             self.to_diff_attribute(enriched_attribute=e_attr, graphql_context=graphql_context)
@@ -181,7 +232,7 @@ class DiffTreeResolver:
             conflict = self.to_diff_conflict(enriched_conflict=enriched_node.conflict, graphql_context=graphql_context)
 
         parent = None
-        if parent_info := enriched_node.get_parent_info(graphql_context=graphql_context):
+        if parent_info := self._get_parent_info(diff_node=enriched_node, graphql_context=graphql_context):
             parent = DiffNodeParent(
                 uuid=parent_info.node.uuid,
                 kind=parent_info.node.kind,
@@ -438,7 +489,7 @@ class DiffTreeResolver:
         else:
             enriched_diff = enriched_diffs[0]
 
-        full_fields = await extract_fields(info.field_nodes[0].selection_set)
+        full_fields = extract_graphql_fields(info=info)
         diff_tree = await self.to_diff_tree(enriched_diff_root=enriched_diff, graphql_context=graphql_context)
         need_base_changes = "num_untracked_base_changes" in full_fields
         need_branch_changes = "num_untracked_diff_changes" in full_fields
@@ -495,7 +546,7 @@ class DiffTreeResolver:
             to_time=summary.to_time.to_datetime(),
             **summary.model_dump(exclude={"from_time", "to_time"}),
         )
-        full_fields = await extract_fields(info.field_nodes[0].selection_set)
+        full_fields = extract_graphql_fields(info=info)
         need_base_changes = "num_untracked_base_changes" in full_fields
         need_branch_changes = "num_untracked_diff_changes" in full_fields
         if need_base_changes or need_branch_changes: