infrahub-server 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

infrahub/core/diff/enricher/hierarchy.py

@@ -12,6 +12,7 @@ from infrahub.log import get_logger
 from ..model.path import (
     CalculatedDiffs,
     EnrichedDiffRoot,
+    NodeIdentifier,
 )
 from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
 from .interface import DiffEnricherInterface
@@ -37,8 +38,8 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         log.info("Beginning hierarchical diff enrichment...")
         self.parent_adder.initialize(enriched_diff_root=enriched_diff_root)
-        node_rel_parent_map: dict[str, list[str]] = defaultdict(list)
-        node_hierarchy_map: dict[str, list[str]] = defaultdict(list)
+        node_rel_parent_map: dict[str, list[NodeIdentifier]] = defaultdict(list)
+        node_hierarchy_map: dict[str, list[NodeIdentifier]] = defaultdict(list)
 
         for node in enriched_diff_root.nodes:
             schema_node = self.db.schema.get(
@@ -49,14 +50,14 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                 continue
 
             if schema_node.has_parent_relationship:
-                node_rel_parent_map[node.kind].append(node.uuid)
+                node_rel_parent_map[node.kind].append(node.identifier)
                 continue
 
             try:
                 hierarchy_schema = schema_node.get_hierarchy_schema(
                     db=self.db, branch=enriched_diff_root.diff_branch_name
                 )
-                node_hierarchy_map[hierarchy_schema.kind].append(node.uuid)
+                node_hierarchy_map[hierarchy_schema.kind].append(node.identifier)
             except ValueError:
                 pass
 
@@ -67,21 +68,21 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
     async def _enrich_hierarchical_nodes(
         self,
         enriched_diff_root: EnrichedDiffRoot,
-        node_map: dict[str, list[str]],
+        node_map: dict[str, list[NodeIdentifier]],
     ) -> None:
         diff_branch = registry.get_branch_from_registry(branch=enriched_diff_root.diff_branch_name)
 
         # Retrieve the ID of all ancestors
-        for kind, node_ids in node_map.items():
-            log.info(f"Beginning hierarchy enrichment for {kind} node, num_nodes={len(node_ids)}...")
+        for kind, node_identifiers in node_map.items():
+            log.info(f"Beginning hierarchy enrichment for {kind} node, num_nodes={len(node_identifiers)}...")
             hierarchy_schema = self.db.schema.get(
                 name=kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
-            for node_id in node_ids:
+            for node_identifier in node_identifiers:
                 query = await NodeGetHierarchyQuery.init(
                     db=self.db,
                     direction=RelationshipHierarchyDirection.ANCESTORS,
-                    node_id=node_id,
+                    node_id=node_identifier.uuid,
                     node_schema=hierarchy_schema,
                     branch=diff_branch,
                     hierarchical_ordering=True,
@@ -93,15 +94,15 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                 if not ancestors:
                     continue
 
-                node = enriched_diff_root.get_node(node_uuid=node_id)
+                node = enriched_diff_root.get_node(node_identifier=node_identifier)
                 parent_rel = hierarchy_schema.get_relationship(name="parent")
 
                 current_node = node
                 for ancestor in ancestors:
+                    ancestor_identifier = NodeIdentifier(uuid=ancestor.uuid, kind=ancestor.kind, labels=ancestor.labels)
                     parent_request = ParentNodeAddRequest(
-                        node_id=current_node.uuid,
-                        parent_id=str(ancestor.uuid),
-                        parent_kind=ancestor.kind,
+                        node_identifier=current_node.identifier,
+                        parent_identifier=ancestor_identifier,
                         parent_label="",
                         parent_rel_name=parent_rel.name,
                         parent_rel_identifier=parent_rel.get_identifier(),
@@ -113,20 +114,20 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                     current_node = parent
 
     async def _enrich_nodes_with_parent(
-        self, enriched_diff_root: EnrichedDiffRoot, node_map: dict[str, list[str]]
+        self, enriched_diff_root: EnrichedDiffRoot, node_map: dict[str, list[NodeIdentifier]]
     ) -> None:
         diff_branch = registry.get_branch_from_registry(branch=enriched_diff_root.diff_branch_name)
 
-        parent_peers: dict[str, RelationshipPeerData] = {}
+        parent_peers: dict[NodeIdentifier, RelationshipPeerData] = {}
 
         # Prepare a map to capture all parents that also have a parent
-        node_parent_with_parent_map: dict[str, list[str]] = defaultdict(list)
+        node_parent_with_parent_map: dict[str, list[NodeIdentifier]] = defaultdict(list)
 
         # TODO Not gonna implement it now but technically we could check the content of the node to see if the parent relationship is present
 
         # Query the UUID of the parent
-        for kind, ids in node_map.items():
-            log.info(f"Beginning parent enrichment for {kind} node, num_nodes={len(ids)}...")
+        for kind, node_identifiers in node_map.items():
+            log.info(f"Beginning parent enrichment for {kind} node, num_nodes={len(node_identifiers)}...")
             schema_node = self.db.schema.get(name=kind, branch=enriched_diff_root.diff_branch_name, duplicate=False)
 
             parent_rel = [rel for rel in schema_node.relationships if rel.kind == RelationshipKind.PARENT][0]
@@ -137,33 +138,43 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
             query = await RelationshipGetPeerQuery.init(
                 db=self.db,
                 branch=diff_branch,
-                source_ids=ids,
+                source_ids=[ni.uuid for ni in node_identifiers],
                 rel_type=DatabaseEdgeType.IS_RELATED.value,
                 schema=parent_rel,
             )
             await query.execute(db=self.db)
 
             for peer in query.get_peers():
-                parent_peers[str(peer.source_id)] = peer
+                source_identifier = NodeIdentifier(
+                    uuid=str(peer.source_id), kind=peer.source_kind, labels=peer.source_labels
+                )
+                parent_peers[source_identifier] = peer
                 if parent_schema.has_parent_relationship:
-                    node_parent_with_parent_map[parent_schema.kind].append(str(peer.peer_id))
+                    peer_identifier = NodeIdentifier(
+                        uuid=str(peer.peer_id), kind=peer.peer_kind, labels=peer.peer_labels
+                    )
+                    node_parent_with_parent_map[parent_schema.kind].append(peer_identifier)
 
         # Check if the parent are already present
         # If parent is already in the list of node we need to add a relationship
         # If parent is not in the list of node, we need to add it
-        diff_node_map = enriched_diff_root.get_node_map(node_uuids=set(parent_peers.keys()))
-        for node_id, peer_parent in parent_peers.items():
+        diff_node_map = enriched_diff_root.get_node_map(
+            node_uuids={source_identifier.uuid for source_identifier in parent_peers.keys()}
+        )
+        for node_identifier, peer_parent in parent_peers.items():
             # TODO check if we can optimize this part to avoid querying this multiple times
-            node = diff_node_map[node_id]
+            node = diff_node_map[node_identifier]
             schema_node = self.db.schema.get(
                 name=node.kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
             parent_rel = [rel for rel in schema_node.relationships if rel.kind == RelationshipKind.PARENT][0]
 
+            peer_identifier = NodeIdentifier(
+                uuid=str(peer_parent.peer_id), kind=peer_parent.peer_kind, labels=peer_parent.peer_labels
+            )
             parent_request = ParentNodeAddRequest(
-                node_id=node.uuid,
-                parent_id=str(peer_parent.peer_id),
-                parent_kind=peer_parent.peer_kind,
+                node_identifier=node.identifier,
+                parent_identifier=peer_identifier,
                 parent_label="",
                 parent_rel_name=parent_rel.name,
                 parent_rel_identifier=parent_rel.get_identifier(),

infrahub/core/diff/ipam_diff_parser.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from infrahub.core.constants import DiffAction
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.diff.model.path import BranchTrackingId
+from infrahub.core.diff.query.filters import EnrichedDiffQueryFilters, IncExclActionFilterOptions, IncExclFilterOptions
 from infrahub.core.ipam.kinds_getter import IpamKindsGetter
 from infrahub.core.ipam.model import IpamNodeDetails
 from infrahub.core.manager import NodeManager
@@ -48,10 +49,10 @@ class IpamDiffParser:
             base_branch_name=target_branch_name,
             diff_branch_names=[source_branch_name],
             tracking_id=BranchTrackingId(name=source_branch_name),
-            filters={
-                "kind": {"includes": list(ip_address_kinds | ip_prefix_kinds)},
-                "status": {"excludes": {DiffAction.UNCHANGED}},
-            },
+            filters=EnrichedDiffQueryFilters(
+                kind=IncExclFilterOptions(includes=list(ip_address_kinds | ip_prefix_kinds)),
+                status=IncExclActionFilterOptions(excludes={DiffAction.UNCHANGED}),
+            ),
         )
         changed_node_details: list[ChangedIpamNodeDetails] = []
         for diff in enriched_diffs:

infrahub/core/diff/merger/merger.py

@@ -54,24 +54,26 @@ class DiffMerger:
         log.info(f"Diff {latest_diff.uuid} retrieved")
         batch_num = 0
         async for node_diff_dicts, property_diff_dicts in self.serializer.serialize_diff(diff=enriched_diff):
-            log.info(f"Merging batch of nodes #{batch_num}")
-            merge_query = await DiffMergeQuery.init(
-                db=self.db,
-                branch=self.source_branch,
-                at=at,
-                target_branch=self.destination_branch,
-                node_diff_dicts=node_diff_dicts,
-            )
-            await merge_query.execute(db=self.db)
-            log.info(f"Merging batch of properties #{batch_num}")
-            merge_properties_query = await DiffMergePropertiesQuery.init(
-                db=self.db,
-                branch=self.source_branch,
-                at=at,
-                target_branch=self.destination_branch,
-                property_diff_dicts=property_diff_dicts,
-            )
-            await merge_properties_query.execute(db=self.db)
+            if node_diff_dicts:
+                log.info(f"Merging batch of nodes #{batch_num}")
+                merge_query = await DiffMergeQuery.init(
+                    db=self.db,
+                    branch=self.source_branch,
+                    at=at,
+                    target_branch=self.destination_branch,
+                    node_diff_dicts=node_diff_dicts,
+                )
+                await merge_query.execute(db=self.db)
+            if property_diff_dicts:
+                log.info(f"Merging batch of properties #{batch_num}")
+                merge_properties_query = await DiffMergePropertiesQuery.init(
+                    db=self.db,
+                    branch=self.source_branch,
+                    at=at,
+                    target_branch=self.destination_branch,
+                    property_diff_dicts=property_diff_dicts,
+                )
+                await merge_properties_query.execute(db=self.db)
             log.info(f"Batch #{batch_num} merged")
             batch_num += 1
 

infrahub/core/diff/model/field_specifiers_map.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+
+class NodeFieldSpecifierMap:
+    def __init__(self) -> None:
+        # {uuid: {kind: {field_name, ...}}}
+        self._map: dict[str, dict[str, set[str]]] = {}
+
+    def __len__(self) -> int:
+        return len(self._map)
+
+    def __hash__(self) -> int:
+        full_node_hash_sum = 0
+        for node_uuid, node_dict in self._map.items():
+            node_kinds_hash_sum = 0
+            for kind, field_names in node_dict.items():
+                fields_hash = hash(frozenset(field_names))
+                node_kinds_hash_sum += hash(f"{hash(kind)}:{fields_hash}")
+            full_node_hash_sum += hash(f"{node_uuid}:{node_kinds_hash_sum}")
+        return hash(full_node_hash_sum)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NodeFieldSpecifierMap):
+            return False
+        return self._map == other._map
+
+    def __sub__(self, other: NodeFieldSpecifierMap) -> NodeFieldSpecifierMap:
+        subtracted = NodeFieldSpecifierMap()
+        for node_uuid, node_dict in self._map.items():
+            if node_uuid not in other._map:
+                subtracted._map[node_uuid] = {**node_dict}
+                continue
+            subtracted_node_map = {}
+            for kind, field_names in node_dict.items():
+                subtracted_field_names = field_names - other._map[node_uuid].get(kind, set())
+                if not subtracted_field_names:
+                    continue
+                subtracted_node_map[kind] = subtracted_field_names
+            if not subtracted_node_map:
+                continue
+            subtracted._map[node_uuid] = subtracted_node_map
+        return subtracted
+
+    def add_entry(self, node_uuid: str, kind: str, field_name: str) -> None:
+        if node_uuid not in self._map:
+            self._map[node_uuid] = {}
+        if kind not in self._map[node_uuid]:
+            self._map[node_uuid][kind] = set()
+        self._map[node_uuid][kind].add(field_name)
+
+    def has_entry(self, node_uuid: str, kind: str, field_name: str) -> bool:
+        return field_name in self._map.get(node_uuid, {}).get(kind, set())
+
+    def get_uuids_list(self) -> list[str]:
+        return list(self._map.keys())
+
+    def get_uuid_field_names_map(self) -> dict[str, list[str]]:
+        uuid_field_names_map: dict[str, list[str]] = {}
+        for node_uuid, node_dict in self._map.items():
+            field_names_set: set[str] = set()
+            for field_names in node_dict.values():
+                field_names_set |= field_names
+            uuid_field_names_map[node_uuid] = list(field_names_set)
+        return uuid_field_names_map

infrahub/core/diff/model/path.py

@@ -81,6 +81,21 @@ def deserialize_tracking_id(tracking_id_str: str) -> TrackingId:
     raise ValueError(f"{tracking_id_str} is not a valid TrackingId")
 
 
+@dataclass
+class NodeIdentifier:
+    """Uniquely identifying nodes that have had their kind or inheritance updated requires all of these fields"""
+
+    uuid: str
+    kind: str
+    labels: frozenset[str]
+
+    def __hash__(self) -> int:
+        return hash(f"{self.uuid}:{self.kind}:{hash(self.labels)}")
+
+    def __str__(self) -> str:
+        return f"{self.kind} '{self.uuid}' ({','.join(self.labels)})"
+
+
 @dataclass
 class NodeDiffFieldSummary:
     kind: str
@@ -307,8 +322,7 @@ class ParentNodeInfo:
 
 @dataclass
 class EnrichedDiffNode(BaseSummary):
-    uuid: str
-    kind: str
+    identifier: NodeIdentifier
     label: str
     path_identifier: str = field(default="", kw_only=True)
     changed_at: Timestamp | None = field(default=None, kw_only=True)
@@ -318,7 +332,15 @@ class EnrichedDiffNode(BaseSummary):
     relationships: set[EnrichedDiffRelationship] = field(default_factory=set)
 
     def __hash__(self) -> int:
-        return hash(self.uuid)
+        return hash(self.identifier)
+
+    @property
+    def uuid(self) -> str:
+        return self.identifier.uuid
+
+    @property
+    def kind(self) -> str:
+        return self.identifier.kind
 
     @property
     def num_properties(self) -> int:
@@ -402,8 +424,7 @@ class EnrichedDiffNode(BaseSummary):
     @classmethod
     def from_calculated_node(cls, calculated_node: DiffNode) -> EnrichedDiffNode:
         return EnrichedDiffNode(
-            uuid=calculated_node.uuid,
-            kind=calculated_node.kind,
+            identifier=calculated_node.identifier,
             label="",
             changed_at=calculated_node.changed_at,
             action=calculated_node.action,
@@ -473,24 +494,24 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
                 nodes_with_parent_uuids |= {child_n.uuid for child_n in r.nodes}
         return {node for node in self.nodes if node.uuid not in nodes_with_parent_uuids}
 
-    def get_node(self, node_uuid: str) -> EnrichedDiffNode:
+    def get_node(self, node_identifier: NodeIdentifier) -> EnrichedDiffNode:
         for n in self.nodes:
-            if n.uuid == node_uuid:
+            if n.identifier == node_identifier:
                 return n
-        raise ValueError(f"No node {node_uuid} in diff root")
+        raise ValueError(f"No node {node_identifier} in diff root")
 
-    def has_node(self, node_uuid: str) -> bool:
+    def has_node(self, node_identifier: NodeIdentifier) -> bool:
         try:
-            self.get_node(node_uuid=node_uuid)
+            self.get_node(node_identifier=node_identifier)
             return True
         except ValueError:
             return False
 
-    def get_node_map(self, node_uuids: set[str] | None = None) -> dict[str, EnrichedDiffNode]:
+    def get_node_map(self, node_uuids: set[str] | None = None) -> dict[NodeIdentifier, EnrichedDiffNode]:
         node_map = {}
         for node in self.nodes:
-            if node_uuids is None or node.uuid in node_uuids:
-                node_map[node.uuid] = node
+            if node_uuids is None or node.identifier.uuid in node_uuids:
+                node_map[node.identifier] = node
         return node_map
 
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
@@ -522,49 +543,6 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
             nodes={EnrichedDiffNode.from_calculated_node(calculated_node=n) for n in calculated_diff.nodes},
         )
 
-    def add_parent(
-        self,
-        node_id: str,
-        parent_id: str,
-        parent_kind: str,
-        parent_label: str,
-        parent_rel_name: str,
-        parent_rel_identifier: str,
-        parent_rel_cardinality: RelationshipCardinality,
-        parent_rel_label: str = "",
-    ) -> EnrichedDiffNode:
-        node = self.get_node(node_uuid=node_id)
-        if not self.has_node(node_uuid=parent_id):
-            parent = EnrichedDiffNode(
-                uuid=parent_id,
-                kind=parent_kind,
-                label=parent_label,
-                action=DiffAction.UNCHANGED,
-                changed_at=None,
-            )
-            self.nodes.add(parent)
-
-        else:
-            parent = self.get_node(node_uuid=parent_id)
-
-        if node.has_relationship(name=parent_rel_name):
-            rel = node.get_relationship(name=parent_rel_name)
-            rel.nodes.add(parent)
-        else:
-            node.relationships.add(
-                EnrichedDiffRelationship(
-                    name=parent_rel_name,
-                    identifier=parent_rel_identifier,
-                    label=parent_rel_label,
-                    cardinality=parent_rel_cardinality,
-                    changed_at=None,
-                    action=DiffAction.UNCHANGED,
-                    nodes={parent},
-                )
-            )
-
-        return parent
-
 
 @dataclass
 class EnrichedDiffsMetadata:
@@ -650,6 +628,14 @@ class EnrichedDiffs(EnrichedDiffsMetadata):
     def branch_node_uuids(self) -> set[str]:
         return {n.uuid for n in self.diff_branch_diff.nodes}
 
+    @property
+    def base_node_identifiers(self) -> set[NodeIdentifier]:
+        return {n.identifier for n in self.base_branch_diff.nodes}
+
+    @property
+    def branch_node_identifiers(self) -> set[NodeIdentifier]:
+        return {n.identifier for n in self.diff_branch_diff.nodes}
+
 
 @dataclass
 class CalculatedDiffs:
@@ -697,13 +683,20 @@ class DiffRelationship:
 
 @dataclass
 class DiffNode:
-    uuid: str
-    kind: str
+    identifier: NodeIdentifier
     changed_at: Timestamp
     action: DiffAction
     attributes: list[DiffAttribute] = field(default_factory=list)
     relationships: list[DiffRelationship] = field(default_factory=list)
 
+    @property
+    def uuid(self) -> str:
+        return self.identifier.uuid
+
+    @property
+    def kind(self) -> str:
+        return self.identifier.kind
+
 
 @dataclass
 class DiffRoot:
@@ -780,6 +773,10 @@ class DatabasePath:
     def node_db_id(self) -> str:
         return self.node_node.element_id
 
+    @property
+    def node_labels(self) -> frozenset[str]:
+        return self.node_node.labels
+
     @property
     def node_kind(self) -> str:
         return str(self.node_node.get("kind"))

infrahub/core/diff/parent_node_adder.py

@@ -2,14 +2,13 @@ from dataclasses import dataclass, field
 
 from infrahub.core.constants import DiffAction, RelationshipCardinality
 
-from .model.path import EnrichedDiffNode, EnrichedDiffRelationship, EnrichedDiffRoot
+from .model.path import EnrichedDiffNode, EnrichedDiffRelationship, EnrichedDiffRoot, NodeIdentifier
 
 
 @dataclass
 class ParentNodeAddRequest:
-    node_id: str
-    parent_id: str
-    parent_kind: str
+    node_identifier: NodeIdentifier
+    parent_identifier: NodeIdentifier
     parent_label: str
     parent_rel_name: str
     parent_rel_identifier: str
@@ -20,7 +19,7 @@ class ParentNodeAddRequest:
 class DiffParentNodeAdder:
     def __init__(self) -> None:
         self._diff_root: EnrichedDiffRoot | None = None
-        self._node_map: dict[str, EnrichedDiffNode] = {}
+        self._node_map: dict[NodeIdentifier, EnrichedDiffNode] = {}
 
     def initialize(self, enriched_diff_root: EnrichedDiffRoot) -> None:
         self._diff_root = enriched_diff_root
@@ -31,33 +30,32 @@ class DiffParentNodeAdder:
             raise RuntimeError("Must call initialize before using")
         return self._diff_root
 
-    def get_node(self, node_uuid: str) -> EnrichedDiffNode:
-        return self._node_map[node_uuid]
+    def get_node(self, identifier: NodeIdentifier) -> EnrichedDiffNode:
+        return self._node_map[identifier]
 
-    def has_node(self, node_uuid: str) -> bool:
-        return node_uuid in self._node_map
+    def has_node(self, identifier: NodeIdentifier) -> bool:
+        return identifier in self._node_map
 
     def add_node(self, node: EnrichedDiffNode) -> None:
-        if node.uuid in self._node_map:
+        if node.identifier in self._node_map:
             return
-        self._node_map[node.uuid] = node
+        self._node_map[node.identifier] = node
         self.get_root().nodes.add(node)
 
     def add_parent(self, parent_request: ParentNodeAddRequest) -> EnrichedDiffNode:
         if not self._diff_root:
             raise RuntimeError("Must call initialize before using")
-        node = self.get_node(node_uuid=parent_request.node_id)
-        if not self.has_node(node_uuid=parent_request.parent_id):
+        node = self.get_node(identifier=parent_request.node_identifier)
+        if not self.has_node(identifier=parent_request.parent_identifier):
             parent = EnrichedDiffNode(
-                uuid=parent_request.parent_id,
-                kind=parent_request.parent_kind,
+                identifier=parent_request.parent_identifier,
                 label=parent_request.parent_label,
                 action=DiffAction.UNCHANGED,
                 changed_at=None,
             )
             self.add_node(parent)
         else:
-            parent = self.get_node(node_uuid=parent_request.parent_id)
+            parent = self.get_node(identifier=parent_request.parent_identifier)
 
         try:
             rel = node.get_relationship(name=parent_request.parent_rel_name)

infrahub/core/diff/query/drop_nodes.py

@@ -0,0 +1,42 @@
+from typing import Any
+
+from infrahub.core.diff.model.path import NodeIdentifier
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+
+class EnrichedDiffDropNodesQuery(Query):
+    name = "enriched_diff_drop_nodes"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(self, enriched_diff_uuid: str, node_identifiers: list[NodeIdentifier], **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.enriched_diff_uuid = enriched_diff_uuid
+        self.node_identifiers = node_identifiers
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params = {
+            "diff_root_uuid": self.enriched_diff_uuid,
+            "node_uuids": [ni.uuid for ni in self.node_identifiers],
+            "node_identifiers_map": {ni.uuid: ni.kind for ni in self.node_identifiers},
+        }
+        query = """
+        MATCH (d_root:DiffRoot {uuid: $diff_root_uuid})
+        MATCH (d_root)-[:DIFF_HAS_NODE]->(dn:DiffNode)
+        WHERE dn.uuid IN $node_uuids
+        AND dn.kind IN $node_identifiers_map[dn.uuid]
+        OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]-(da:DiffAttribute)
+        OPTIONAL MATCH (da)-[*]->(diff_thing)
+        DETACH DELETE diff_thing
+        DETACH DELETE da
+        WITH dn
+        OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement)
+        OPTIONAL MATCH (dre)-[*]->(diff_thing)
+        DETACH DELETE diff_thing
+        DETACH DELETE dre
+        DETACH DELETE dr
+        DETACH DELETE dn
+        """
+        self.add_to_query(query=query)

infrahub/core/diff/query/field_specifiers.py

@@ -18,20 +18,21 @@ class EnrichedDiffFieldSpecifiersQuery(Query):
 CALL {
     MATCH (root:DiffRoot {uuid: $diff_id})-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_ATTRIBUTE]->(attr:DiffAttribute)
     WHERE (root.is_merged IS NULL OR root.is_merged <> TRUE)
-    RETURN node.uuid AS node_uuid, attr.name AS field_name
+    RETURN node.uuid AS node_uuid, node.kind AS node_kind, attr.name AS field_name
     UNION
     MATCH (root:DiffRoot {uuid: $diff_id})-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_RELATIONSHIP]->(rel:DiffRelationship)
     WHERE (root.is_merged IS NULL OR root.is_merged <> TRUE)
-    RETURN node.uuid AS node_uuid, rel.identifier AS field_name
+    RETURN node.uuid AS node_uuid, node.kind AS node_kind, rel.identifier AS field_name
 }
         """
         self.add_to_query(query=query)
-        self.return_labels = ["node_uuid", "field_name"]
-        self.order_by = ["node_uuid", "field_name"]
+        self.return_labels = ["node_uuid", "node_kind", "field_name"]
+        self.order_by = ["node_uuid", "node_kind", "field_name"]
 
-    def get_node_field_specifier_tuples(self) -> Generator[tuple[str, str], None, None]:
+    def get_node_field_specifier_tuples(self) -> Generator[tuple[str, str, str], None, None]:
         for result in self.get_results():
             node_uuid = result.get_as_str("node_uuid")
+            node_kind = result.get_as_str("node_kind")
             field_name = result.get_as_str("field_name")
-            if node_uuid and field_name:
-                yield (node_uuid, field_name)
+            if node_uuid and node_kind and field_name:
+                yield (node_uuid, node_kind, field_name)