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

infrahub/computed_attribute/models.py

@@ -118,6 +118,10 @@ class PythonTransformTarget:
 class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
     type: TriggerType = TriggerType.COMPUTED_ATTR_JINJA2
     computed_attribute: ComputedAttributeTarget
+    template_hash: str
+
+    def get_description(self) -> str:
+        return f"{super().get_description()} | hash:{self.template_hash}"
 
     @classmethod
     def from_computed_attribute(
@@ -139,6 +143,14 @@ class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
             # node creation events if the attribute is optional.
             event_trigger.events.add(NodeCreatedEvent.event_name)
 
+        if (
+            computed_attribute.attribute.computed_attribute
+            and computed_attribute.attribute.computed_attribute.jinja2_template is None
+        ) or not computed_attribute.attribute.computed_attribute:
+            raise ValueError("Jinja2 template is required for computed attribute")
+
+        template_hash = computed_attribute.attribute.computed_attribute.get_hash()
+
         event_trigger.match = {"infrahub.node.kind": trigger_node.kind}
         if branches_out_of_scope:
             event_trigger.match["infrahub.branch.name"] = [f"!{branch}" for branch in branches_out_of_scope]
@@ -177,6 +189,7 @@ class ComputedAttrJinja2TriggerDefinition(TriggerBranchDefinition):
 
         definition = cls(
             name=f"{computed_attribute.key_name}{NAME_SEPARATOR}kind{NAME_SEPARATOR}{trigger_node.kind}",
+            template_hash=template_hash,
             branch=branch,
             computed_attribute=computed_attribute,
             trigger=event_trigger,

infrahub/computed_attribute/tasks.py

@@ -14,7 +14,7 @@ from infrahub.core.registry import registry
 from infrahub.events import BranchDeletedEvent
 from infrahub.git.repository import get_initialized_repo
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
-from infrahub.trigger.models import TriggerType
+from infrahub.trigger.models import TriggerSetupReport, TriggerType
 from infrahub.trigger.setup import setup_triggers
 from infrahub.workflows.catalogue import (
     COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
@@ -25,7 +25,11 @@ from infrahub.workflows.catalogue import (
 from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
 
 from .gather import gather_trigger_computed_attribute_jinja2, gather_trigger_computed_attribute_python
-from .models import ComputedAttrJinja2GraphQL, ComputedAttrJinja2GraphQLResponse, PythonTransformTarget
+from .models import (
+    ComputedAttrJinja2GraphQL,
+    ComputedAttrJinja2GraphQLResponse,
+    PythonTransformTarget,
+)
 
 if TYPE_CHECKING:
     from infrahub.core.schema.computed_attribute import ComputedAttribute
@@ -159,10 +163,10 @@ async def trigger_update_python_computed_attributes(
 
 
 @flow(
-    name="process_computed_attribute_value_jinja2",
-    flow_run_name="Update value for computed attribute {attribute_name}",
+    name="computed-attribute-jinja2-update-value",
+    flow_run_name="Update value for computed attribute {node_kind}:{attribute_name}",
 )
-async def update_computed_attribute_value_jinja2(
+async def computed_attribute_jinja2_update_value(
     branch_name: str,
     obj: ComputedAttrJinja2GraphQLResponse,
     node_kind: str,
@@ -246,7 +250,7 @@ async def process_jinja2(
         batch = await service.client.create_batch()
         for node in found:
             batch.add(
-                task=update_computed_attribute_value_jinja2,
+                task=computed_attribute_jinja2_update_value,
                 branch_name=branch_name,
                 obj=node,
                 node_kind=node_schema.kind,
@@ -302,36 +306,33 @@ async def computed_attribute_setup_jinja2(
 
         triggers = await gather_trigger_computed_attribute_jinja2()
 
-        # Since we can have multiple trigger per NodeKind
-        # we need to extract the list of unique node that should be processed
-        # also
-        # Because the automation in Prefect doesn't capture all information about the computed attribute
-        # we can't tell right now if a given computed attribute has changed and need to be updated
-        unique_nodes: set[tuple[str, str, str]] = {
-            (trigger.branch, trigger.computed_attribute.kind, trigger.computed_attribute.attribute.name)
-            for trigger in triggers
-        }
-        for branch, kind, attribute_name in unique_nodes:
-            if event_name != BranchDeletedEvent.event_name and branch == branch_name:
-                await service.workflow.submit_workflow(
-                    workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
-                    context=context,
-                    parameters={
-                        "branch_name": branch,
-                        "computed_attribute_name": attribute_name,
-                        "computed_attribute_kind": kind,
-                    },
-                )
-
         # Configure all ComputedAttrJinja2Trigger in Prefect
         async with get_client(sync_client=False) as prefect_client:
-            await setup_triggers(
+            report: TriggerSetupReport = await setup_triggers(
                 client=prefect_client,
                 triggers=triggers,
                 trigger_type=TriggerType.COMPUTED_ATTR_JINJA2,
                 force_update=False,
             )  # type: ignore[misc]
 
+            # Since we can have multiple trigger per NodeKind
+            # we need to extract the list of unique node that should be processed
+            unique_nodes: set[tuple[str, str, str]] = {
+                (trigger.branch, trigger.computed_attribute.kind, trigger.computed_attribute.attribute.name)  # type: ignore[attr-defined]
+                for trigger in report.updated + report.created
+            }
+            for branch, kind, attribute_name in unique_nodes:
+                if event_name != BranchDeletedEvent.event_name and branch == branch_name:
+                    await service.workflow.submit_workflow(
+                        workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+                        context=context,
+                        parameters={
+                            "branch_name": branch,
+                            "computed_attribute_name": attribute_name,
+                            "computed_attribute_kind": kind,
+                        },
+                    )
+
         log.info(f"{len(triggers)} Computed Attribute for Jinja2 automation configuration completed")
 
 

infrahub/core/attribute.py

@@ -782,6 +782,10 @@ class Dropdown(BaseAttribute):
 
         return ""
 
+    @staticmethod
+    def get_allowed_property_in_path() -> list[str]:
+        return ["color", "description", "label", "value"]
+
     @classmethod
     def validate_content(cls, value: Any, name: str, schema: AttributeSchema) -> None:
         """Validate the content of the dropdown."""
@@ -817,7 +821,18 @@ class IPNetwork(BaseAttribute):
 
     @staticmethod
     def get_allowed_property_in_path() -> list[str]:
-        return ["value", "version", "binary_address", "prefixlen"]
+        return [
+            "binary_address",
+            "broadcast_address",
+            "hostmask",
+            "netmask",
+            "num_addresses",
+            "prefixlen",
+            "value",
+            "version",
+            "with_hostmask",
+            "with_netmask",
+        ]
 
     @property
     def obj(self) -> ipaddress.IPv4Network | ipaddress.IPv6Network:
@@ -950,7 +965,17 @@ class IPHost(BaseAttribute):
 
     @staticmethod
     def get_allowed_property_in_path() -> list[str]:
-        return ["value", "version", "binary_address"]
+        return [
+            "binary_address",
+            "hostmask",
+            "ip",
+            "netmask",
+            "prefixlen",
+            "value",
+            "version",
+            "with_hostmask",
+            "with_netmask",
+        ]
 
     @property
     def obj(self) -> ipaddress.IPv4Interface | ipaddress.IPv6Interface:
@@ -1170,6 +1195,22 @@ class MacAddress(BaseAttribute):
         """Serialize the value as standard EUI-48 or EUI-64 before storing it in the database."""
         return str(netaddr.EUI(addr=self.value))
 
+    @staticmethod
+    def get_allowed_property_in_path() -> list[str]:
+        return [
+            "bare",
+            "binary",
+            "dot_notation",
+            "ei",
+            "eui48",
+            "eui64",
+            "oui",
+            "semicolon_notation",
+            "split_notation",
+            "value",
+            "version",
+        ]
+
 
 class MacAddressOptional(MacAddress):
     value: str | None

infrahub/core/branch/models.py

@@ -295,6 +295,7 @@ class Branch(StandardNode):
         is_isolated: bool = True,
         branch_agnostic: bool = False,
         variable_name: str = "r",
+        params_prefix: str = "",
     ) -> tuple[str, dict]:
         """
         Generate a CYPHER Query filter based on a path to query a part of the graph at a specific time and on a specific branch.
@@ -306,30 +307,28 @@ class Branch(StandardNode):
 
             There is a currently an assumption that the relationship in the path will be named 'r'
         """
-
+        pp = params_prefix
         params: dict[str, Any] = {}
         at = Timestamp(at)
         at_str = at.to_string()
         if branch_agnostic:
-            filter_str = (
-                f"{variable_name}.from <= $time1 AND ({variable_name}.to IS NULL or {variable_name}.to >= $time1)"
-            )
-            params["time1"] = at_str
+            filter_str = f"{variable_name}.from <= ${pp}time1 AND ({variable_name}.to IS NULL or {variable_name}.to >= ${pp}time1)"
+            params[f"{pp}time1"] = at_str
             return filter_str, params
 
         branches_times = self.get_branches_and_times_to_query_global(at=at_str, is_isolated=is_isolated)
 
         for idx, (branch_name, time_to_query) in enumerate(branches_times.items()):
-            params[f"branch{idx}"] = list(branch_name)
-            params[f"time{idx}"] = time_to_query
+            params[f"{pp}branch{idx}"] = list(branch_name)
+            params[f"{pp}time{idx}"] = time_to_query
 
         filters = []
         for idx in range(len(branches_times)):
             filters.append(
-                f"({variable_name}.branch IN $branch{idx} AND {variable_name}.from <= $time{idx} AND {variable_name}.to IS NULL)"
+                f"({variable_name}.branch IN ${pp}branch{idx} AND {variable_name}.from <= ${pp}time{idx} AND {variable_name}.to IS NULL)"
             )
             filters.append(
-                f"({variable_name}.branch IN $branch{idx} AND {variable_name}.from <= $time{idx} AND {variable_name}.to >= $time{idx})"
+                f"({variable_name}.branch IN ${pp}branch{idx} AND {variable_name}.from <= ${pp}time{idx} AND {variable_name}.to >= ${pp}time{idx})"
             )
 
         filter_str = "(" + "\n OR ".join(filters) + ")"

infrahub/core/diff/calculator.py

@@ -7,6 +7,7 @@ from infrahub.core.diff.query_parser import DiffQueryParser
 from infrahub.core.query.diff import (
     DiffCalculationQuery,
     DiffFieldPathsQuery,
+    DiffMigratedKindNodesQuery,
     DiffNodePathsQuery,
     DiffPropertyPathsQuery,
 )
@@ -15,7 +16,7 @@ from infrahub.database import InfrahubDatabase
 from infrahub.log import get_logger
 
 from .model.field_specifiers_map import NodeFieldSpecifierMap
-from .model.path import CalculatedDiffs
+from .model.path import CalculatedDiffs, DiffNode, DiffRoot, NodeIdentifier
 
 log = get_logger()
 
@@ -59,7 +60,7 @@ class DiffCalculator:
             )
             log.info(f"Beginning one diff calculation query {limit=}, {offset=}")
             await diff_query.execute(db=self.db)
-            log.info("Diff calculation query complete")
+            log.info(f"Diff calculation query complete {limit=}, {offset=}")
             last_result = None
             for query_result in diff_query.get_results():
                 diff_parser.read_result(query_result=query_result)
@@ -69,6 +70,56 @@ class DiffCalculator:
                 has_more_data = last_result.get_as_type("has_more_data", bool)
             offset += limit
 
+    async def _apply_kind_migrated_nodes(
+        self, branch_diff: DiffRoot, calculation_request: DiffCalculationRequest
+    ) -> None:
+        has_more_data = True
+        offset = 0
+        limit = config.SETTINGS.database.query_size_limit
+        diff_nodes_by_identifier = {n.identifier: n for n in branch_diff.nodes}
+        diff_nodes_to_add: list[DiffNode] = []
+        while has_more_data:
+            diff_query = await DiffMigratedKindNodesQuery.init(
+                db=self.db,
+                branch=calculation_request.diff_branch,
+                base_branch=calculation_request.base_branch,
+                diff_branch_from_time=calculation_request.branch_from_time,
+                diff_from=calculation_request.from_time,
+                diff_to=calculation_request.to_time,
+                limit=limit,
+                offset=offset,
+            )
+            log.info(f"Getting one batch of migrated kind nodes {limit=}, {offset=}")
+            await diff_query.execute(db=self.db)
+            log.info(f"Migrated kind nodes query complete {limit=}, {offset=}")
+            last_result = None
+            for migrated_kind_node in diff_query.get_migrated_kind_nodes():
+                migrated_kind_identifier = NodeIdentifier(
+                    uuid=migrated_kind_node.uuid,
+                    kind=migrated_kind_node.kind,
+                    db_id=migrated_kind_node.db_id,
+                )
+                if migrated_kind_identifier in diff_nodes_by_identifier:
+                    diff_node = diff_nodes_by_identifier[migrated_kind_identifier]
+                    diff_node.is_node_kind_migration = True
+                    continue
+                new_diff_node = DiffNode(
+                    identifier=migrated_kind_identifier,
+                    changed_at=migrated_kind_node.from_time,
+                    action=migrated_kind_node.action,
+                    is_node_kind_migration=True,
+                    attributes=[],
+                    relationships=[],
+                )
+                diff_nodes_by_identifier[migrated_kind_identifier] = new_diff_node
+                diff_nodes_to_add.append(new_diff_node)
+                last_result = migrated_kind_node
+            has_more_data = False
+            if last_result:
+                has_more_data = last_result.has_more_data
+            offset += limit
+        branch_diff.nodes.extend(diff_nodes_to_add)
+
     async def calculate_diff(
         self,
         base_branch: Branch,
@@ -92,7 +143,7 @@ class DiffCalculator:
         )
         node_limit = int(config.SETTINGS.database.query_size_limit / 10)
         fields_limit = int(config.SETTINGS.database.query_size_limit / 3)
-        properties_limit = int(config.SETTINGS.database.query_size_limit)
+        properties_limit = config.SETTINGS.database.query_size_limit
 
         calculation_request = DiffCalculationRequest(
             base_branch=base_branch,
@@ -132,7 +183,7 @@ class DiffCalculator:
         if base_branch.name != diff_branch.name:
             current_node_field_specifiers = diff_parser.get_current_node_field_specifiers()
             new_node_field_specifiers = diff_parser.get_new_node_field_specifiers()
-            calculation_request = DiffCalculationRequest(
+            base_calculation_request = DiffCalculationRequest(
                 base_branch=base_branch,
                 diff_branch=base_branch,
                 branch_from_time=diff_branch_from_time,
@@ -146,7 +197,7 @@ class DiffCalculator:
             await self._run_diff_calculation_query(
                 diff_parser=diff_parser,
                 query_class=DiffNodePathsQuery,
-                calculation_request=calculation_request,
+                calculation_request=base_calculation_request,
                 limit=node_limit,
             )
             log.info("Diff node-level calculation queries for base complete")
@@ -155,7 +206,7 @@ class DiffCalculator:
             await self._run_diff_calculation_query(
                 diff_parser=diff_parser,
                 query_class=DiffFieldPathsQuery,
-                calculation_request=calculation_request,
+                calculation_request=base_calculation_request,
                 limit=fields_limit,
             )
             log.info("Diff field-level calculation queries for base complete")
@@ -164,7 +215,7 @@ class DiffCalculator:
             await self._run_diff_calculation_query(
                 diff_parser=diff_parser,
                 query_class=DiffPropertyPathsQuery,
-                calculation_request=calculation_request,
+                calculation_request=base_calculation_request,
                 limit=properties_limit,
             )
             log.info("Diff property-level calculation queries for base complete")
@@ -172,9 +223,11 @@ class DiffCalculator:
         log.info("Parsing calculated diff")
         diff_parser.parse(include_unchanged=include_unchanged)
         log.info("Calculated diff parsed")
+        branch_diff = diff_parser.get_diff_root_for_branch(branch=diff_branch.name)
+        await self._apply_kind_migrated_nodes(branch_diff=branch_diff, calculation_request=calculation_request)
         return CalculatedDiffs(
             base_branch_name=base_branch.name,
             diff_branch_name=diff_branch.name,
             base_branch_diff=diff_parser.get_diff_root_for_branch(branch=base_branch.name),
-            diff_branch_diff=diff_parser.get_diff_root_for_branch(branch=diff_branch.name),
+            diff_branch_diff=branch_diff,
         )

infrahub/core/diff/combiner.py

@@ -14,6 +14,7 @@ from .model.path import (
     EnrichedDiffRoot,
     EnrichedDiffs,
     EnrichedDiffSingleRelationship,
+    NodeIdentifier,
 )
 
 
@@ -26,30 +27,35 @@ class NodePair:
 class DiffCombiner:
     def __init__(self) -> None:
         # {child_uuid: (parent_uuid, parent_rel_name)}
-        self._child_parent_uuid_map: dict[str, tuple[str, str]] = {}
-        self._parent_node_uuids: set[str] = set()
-        self._earlier_nodes_by_uuid: dict[str, EnrichedDiffNode] = {}
-        self._later_nodes_by_uuid: dict[str, EnrichedDiffNode] = {}
-        self._common_node_uuids: set[str] = set()
+        self._child_parent_identifier_map: dict[NodeIdentifier, tuple[NodeIdentifier, str]] = {}
+        self._parent_node_identifiers: set[NodeIdentifier] = set()
+        self._earlier_nodes_by_identifier: dict[NodeIdentifier, EnrichedDiffNode] = {}
+        self._later_nodes_by_identifier: dict[NodeIdentifier, EnrichedDiffNode] = {}
+        self._common_node_identifiers: set[NodeIdentifier] = set()
         self._diff_branch_name: str | None = None
 
     def _initialize(self, earlier_diff: EnrichedDiffRoot, later_diff: EnrichedDiffRoot) -> None:
         self._diff_branch_name = earlier_diff.diff_branch_name
-        self._child_parent_uuid_map = {}
-        self._earlier_nodes_by_uuid = {}
-        self._later_nodes_by_uuid = {}
-        self._common_node_uuids = set()
+        self._child_parent_identifier_map = {}
+        self._earlier_nodes_by_identifier = {}
+        self._later_nodes_by_identifier = {}
+        self._common_node_identifiers = set()
         # map the parent of each node (if it exists), preference to the later diff
         for diff_root in (earlier_diff, later_diff):
             for child_node in diff_root.nodes:
                 for parent_rel in child_node.relationships:
                     for parent_node in parent_rel.nodes:
-                        self._child_parent_uuid_map[child_node.uuid] = (parent_node.uuid, parent_rel.name)
+                        self._child_parent_identifier_map[child_node.identifier] = (
+                            parent_node.identifier,
+                            parent_rel.name,
+                        )
         # UUIDs of all the parents, removing the stale parents from the earlier diff
-        self._parent_node_uuids = {parent_tuple[0] for parent_tuple in self._child_parent_uuid_map.values()}
-        self._earlier_nodes_by_uuid = {n.uuid: n for n in earlier_diff.nodes}
-        self._later_nodes_by_uuid = {n.uuid: n for n in later_diff.nodes}
-        self._common_node_uuids = set(self._earlier_nodes_by_uuid.keys()) & set(self._later_nodes_by_uuid.keys())
+        self._parent_node_identifiers = {parent_tuple[0] for parent_tuple in self._child_parent_identifier_map.values()}
+        self._earlier_nodes_by_identifier = {n.identifier: n for n in earlier_diff.nodes}
+        self._later_nodes_by_identifier = {n.identifier: n for n in later_diff.nodes}
+        self._common_node_identifiers = set(self._earlier_nodes_by_identifier.keys()) & set(
+            self._later_nodes_by_identifier.keys()
+        )
 
     @property
     def diff_branch_name(self) -> str:
@@ -61,13 +67,13 @@ class DiffCombiner:
         filtered_node_pairs: list[NodePair] = []
         for earlier_node in earlier_diff.nodes:
             later_node: EnrichedDiffNode | None = None
-            if earlier_node.uuid in self._common_node_uuids:
-                later_node = self._later_nodes_by_uuid[earlier_node.uuid]
+            if earlier_node.identifier in self._common_node_identifiers:
+                later_node = self._later_nodes_by_identifier[earlier_node.identifier]
             # this is an out-of-date parent
             if (
                 earlier_node.action is DiffAction.UNCHANGED
                 and (later_node is None or later_node.action is DiffAction.UNCHANGED)
-                and earlier_node.uuid not in self._parent_node_uuids
+                and earlier_node.identifier not in self._parent_node_identifiers
             ):
                 continue
             if later_node is None:
@@ -79,15 +85,15 @@ class DiffCombiner:
             filtered_node_pairs.append(NodePair(earlier=earlier_node, later=later_node))
         for later_node in later_diff.nodes:
             # these have already been handled
-            if later_node.uuid in self._common_node_uuids:
+            if later_node.identifier in self._common_node_identifiers:
                 continue
             filtered_node_pairs.append(NodePair(later=later_node))
         return filtered_node_pairs
 
-    def _get_parent_relationship_name(self, node_id: str) -> str | None:
-        if node_id not in self._child_parent_uuid_map:
+    def _get_parent_relationship_name(self, node_id: NodeIdentifier) -> str | None:
+        if node_id not in self._child_parent_identifier_map:
             return None
-        return self._child_parent_uuid_map[node_id][1]
+        return self._child_parent_identifier_map[node_id][1]
 
     def _should_include(self, earlier: DiffAction, later: DiffAction) -> bool:
         actions = {earlier, later}
@@ -284,7 +290,7 @@ class DiffCombiner:
         self,
         earlier_relationships: set[EnrichedDiffRelationship],
         later_relationships: set[EnrichedDiffRelationship],
-        node_id: str,
+        node_id: NodeIdentifier,
     ) -> set[EnrichedDiffRelationship]:
         earlier_rels_by_name = {rel.name: rel for rel in earlier_relationships}
         later_rels_by_name = {rel.name: rel for rel in later_relationships}
@@ -365,7 +371,7 @@ class DiffCombiner:
             combined_relationships = self._combine_relationships(
                 earlier_relationships=node_pair.earlier.relationships,
                 later_relationships=node_pair.later.relationships,
-                node_id=node_pair.later.uuid,
+                node_id=node_pair.later.identifier,
             )
             if all(ca.action is DiffAction.UNCHANGED for ca in combined_attributes) and all(
                 cr.action is DiffAction.UNCHANGED for cr in combined_relationships
@@ -380,7 +386,7 @@ class DiffCombiner:
                 combined_attributes
                 or combined_relationships
                 or combined_conflict
-                or node_pair.later.uuid in self._parent_node_uuids
+                or node_pair.later.identifier in self._parent_node_identifiers
             ):
                 combined_nodes.add(
                     EnrichedDiffNode(
@@ -388,6 +394,8 @@ class DiffCombiner:
                         label=node_pair.later.label,
                         changed_at=node_pair.later.changed_at or node_pair.earlier.changed_at,
                         action=combined_action,
+                        is_node_kind_migration=node_pair.earlier.is_node_kind_migration
+                        or node_pair.later.is_node_kind_migration,
                         path_identifier=node_pair.later.path_identifier,
                         attributes=combined_attributes,
                         relationships=combined_relationships,
@@ -397,12 +405,12 @@ class DiffCombiner:
         return combined_nodes
 
     def _link_child_nodes(self, nodes: Iterable[EnrichedDiffNode]) -> None:
-        nodes_by_uuid: dict[str, EnrichedDiffNode] = {n.uuid: n for n in nodes}
-        for child_node in nodes_by_uuid.values():
-            if child_node.uuid not in self._child_parent_uuid_map:
+        nodes_by_identifier: dict[NodeIdentifier, EnrichedDiffNode] = {n.identifier: n for n in nodes}
+        for child_node in nodes_by_identifier.values():
+            if child_node.identifier not in self._child_parent_identifier_map:
                 continue
-            parent_uuid, parent_rel_name = self._child_parent_uuid_map[child_node.uuid]
-            parent_node = nodes_by_uuid[parent_uuid]
+            parent_identifier, parent_rel_name = self._child_parent_identifier_map[child_node.identifier]
+            parent_node = nodes_by_identifier[parent_identifier]
             parent_rel = child_node.get_relationship(name=parent_rel_name)
             parent_rel.nodes.add(parent_node)
 

infrahub/core/diff/enricher/hierarchy.py

@@ -99,7 +99,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
                 current_node = node
                 for ancestor in ancestors:
-                    ancestor_identifier = NodeIdentifier(uuid=ancestor.uuid, kind=ancestor.kind, labels=ancestor.labels)
+                    ancestor_identifier = NodeIdentifier(uuid=ancestor.uuid, kind=ancestor.kind, db_id=ancestor.db_id)
                     parent_request = ParentNodeAddRequest(
                         node_identifier=current_node.identifier,
                         parent_identifier=ancestor_identifier,
@@ -146,13 +146,11 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
             for peer in query.get_peers():
                 source_identifier = NodeIdentifier(
-                    uuid=str(peer.source_id), kind=peer.source_kind, labels=peer.source_labels
+                    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:
-                    peer_identifier = NodeIdentifier(
-                        uuid=str(peer.peer_id), kind=peer.peer_kind, labels=peer.peer_labels
-                    )
+                    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
@@ -170,7 +168,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
             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
+                uuid=str(peer_parent.peer_id), kind=peer_parent.peer_kind, db_id=peer_parent.peer_db_id
             )
             parent_request = ParentNodeAddRequest(
                 node_identifier=node.identifier,

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,6 +59,16 @@ 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):
             if node_diff_dicts:
                 log.info(f"Merging batch of nodes #{batch_num}")
@@ -62,6 +78,7 @@ class DiffMerger:
                     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:
@@ -72,10 +89,21 @@ class DiffMerger:
                     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,
+                migrated_uuids=list(migrated_kind_uuids),
+            )
+            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: