infrahub-server 1.2.9rc0__py3-none-any.whl → 1.2.11__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,26 +306,33 @@ async def computed_attribute_setup_jinja2(
 
         triggers = await gather_trigger_computed_attribute_jinja2()
 
-        for trigger in triggers:
-            if event_name != BranchDeletedEvent.event_name and trigger.branch == branch_name:
-                await service.workflow.submit_workflow(
-                    workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
-                    context=context,
-                    parameters={
-                        "branch_name": trigger.branch,
-                        "computed_attribute_name": trigger.computed_attribute.attribute.name,
-                        "computed_attribute_kind": trigger.computed_attribute.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")
 
 
@@ -347,18 +358,29 @@ async def computed_attribute_setup_python(
 
         triggers_python, triggers_python_query = await gather_trigger_computed_attribute_python(db=db)
 
-        for trigger in triggers_python:
-            if event_name != BranchDeletedEvent.event_name and trigger.branch == branch_name:
-                log.info(
-                    f"Triggering update for {trigger.computed_attribute.computed_attribute.attribute.name} on {branch_name}"
-                )
+        # 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.computed_attribute.kind,
+                trigger.computed_attribute.computed_attribute.attribute.name,
+            )
+            for trigger in triggers_python
+        }
+        for branch, kind, attribute_name in unique_nodes:
+            if event_name != BranchDeletedEvent.event_name and branch == branch_name:
+                log.info(f"Triggering update for {kind}.{attribute_name} on {branch}")
                 await service.workflow.submit_workflow(
                     workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
                     context=context,
                     parameters={
                         "branch_name": branch_name,
-                        "computed_attribute_name": trigger.computed_attribute.computed_attribute.attribute.name,
-                        "computed_attribute_kind": trigger.computed_attribute.computed_attribute.kind,
+                        "computed_attribute_name": attribute_name,
+                        "computed_attribute_kind": kind,
                     },
                 )
 

infrahub/config.py

@@ -269,6 +269,7 @@ class DatabaseSettings(BaseSettings):
     address: str = "localhost"
     port: int = 7687
     database: str | None = Field(default=None, pattern=VALID_DATABASE_NAME_REGEX, description="Name of the database")
+    policy: str | None = Field(default=None, description="Routing policy for database connections")
     tls_enabled: bool = Field(default=False, description="Indicates if TLS is enabled for the connection")
     tls_insecure: bool = Field(default=False, description="Indicates if TLS certificates are verified")
     tls_ca_file: str | None = Field(default=None, description="File path to CA cert or bundle in PEM format")
@@ -293,6 +294,14 @@ class DatabaseSettings(BaseSettings):
         default=0.01, ge=0, description="Delay to add when max_concurrent_queries is reached."
     )
 
+    @property
+    def database_uri(self) -> str:
+        """Constructs the database URI based on the configuration settings."""
+        base_uri = f"{self.protocol}://{self.address}:{self.port}"
+        if self.policy is not None:
+            return f"{base_uri}?policy={self.policy}"
+        return base_uri
+
     @property
     def database_name(self) -> str:
         return self.database or self.db_type.value

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/branch/tasks.py

@@ -212,8 +212,6 @@ async def merge_branch(
 
         merger: BranchMerger | None = None
         async with lock.registry.global_graph_lock():
-            # await update_diff(model=RequestDiffUpdate(branch_name=obj.name))
-
             diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
             diff_coordinator = await component_registry.get_component(DiffCoordinator, db=db, branch=obj)
             diff_merger = await component_registry.get_component(DiffMerger, db=db, branch=obj)

infrahub/core/constants/infrahubkind.py

@@ -70,3 +70,4 @@ TRANSFORMPYTHON = "CoreTransformPython"
 USERVALIDATOR = "CoreUserValidator"
 VALIDATOR = "CoreValidator"
 WEBHOOK = "CoreWebhook"
+WEIGHTED_POOL_RESOURCE = "CoreWeightedPoolResource"

infrahub/core/constraint/node/runner.py

@@ -26,7 +26,7 @@ class NodeConstraintRunner:
     async def check(
         self, node: Node, field_filters: list[str] | None = None, skip_uniqueness_check: bool = False
     ) -> None:
-        async with self.db.start_session() as db:
+        async with self.db.start_session(read_only=False) as db:
             await node.resolve_relationships(db=db)
 
             if not skip_uniqueness_check:

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,
 )
@@ -14,7 +15,8 @@ from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.log import get_logger
 
-from .model.path import CalculatedDiffs
+from .model.field_specifiers_map import NodeFieldSpecifierMap
+from .model.path import CalculatedDiffs, DiffNode, DiffRoot, NodeIdentifier
 
 log = get_logger()
 
@@ -26,8 +28,8 @@ class DiffCalculationRequest:
     branch_from_time: Timestamp
     from_time: Timestamp
     to_time: Timestamp
-    current_node_field_specifiers: dict[str, set[str]] | None = field(default=None)
-    new_node_field_specifiers: dict[str, set[str]] | None = field(default=None)
+    current_node_field_specifiers: NodeFieldSpecifierMap | None = field(default=None)
+    new_node_field_specifiers: NodeFieldSpecifierMap | None = field(default=None)
 
 
 class DiffCalculator:
@@ -58,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)
@@ -68,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,
@@ -75,7 +127,7 @@ class DiffCalculator:
         from_time: Timestamp,
         to_time: Timestamp,
         include_unchanged: bool = True,
-        previous_node_specifiers: dict[str, set[str]] | None = None,
+        previous_node_specifiers: NodeFieldSpecifierMap | None = None,
     ) -> CalculatedDiffs:
         if diff_branch.name == registry.default_branch:
             diff_branch_from_time = from_time
@@ -91,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,
@@ -131,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,
@@ -145,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")
@@ -154,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")
@@ -163,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")
@@ -171,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,15 +386,16 @@ 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(
-                        uuid=node_pair.later.uuid,
-                        kind=node_pair.later.kind,
+                        identifier=node_pair.later.identifier,
                         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,
@@ -398,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)