infrahub-server 1.2.9rc0__py3-none-any.whl → 1.2.11__py3-none-any.whl

infrahub/core/diff/coordinator.py

@@ -9,6 +9,7 @@ from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import ValidationError
 from infrahub.log import get_logger
 
+from .model.field_specifiers_map import NodeFieldSpecifierMap
 from .model.path import (
     BranchTrackingId,
     EnrichedDiffRoot,
@@ -16,6 +17,7 @@ from .model.path import (
     EnrichedDiffs,
     EnrichedDiffsMetadata,
     NameTrackingId,
+    NodeIdentifier,
     TrackingId,
 )
 
@@ -43,7 +45,7 @@ class EnrichedDiffRequest:
     from_time: Timestamp
     to_time: Timestamp
     tracking_id: TrackingId
-    node_field_specifiers: dict[str, set[str]] = field(default_factory=dict)
+    node_field_specifiers: NodeFieldSpecifierMap = field(default_factory=NodeFieldSpecifierMap)
 
     def __repr__(self) -> str:
         return (
@@ -141,7 +143,7 @@ class DiffCoordinator:
             self.lock_registry.get(name=incremental_lock_name, namespace=self.lock_namespace),
         ):
             log.info(f"Acquired lock to run branch diff update for {base_branch.name} - {diff_branch.name}")
-            enriched_diffs = await self._update_diffs(
+            enriched_diffs, node_identifiers_to_drop = await self._update_diffs(
                 base_branch=base_branch,
                 diff_branch=diff_branch,
                 from_time=from_time,
@@ -149,7 +151,9 @@ class DiffCoordinator:
                 tracking_id=tracking_id,
                 force_branch_refresh=False,
             )
-            await self.diff_repo.save(enriched_diffs=enriched_diffs)
+            await self.diff_repo.save(
+                enriched_diffs=enriched_diffs, node_identifiers_to_drop=list(node_identifiers_to_drop)
+            )
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Branch diff update complete for {base_branch.name} - {diff_branch.name}")
         return enriched_diffs.diff_branch_diff
@@ -168,7 +172,7 @@ class DiffCoordinator:
         )
         async with self.lock_registry.get(name=general_lock_name, namespace=self.lock_namespace):
             log.info(f"Acquired lock to run arbitrary diff update for {base_branch.name} - {diff_branch.name}")
-            enriched_diffs = await self._update_diffs(
+            enriched_diffs, node_identifiers_to_drop = await self._update_diffs(
                 base_branch=base_branch,
                 diff_branch=diff_branch,
                 from_time=from_time,
@@ -177,7 +181,9 @@ class DiffCoordinator:
                 force_branch_refresh=False,
             )
 
-            await self.diff_repo.save(enriched_diffs=enriched_diffs)
+            await self.diff_repo.save(
+                enriched_diffs=enriched_diffs, node_identifiers_to_drop=list(node_identifiers_to_drop)
+            )
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Arbitrary diff update complete for {base_branch.name} - {diff_branch.name}")
         return enriched_diffs.diff_branch_diff
@@ -205,7 +211,7 @@ class DiffCoordinator:
             from_time = current_branch_diff.from_time
             branched_from_time = Timestamp(diff_branch.get_branched_from())
             from_time = max(from_time, branched_from_time)
-            enriched_diffs = await self._update_diffs(
+            enriched_diffs, _ = await self._update_diffs(
                 base_branch=base_branch,
                 diff_branch=diff_branch,
                 from_time=branched_from_time,
@@ -282,7 +288,7 @@ class DiffCoordinator:
         to_time: Timestamp,
         tracking_id: TrackingId,
         force_branch_refresh: Literal[True] = ...,
-    ) -> EnrichedDiffs: ...
+    ) -> tuple[EnrichedDiffs, set[NodeIdentifier]]: ...
 
     @overload
     async def _update_diffs(
@@ -293,7 +299,7 @@ class DiffCoordinator:
         to_time: Timestamp,
         tracking_id: TrackingId,
         force_branch_refresh: Literal[False] = ...,
-    ) -> EnrichedDiffs | EnrichedDiffsMetadata: ...
+    ) -> tuple[EnrichedDiffs | EnrichedDiffsMetadata, set[NodeIdentifier]]: ...
 
     async def _update_diffs(
         self,
@@ -303,7 +309,7 @@ class DiffCoordinator:
         to_time: Timestamp,
         tracking_id: TrackingId,
         force_branch_refresh: bool = False,
-    ) -> EnrichedDiffs | EnrichedDiffsMetadata:
+    ) -> tuple[EnrichedDiffs | EnrichedDiffsMetadata, set[NodeIdentifier]]:
         # start with empty diffs b/c we only care about their metadata for now, hydrate them with data as needed
         diff_pairs_metadata = await self.diff_repo.get_diff_pairs_metadata(
             base_branch_names=[base_branch.name],
@@ -312,7 +318,7 @@ class DiffCoordinator:
             to_time=to_time,
             tracking_id=tracking_id,
         )
-        aggregated_enriched_diffs = await self._aggregate_enriched_diffs(
+        aggregated_enriched_diffs, node_identifiers_to_drop = await self._aggregate_enriched_diffs(
             diff_request=EnrichedDiffRequest(
                 base_branch=base_branch,
                 diff_branch=diff_branch,
@@ -343,7 +349,7 @@ class DiffCoordinator:
         # this is an EnrichedDiffsMetadata, so there are no nodes to enrich
         if not isinstance(aggregated_enriched_diffs, EnrichedDiffs):
             aggregated_enriched_diffs.update_metadata(from_time=from_time, to_time=to_time, tracking_id=tracking_id)
-            return aggregated_enriched_diffs
+            return aggregated_enriched_diffs, set()
 
         await self.conflicts_enricher.add_conflicts_to_branch_diff(
             base_diff_root=aggregated_enriched_diffs.base_branch_diff,
@@ -353,27 +359,27 @@ class DiffCoordinator:
             enriched_diff_root=aggregated_enriched_diffs.diff_branch_diff, conflicts_only=True
         )
 
-        return aggregated_enriched_diffs
+        return aggregated_enriched_diffs, node_identifiers_to_drop
 
     @overload
     async def _aggregate_enriched_diffs(
         self,
         diff_request: EnrichedDiffRequest,
         partial_enriched_diffs: list[EnrichedDiffsMetadata],
-    ) -> EnrichedDiffs | EnrichedDiffsMetadata: ...
+    ) -> tuple[EnrichedDiffs | EnrichedDiffsMetadata, set[NodeIdentifier]]: ...
 
     @overload
     async def _aggregate_enriched_diffs(
         self,
         diff_request: EnrichedDiffRequest,
         partial_enriched_diffs: None,
-    ) -> EnrichedDiffs: ...
+    ) -> tuple[EnrichedDiffs, set[NodeIdentifier]]: ...
 
     async def _aggregate_enriched_diffs(
         self,
         diff_request: EnrichedDiffRequest,
         partial_enriched_diffs: list[EnrichedDiffsMetadata] | None,
-    ) -> EnrichedDiffs | EnrichedDiffsMetadata:
+    ) -> tuple[EnrichedDiffs | EnrichedDiffsMetadata, set[NodeIdentifier]]:
         """
         If return is an EnrichedDiffsMetadata, it acts as a pointer to a diff in the database that has all the
             necessary data for this diff_request. Might have a different time range and/or tracking_id
@@ -385,6 +391,7 @@ class DiffCoordinator:
                 diff_request=diff_request, is_incremental_diff=False
             )
 
+        node_identifiers_to_drop: set[NodeIdentifier] = set()
         if partial_enriched_diffs is not None and not aggregated_enriched_diffs:
             ordered_diffs = self._get_ordered_diff_pairs(diff_pairs=partial_enriched_diffs, allow_overlap=False)
             ordered_diff_reprs = [repr(d) for d in ordered_diffs]
@@ -430,31 +437,31 @@ class DiffCoordinator:
                 )
                 current_time = end_time
 
-            aggregated_enriched_diffs = await self._concatenate_diffs_and_requests(
+            aggregated_enriched_diffs, node_identifiers_to_drop = await self._concatenate_diffs_and_requests(
                 diff_or_request_list=incremental_diffs_and_requests, full_diff_request=diff_request
             )
 
         # no changes during this time period, so generate an EnrichedDiffs with no nodes
         if not aggregated_enriched_diffs:
-            return self._build_enriched_diffs_with_no_nodes(diff_request=diff_request)
+            return self._build_enriched_diffs_with_no_nodes(diff_request=diff_request), node_identifiers_to_drop
 
         # metadata-only diff, means that a diff exists in the database that covers at least
         # part of this time period, but it might need to have its start or end time extended
         # to cover time ranges with no changes
         if not isinstance(aggregated_enriched_diffs, EnrichedDiffs):
-            return aggregated_enriched_diffs
+            return aggregated_enriched_diffs, node_identifiers_to_drop
 
         # a new diff (with nodes) covering the time period
         aggregated_enriched_diffs.update_metadata(
             from_time=diff_request.from_time, to_time=diff_request.to_time, tracking_id=diff_request.tracking_id
         )
-        return aggregated_enriched_diffs
+        return aggregated_enriched_diffs, node_identifiers_to_drop
 
     async def _concatenate_diffs_and_requests(
         self,
         diff_or_request_list: Sequence[EnrichedDiffsMetadata | EnrichedDiffRequest | None],
         full_diff_request: EnrichedDiffRequest,
-    ) -> EnrichedDiffs | EnrichedDiffsMetadata | None:
+    ) -> tuple[EnrichedDiffs | EnrichedDiffsMetadata | None, set[NodeIdentifier]]:
         """
         Returns None if diff_or_request_list is empty or all Nones
             meaning there are no changes for the diff during this time period
@@ -464,7 +471,7 @@ class DiffCoordinator:
             meaning multiple diffs (some that may have been freshly calculated) were combined
         """
         previous_diff_pair: EnrichedDiffs | EnrichedDiffsMetadata | None = None
-        updated_node_uuids: set[str] = set()
+        updated_node_identifiers: set[NodeIdentifier] = set()
         for diff_or_request in diff_or_request_list:
             if isinstance(diff_or_request, EnrichedDiffRequest):
                 if previous_diff_pair:
@@ -478,8 +485,8 @@ class DiffCoordinator:
                 calculated_diff = await self._calculate_enriched_diff(
                     diff_request=diff_or_request, is_incremental_diff=is_incremental_diff
                 )
-                updated_node_uuids |= calculated_diff.base_node_uuids
-                updated_node_uuids |= calculated_diff.branch_node_uuids
+                updated_node_identifiers |= calculated_diff.base_node_identifiers
+                updated_node_identifiers |= calculated_diff.branch_node_identifiers
                 single_enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata = calculated_diff
 
             elif isinstance(diff_or_request, EnrichedDiffsMetadata):
@@ -495,17 +502,22 @@ class DiffCoordinator:
             previous_diff_pair = await self._combine_diffs(
                 earlier=previous_diff_pair,
                 later=single_enriched_diffs,
-                node_uuids=updated_node_uuids,
+                node_identifiers=updated_node_identifiers,
             )
             log.info("Diffs combined.")
 
-        return previous_diff_pair
+        node_identifiers_to_drop: set[NodeIdentifier] = set()
+        if isinstance(previous_diff_pair, EnrichedDiffs):
+            # nodes that were updated and that no longer exist on this diff have been removed
+            node_identifiers_to_drop = updated_node_identifiers - previous_diff_pair.branch_node_identifiers
+
+        return previous_diff_pair, node_identifiers_to_drop
 
     async def _combine_diffs(
         self,
         earlier: EnrichedDiffs | EnrichedDiffsMetadata,
         later: EnrichedDiffs | EnrichedDiffsMetadata,
-        node_uuids: set[str],
+        node_identifiers: set[NodeIdentifier],
     ) -> EnrichedDiffs | EnrichedDiffsMetadata:
         log.info(f"Earlier diff to combine: {earlier!r}")
         log.info(f"Later diff to combine: {later!r}")
@@ -522,11 +534,15 @@ class DiffCoordinator:
         # hydrate the diffs to combine, if necessary
         if not isinstance(earlier, EnrichedDiffs):
             log.info("Hydrating earlier diff...")
-            earlier = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=earlier, node_uuids=node_uuids)
+            earlier = await self.diff_repo.hydrate_diff_pair(
+                enriched_diffs_metadata=earlier, node_identifiers=node_identifiers
+            )
             log.info("Earlier diff hydrated.")
         if not isinstance(later, EnrichedDiffs):
             log.info("Hydrating later diff...")
-            later = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=later, node_uuids=node_uuids)
+            later = await self.diff_repo.hydrate_diff_pair(
+                enriched_diffs_metadata=later, node_identifiers=node_identifiers
+            )
             log.info("Later diff hydrated.")
 
         return await self.diff_combiner.combine(earlier_diffs=earlier, later_diffs=later)

infrahub/core/diff/data_check_synchronizer.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
 from infrahub.core.constants import BranchConflictKeep, InfrahubKind
+from infrahub.core.diff.query.filters import EnrichedDiffQueryFilters
 from infrahub.core.integrity.object_conflict.conflict_recorder import ObjectConflictValidatorRecorder
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
@@ -74,7 +75,7 @@ class DiffDataCheckSynchronizer:
                 retrieved_diff_conflicts_only = await self.diff_repository.get_one(
                     diff_branch_name=enriched_diff.diff_branch_name,
                     diff_id=enriched_diff.uuid,
-                    filters={"only_conflicted": True},
+                    filters=EnrichedDiffQueryFilters(only_conflicted=True),
                 )
                 enriched_diff_all_conflicts = retrieved_diff_conflicts_only
                 # if `enriched_diff` is an EnrichedDiffRootsMetadata, then there have been no changes to the diff and
@@ -116,7 +117,7 @@ class DiffDataCheckSynchronizer:
     def _update_diff_conflicts(self, updated_diff: EnrichedDiffRoot, retrieved_diff: EnrichedDiffRoot) -> None:
         for updated_node in updated_diff.nodes:
             try:
-                retrieved_node = retrieved_diff.get_node(node_uuid=updated_node.uuid)
+                retrieved_node = retrieved_diff.get_node(node_identifier=updated_node.identifier)
             except ValueError:
                 retrieved_node = None
             if not retrieved_node:

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, db_id=ancestor.db_id)
                     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,41 @@ 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, db_id=peer.source_db_id
+                )
+                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, db_id=peer.peer_db_id)
+                    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, db_id=peer_parent.peer_db_id
+            )
             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

@@ -3,8 +3,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from infrahub.core import registry
+from infrahub.core.constants import DiffAction
 from infrahub.core.diff.model.path import BranchTrackingId
-from infrahub.core.diff.query.merge import DiffMergePropertiesQuery, DiffMergeQuery, DiffMergeRollbackQuery
+from infrahub.core.diff.query.merge import (
+    DiffMergeMigratedKindsQuery,
+    DiffMergePropertiesQuery,
+    DiffMergeQuery,
+    DiffMergeRollbackQuery,
+)
 from infrahub.log import get_logger
 
 if TYPE_CHECKING:
@@ -53,27 +59,51 @@ class DiffMerger:
         )
         log.info(f"Diff {latest_diff.uuid} retrieved")
         batch_num = 0
+        migrated_kinds_id_map = {}
+        for n in enriched_diff.nodes:
+            if not n.is_node_kind_migration:
+                continue
+            if n.uuid not in migrated_kinds_id_map or (
+                n.uuid in migrated_kinds_id_map and n.action is DiffAction.ADDED
+            ):
+                # make sure that we use the ADDED db_id if it exists
+                # it will not if a node was migrated and then deleted
+                migrated_kinds_id_map[n.uuid] = n.identifier.db_id
         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(
+            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,
+                    migrated_kinds_id_map=migrated_kinds_id_map,
+                )
+                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,
+                    migrated_kinds_id_map=migrated_kinds_id_map,
+                )
+                await merge_properties_query.execute(db=self.db)
+            log.info(f"Batch #{batch_num} merged")
+            batch_num += 1
+        migrated_kind_uuids = {n.identifier.uuid for n in enriched_diff.nodes if n.is_node_kind_migration}
+        if migrated_kind_uuids:
+            migrated_merge_query = await DiffMergeMigratedKindsQuery.init(
                 db=self.db,
                 branch=self.source_branch,
                 at=at,
                 target_branch=self.destination_branch,
-                property_diff_dicts=property_diff_dicts,
+                migrated_uuids=list(migrated_kind_uuids),
             )
-            await merge_properties_query.execute(db=self.db)
-            log.info(f"Batch #{batch_num} merged")
-            batch_num += 1
+            await migrated_merge_query.execute(db=self.db)
 
         self.source_branch.branched_from = at.to_string()
         await self.source_branch.save(db=self.db)

infrahub/core/diff/merger/serializer.py

@@ -39,6 +39,7 @@ class DiffMergeSerializer:
 
     def _reset_caches(self) -> None:
         self._attribute_type_cache = {}
+        self._conflicted_cardinality_one_relationships = set()
 
     @property
     def source_branch_name(self) -> str:

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