infrahub-server 1.2.9rc0__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/diff/query/save.py

@@ -30,8 +30,7 @@ class EnrichedDiffRootsUpsertQuery(Query):
         query = """
 UNWIND $diff_root_list AS diff_root_map
 WITH diff_root_map
-CALL {
-    WITH diff_root_map
+CALL (diff_root_map) {
     MERGE (diff_root:DiffRoot {uuid: diff_root_map.uuid})
     SET diff_root.base_branch = diff_root_map.base_branch
     SET diff_root.diff_branch = diff_root_map.diff_branch
@@ -43,8 +42,7 @@ CALL {
 WITH DISTINCT diff_root AS diff_root
 WITH collect(diff_root) AS diff_roots
 WHERE SIZE(diff_roots) = 2
-CALL {
-    WITH diff_roots
+CALL (diff_roots) {
     WITH diff_roots[0] AS base_diff_node, diff_roots[1] AS branch_diff_node
     MERGE (base_diff_node)-[:DIFF_HAS_PARTNER]-(branch_diff_node)
     SET (base_diff_node).partner_uuid = (branch_diff_node).uuid
@@ -85,18 +83,20 @@ UNWIND $node_details_list AS node_details
 WITH
     node_details.root_uuid AS root_uuid,
     node_details.node_map AS node_map,
-    toString(node_details.node_map.node_properties.uuid) AS node_uuid
+    toString(node_details.node_map.node_properties.uuid) AS node_uuid,
+    node_details.node_map.node_properties.db_id AS node_db_id
 MERGE (diff_root:DiffRoot {uuid: root_uuid})
-MERGE (diff_root)-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_uuid})
+MERGE (diff_root)-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_uuid, db_id: node_db_id})
 WITH root_uuid, node_map, diff_node, (node_map.conflict_params IS NOT NULL) AS has_node_conflict
 SET
     diff_node.kind = node_map.node_properties.kind,
     diff_node.label = node_map.node_properties.label,
     diff_node.changed_at = node_map.node_properties.changed_at,
     diff_node.action = node_map.node_properties.action,
+    diff_node.is_node_kind_migration = node_map.node_properties.is_node_kind_migration,
     diff_node.path_identifier = node_map.node_properties.path_identifier
 WITH root_uuid, node_map, diff_node, has_node_conflict
-CALL {
+CALL (diff_node) {
     // -------------------------
     // delete parent-child relationships for included nodes, they will be added in EnrichedNodesLinkQuery
     // -------------------------
@@ -105,43 +105,38 @@ CALL {
     DELETE parent_rel
 }
 OPTIONAL MATCH (diff_node)-[:DIFF_HAS_CONFLICT]->(current_node_conflict:DiffConflict)
-CALL {
+CALL (diff_node, current_node_conflict, has_node_conflict) {
     // -------------------------
     // create a node-level conflict, if necessary
     // -------------------------
     WITH diff_node, current_node_conflict, has_node_conflict
-    WITH diff_node, current_node_conflict, has_node_conflict
     WHERE current_node_conflict IS NULL AND has_node_conflict = TRUE
     CREATE (diff_node)-[:DIFF_HAS_CONFLICT]->(:DiffConflict)
 }
-CALL {
+CALL (current_node_conflict, has_node_conflict) {
     // -------------------------
     // delete a node-level conflict, if necessary
     // -------------------------
     WITH current_node_conflict, has_node_conflict
-    WITH current_node_conflict, has_node_conflict
     WHERE current_node_conflict IS NOT NULL AND has_node_conflict = FALSE
     DETACH DELETE current_node_conflict
 }
 WITH root_uuid, node_map, diff_node, has_node_conflict, node_map.conflict_params AS node_conflict_params
-CALL {
+CALL (diff_node, has_node_conflict, node_conflict_params) {
     // -------------------------
     // set the properties of the node-level conflict, if necessary
     // -------------------------
     WITH diff_node, has_node_conflict, node_conflict_params
-    WITH diff_node, has_node_conflict, node_conflict_params
     WHERE has_node_conflict = TRUE
     OPTIONAL MATCH (diff_node)-[:DIFF_HAS_CONFLICT]->(node_conflict:DiffConflict)
     SET node_conflict = node_conflict_params
 }
-CALL {
+CALL (diff_node, node_map) {
     // -------------------------
     // remove stale attributes for this node
     // -------------------------
-    WITH diff_node, node_map
-    CALL {
-        WITH diff_node, node_map
-        WITH diff_node, %(attr_name_list_comp)s AS attr_names
+    CALL (diff_node, node_map) {
+        WITH %(attr_name_list_comp)s AS attr_names
         OPTIONAL MATCH (diff_node)-[:DIFF_HAS_ATTRIBUTE]->(attr_to_delete:DiffAttribute)
         WHERE NOT (attr_to_delete.name IN attr_names)
         OPTIONAL MATCH (attr_to_delete)-[*..6]->(next_to_delete)
@@ -161,9 +156,8 @@ CALL {
     // -------------------------
     // remove stale properties for this attribute
     // -------------------------
-    CALL {
-        WITH diff_attribute, node_attribute
-        WITH diff_attribute, %(attr_props_list_comp)s AS prop_types
+    CALL (diff_attribute, node_attribute) {
+        WITH %(attr_props_list_comp)s AS prop_types
         OPTIONAL MATCH (diff_attribute)-[:DIFF_HAS_PROPERTY]->(prop_to_delete:DiffProperty)
         WHERE NOT (prop_to_delete.property_type IN prop_types)
         OPTIONAL MATCH (prop_to_delete)-[*..4]->(next_to_delete)
@@ -190,9 +184,8 @@ CALL {
 // -------------------------
 // remove stale relationships for this node
 // -------------------------
-CALL {
-    WITH diff_node, node_map
-    WITH diff_node, %(rel_name_list_comp)s AS rel_names
+CALL (diff_node, node_map) {
+    WITH %(rel_name_list_comp)s AS rel_names
     OPTIONAL MATCH (diff_node)-[:DIFF_HAS_RELATIONSHIP]->(rel_to_delete:DiffRelationship)
     WHERE NOT (rel_to_delete.name IN rel_names)
     OPTIONAL MATCH (rel_to_delete)-[*..8]->(next_to_delete)
@@ -210,9 +203,8 @@ SET diff_relationship = node_relationship.node_properties
 // remove stale elements for this relationship group
 // -------------------------
 WITH diff_relationship, node_relationship
-CALL {
-    WITH diff_relationship, node_relationship
-    WITH diff_relationship, %(rel_peers_list_comp)s AS rel_peers
+CALL (diff_relationship, node_relationship) {
+    WITH %(rel_peers_list_comp)s AS rel_peers
     OPTIONAL MATCH (diff_relationship)-[:DIFF_HAS_ELEMENT]->(element_to_delete:DiffRelationshipElement)
     WHERE NOT (element_to_delete.peer_id IN rel_peers)
     OPTIONAL MATCH (element_to_delete)-[*..6]->(next_to_delete)
@@ -245,9 +237,8 @@ FOREACH (i in CASE WHEN has_element_conflict = TRUE THEN [1] ELSE [] END |
 // remove stale properties for this relationship element
 // -------------------------
 WITH diff_relationship_element, node_single_relationship
-CALL {
-    WITH diff_relationship_element, node_single_relationship
-    WITH diff_relationship_element, %(element_props_list_comp)s AS element_props
+CALL (diff_relationship_element, node_single_relationship) {
+    WITH %(element_props_list_comp)s AS element_props
     OPTIONAL MATCH (diff_relationship_element)-[:DIFF_HAS_PROPERTY]->(property_to_delete:DiffProperty)
     WHERE NOT (property_to_delete.property_type IN element_props)
     OPTIONAL MATCH (property_to_delete)-[*..4]->(next_to_delete)
@@ -401,6 +392,8 @@ FOREACH (i in CASE WHEN has_property_conflict = TRUE THEN [1] ELSE [] END |
             "node_properties": {
                 "uuid": enriched_node.uuid,
                 "kind": enriched_node.kind,
+                "db_id": enriched_node.identifier.db_id,
+                "is_node_kind_migration": enriched_node.is_node_kind_migration,
                 "label": enriched_node.label,
                 "changed_at": enriched_node.changed_at.to_string() if enriched_node.changed_at else None,
                 "action": enriched_node.action.value,
@@ -447,10 +440,9 @@ WITH keys($parent_node_map) AS child_node_uuids
 MATCH (diff_root:DiffRoot {uuid: $root_uuid})
 MATCH (diff_root)-[:DIFF_HAS_NODE]->(child_node:DiffNode)
 WHERE child_node.uuid IN child_node_uuids
-CALL {
-    WITH diff_root, child_node
-    WITH diff_root, child_node, $parent_node_map[child_node.uuid] AS sub_map
-    WITH diff_root, child_node, sub_map, keys(sub_map) AS relationship_names
+CALL (diff_root, child_node) {
+    WITH $parent_node_map[child_node.uuid] AS sub_map
+    WITH sub_map, keys(sub_map) AS relationship_names
     MATCH (child_node)-[:DIFF_HAS_RELATIONSHIP]->(diff_rel_group:DiffRelationship)
     WHERE diff_rel_group.name IN relationship_names
     WITH diff_root, diff_rel_group, toString(sub_map[diff_rel_group.name]) AS parent_uuid

infrahub/core/diff/query/summary_counts_enricher.py

@@ -46,70 +46,59 @@ WHERE ($diff_id IS NOT NULL AND root.uuid = $diff_id)
 OR ($tracking_id IS NOT NULL AND root.tracking_id = $tracking_id AND root.diff_branch = $diff_branch_name)
 MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode)
 WHERE $node_uuids IS NULL OR dn.uuid IN $node_uuids
-CALL {
+CALL (dn) {
     // ----------------------
     // handle attribute count updates
     // ----------------------
-    WITH dn
     MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute)
-    CALL {
-        WITH da
+    CALL (da) {
         OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty)-[:DIFF_HAS_CONFLICT]->(dc:DiffConflict)
-        WITH da, count(dc) AS num_conflicts
+        WITH count(dc) AS num_conflicts
         SET da.num_conflicts = num_conflicts
         SET da.contains_conflict = (num_conflicts > 0)
     }
-    CALL {
-        WITH da
+    CALL (da) {
         OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "added"})
-        WITH da, count(dp.action) AS num_added
+        WITH count(dp.action) AS num_added
         SET da.num_added = num_added
     }
-    CALL {
-        WITH da
+    CALL (da) {
         OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "updated"})
-        WITH da, count(dp.action) AS num_updated
+        WITH count(dp.action) AS num_updated
         SET da.num_updated = num_updated
     }
-    CALL {
-        WITH da
+    CALL (da) {
         OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "removed"})
-        WITH da, count(dp.action) AS num_removed
+        WITH count(dp.action) AS num_removed
         SET da.num_removed = num_removed
     }
 }
-CALL {
-    WITH dn
+CALL (dn) {
     MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
-    CALL {
+    CALL (dr) {
         // ----------------------
         // handle relationship element count updates
         // ----------------------
-        WITH dr
         MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement)
-        CALL {
-            WITH dre
+        CALL (dre) {
             OPTIONAL MATCH (dre)-[*..4]->(dc:DiffConflict)
-            WITH dre, count(dc) AS num_conflicts
+            WITH count(dc) AS num_conflicts
             SET dre.num_conflicts = num_conflicts
             SET dre.contains_conflict = (num_conflicts > 0)
         }
-        CALL {
-            WITH dre
+        CALL (dre) {
             OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "added"})
-            WITH dre, count(dp.action) AS num_added
+            WITH count(dp.action) AS num_added
             SET dre.num_added = num_added
         }
-        CALL {
-            WITH dre
+        CALL (dre) {
             OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "updated"})
-            WITH dre, count(dp.action) AS num_updated
+            WITH count(dp.action) AS num_updated
             SET dre.num_updated = num_updated
         }
-        CALL {
-            WITH dre
+        CALL (dre) {
             OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "removed"})
-            WITH dre, count(dp.action) AS num_removed
+            WITH count(dp.action) AS num_removed
             SET dre.num_removed = num_removed
         }
     }
@@ -121,22 +110,19 @@ CALL {
     SET dr.num_conflicts = num_conflicts
     SET dr.contains_conflict = (num_conflicts > 0)
     WITH dr
-    CALL {
-        WITH dr
+    CALL (dr) {
         OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "added"})
-        WITH dr, count(dre.action) AS num_added
+        WITH count(dre.action) AS num_added
         SET dr.num_added = num_added
     }
-    CALL {
-        WITH dr
+    CALL (dr) {
         OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "updated"})
-        WITH dr, count(dre.action) AS num_updated
+        WITH count(dre.action) AS num_updated
         SET dr.num_updated = num_updated
     }
-    CALL {
-        WITH dr
+    CALL (dr) {
         OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "removed"})
-        WITH dr, count(dre.action) AS num_removed
+        WITH count(dre.action) AS num_removed
         SET dr.num_removed = num_removed
     }
 }
@@ -189,19 +175,16 @@ WHERE $node_uuids IS NULL OR dn.uuid IN $node_uuids
 // handle node count updates
 // ----------------------
 WITH root, dn, coalesce(dn.num_conflicts, 0) AS previous_num_conflicts
-CALL {
+CALL (dn) {
     // ----------------------
     // handle node num_conflicts update
     // ----------------------
-    WITH dn
     OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute {contains_conflict: TRUE})
     RETURN sum(da.num_conflicts) AS num_conflicts
     UNION ALL
-    WITH dn
     OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship {contains_conflict: TRUE})
     RETURN sum(dr.num_conflicts) AS num_conflicts
     UNION ALL
-    WITH dn
     OPTIONAL MATCH (dn)-[:DIFF_HAS_CONFLICT]->(dc:DiffConflict)
     RETURN count(dc) AS num_conflicts
 }
@@ -209,17 +192,16 @@ WITH root, dn, previous_num_conflicts, sum(num_conflicts) AS updated_num_conflic
 SET dn.num_conflicts = updated_num_conflicts
 SET dn.contains_conflict = (updated_num_conflicts > 0)
 WITH root, dn, updated_num_conflicts - previous_num_conflicts AS num_conflicts_delta
-CALL {
+CALL (dn) {
     // ----------------------
     // handle node added/updated/removed updates
     // ----------------------
-    WITH dn
     OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute)
-    WITH dn, collect(da.action) AS attr_actions
+    WITH collect(da.action) AS attr_actions
     OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
-    WITH dn, attr_actions, collect(dr.action) AS rel_actions
-    WITH dn, attr_actions + rel_actions AS actions
-    WITH dn, reduce(counts = [0,0,0], a IN actions |
+    WITH attr_actions, collect(dr.action) AS rel_actions
+    WITH attr_actions + rel_actions AS actions
+    WITH reduce(counts = [0,0,0], a IN actions |
         CASE
             WHEN a = "added" THEN [counts[0] + 1, counts[1], counts[2]]
             WHEN a = "updated" THEN [counts[0], counts[1] + 1, counts[2]]
@@ -227,7 +209,7 @@ CALL {
             ELSE counts
         END
     ) AS action_counts
-    WITH dn, action_counts[0] AS num_added, action_counts[1] AS num_updated, action_counts[2] AS num_removed
+    WITH action_counts[0] AS num_added, action_counts[1] AS num_updated, action_counts[2] AS num_removed
     SET dn.num_added = num_added
     SET dn.num_updated = num_updated
     SET dn.num_removed = num_removed
@@ -236,8 +218,7 @@ CALL {
 // handle conflict updates for parent nodes
 // ----------------------
 WITH root, dn, num_conflicts_delta
-CALL {
-    WITH dn, num_conflicts_delta
+CALL (dn, num_conflicts_delta) {
     OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP|DIFF_HAS_NODE*1..]->(parent_node:DiffNode)
     SET parent_node.num_conflicts = parent_node.num_conflicts + num_conflicts_delta
     SET parent_node.contains_conflict = (parent_node.num_conflicts > 0)
@@ -246,8 +227,7 @@ CALL {
 // handle root count updates
 // ----------------------
 WITH root, sum(num_conflicts_delta) AS total_conflicts_delta
-CALL {
-    WITH root, total_conflicts_delta
+CALL (root, total_conflicts_delta) {
     SET root.num_conflicts = coalesce(root.num_conflicts, 0) + total_conflicts_delta
     SET root.contains_conflict = root.num_conflicts > 0
     WITH root

infrahub/core/diff/query_parser.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections import defaultdict
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from uuid import uuid4
@@ -15,6 +14,7 @@ from infrahub.core.constants import (
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.timestamp import Timestamp
 
+from .model.field_specifiers_map import NodeFieldSpecifierMap
 from .model.path import (
     DatabasePath,
     DiffAttribute,
@@ -23,6 +23,7 @@ from .model.path import (
     DiffRelationship,
     DiffRoot,
     DiffSingleRelationship,
+    NodeIdentifier,
 )
 
 if TYPE_CHECKING:
@@ -394,8 +395,7 @@ class DiffRelationshipIntermediate:
 @dataclass
 class DiffNodeIntermediate(TrackedStatusUpdates):
     force_action: DiffAction | None
-    uuid: str
-    kind: str
+    identifier: NodeIdentifier
     db_id: str
     from_time: Timestamp
     status: RelationshipStatus
@@ -403,6 +403,14 @@ class DiffNodeIntermediate(TrackedStatusUpdates):
     # {(name, identifier): DiffRelationshipIntermediate}
     relationships_by_identifier: dict[tuple[str, str], DiffRelationshipIntermediate] = field(default_factory=dict)
 
+    @property
+    def uuid(self) -> str:
+        return self.identifier.uuid
+
+    @property
+    def kind(self) -> str:
+        return self.identifier.kind
+
     def to_diff_node(self, from_time: Timestamp, include_unchanged: bool) -> DiffNode:
         attributes = []
         for attr in self.attributes_by_name.values():
@@ -424,8 +432,7 @@ class DiffNodeIntermediate(TrackedStatusUpdates):
         if self.force_action:
             action = self.force_action
         return DiffNode(
-            uuid=self.uuid,
-            kind=self.kind,
+            identifier=self.identifier,
             changed_at=changed_at,
             action=action,
             attributes=attributes,
@@ -441,11 +448,11 @@ class DiffNodeIntermediate(TrackedStatusUpdates):
 class DiffRootIntermediate:
     uuid: str
     branch: str
-    nodes_by_id: dict[str, DiffNodeIntermediate] = field(default_factory=dict)
+    nodes_by_identifier: dict[NodeIdentifier, DiffNodeIntermediate] = field(default_factory=dict)
 
     def to_diff_root(self, from_time: Timestamp, to_time: Timestamp, include_unchanged: bool) -> DiffRoot:
         nodes = []
-        for node in self.nodes_by_id.values():
+        for node in self.nodes_by_identifier.values():
             if node.is_empty:
                 continue
             diff_node = node.to_diff_node(from_time=from_time, include_unchanged=include_unchanged)
@@ -462,7 +469,7 @@ class DiffQueryParser:
         schema_manager: SchemaManager,
         from_time: Timestamp,
         to_time: Timestamp | None = None,
-        previous_node_field_specifiers: dict[str, set[str]] | None = None,
+        previous_node_field_specifiers: NodeFieldSpecifierMap | None = None,
     ) -> None:
         self.base_branch_name = base_branch.name
         self.diff_branch_name = diff_branch.name
@@ -476,9 +483,9 @@ class DiffQueryParser:
             self.diff_branched_from_time = Timestamp(diff_branch.get_branched_from())
         self._diff_root_by_branch: dict[str, DiffRootIntermediate] = {}
         self._final_diff_root_by_branch: dict[str, DiffRoot] = {}
-        self._previous_node_field_specifiers = previous_node_field_specifiers or {}
-        self._new_node_field_specifiers: dict[str, set[str]] | None = None
-        self._current_node_field_specifiers: dict[str, set[str]] | None = None
+        self._previous_node_field_specifiers = previous_node_field_specifiers or NodeFieldSpecifierMap()
+        self._new_node_field_specifiers: NodeFieldSpecifierMap | None = None
+        self._current_node_field_specifiers: NodeFieldSpecifierMap | None = None
 
     def get_branches(self) -> set[str]:
         return set(self._final_diff_root_by_branch.keys())
@@ -490,51 +497,40 @@ class DiffQueryParser:
             return self._final_diff_root_by_branch[branch]
         return DiffRoot(from_time=self.from_time, to_time=self.to_time, uuid=str(uuid4()), branch=branch, nodes=[])
 
-    def get_diff_node_field_specifiers(self) -> dict[str, set[str]]:
+    def get_diff_node_field_specifiers(self) -> NodeFieldSpecifierMap:
+        node_field_specifiers_map = NodeFieldSpecifierMap()
         if self.diff_branch_name not in self._diff_root_by_branch:
-            return {}
-        node_field_specifiers_map: dict[str, set[str]] = defaultdict(set)
+            return node_field_specifiers_map
         diff_root = self._diff_root_by_branch[self.diff_branch_name]
-        for node in diff_root.nodes_by_id.values():
+        for node in diff_root.nodes_by_identifier.values():
             for attribute_name in node.attributes_by_name:
-                node_field_specifiers_map[node.uuid].add(attribute_name)
+                node_field_specifiers_map.add_entry(node_uuid=node.uuid, kind=node.kind, field_name=attribute_name)
             for relationship_diff in node.relationships_by_identifier.values():
-                node_field_specifiers_map[node.uuid].add(relationship_diff.identifier)
+                node_field_specifiers_map.add_entry(
+                    node_uuid=node.uuid, kind=node.kind, field_name=relationship_diff.identifier
+                )
         return node_field_specifiers_map
 
-    def _remove_node_specifiers(
-        self, node_specifiers: dict[str, set[str]], node_specifiers_to_remove: dict[str, set[str]]
-    ) -> dict[str, set[str]]:
-        final_node_specifiers: dict[str, set[str]] = defaultdict(set)
-        for node_uuid, field_names_set in node_specifiers.items():
-            specifiers_to_remove = node_specifiers_to_remove.get(node_uuid, set())
-            final_specifiers = field_names_set - specifiers_to_remove
-            if final_specifiers:
-                final_node_specifiers[node_uuid] = final_specifiers
-        return final_node_specifiers
-
-    def get_new_node_field_specifiers(self) -> dict[str, set[str]]:
+    def get_new_node_field_specifiers(self) -> NodeFieldSpecifierMap:
         if self._new_node_field_specifiers is not None:
             return self._new_node_field_specifiers
         branch_node_specifiers = self.get_diff_node_field_specifiers()
-        new_node_field_specifiers = self._remove_node_specifiers(
-            branch_node_specifiers, self._previous_node_field_specifiers
-        )
-        self._new_node_field_specifiers = new_node_field_specifiers
-        return new_node_field_specifiers
+        self._new_node_field_specifiers = branch_node_specifiers - self._previous_node_field_specifiers
+        return self._new_node_field_specifiers
 
-    def get_current_node_field_specifiers(self) -> dict[str, set[str]]:
+    def get_current_node_field_specifiers(self) -> NodeFieldSpecifierMap:
         if self._current_node_field_specifiers is not None:
             return self._current_node_field_specifiers
         new_node_field_specifiers = self.get_new_node_field_specifiers()
-        current_node_field_specifiers = self._remove_node_specifiers(
-            self._previous_node_field_specifiers, new_node_field_specifiers
-        )
-        self._current_node_field_specifiers = current_node_field_specifiers
-        return current_node_field_specifiers
+        self._current_node_field_specifiers = self._previous_node_field_specifiers - new_node_field_specifiers
+        return self._current_node_field_specifiers
 
     def read_result(self, query_result: QueryResult) -> None:
-        path = query_result.get_path(label="diff_path")
+        try:
+            path = query_result.get_path(label="diff_path")
+        except ValueError:
+            # the path was null, so nothing to read
+            return
         database_path = DatabasePath.from_cypher_path(cypher_path=path)
         self._parse_path(database_path=database_path)
         self._current_node_field_specifiers = None
@@ -565,11 +561,12 @@ class DiffQueryParser:
         return self._diff_root_by_branch[branch]
 
     def _get_diff_node(self, database_path: DatabasePath, diff_root: DiffRootIntermediate) -> DiffNodeIntermediate:
-        node_id = database_path.node_id
-        if node_id not in diff_root.nodes_by_id:
-            diff_root.nodes_by_id[node_id] = DiffNodeIntermediate(
-                uuid=node_id,
-                kind=database_path.node_kind,
+        identifier = NodeIdentifier(
+            uuid=database_path.node_id, kind=database_path.node_kind, db_id=database_path.node_db_id
+        )
+        if identifier not in diff_root.nodes_by_identifier:
+            diff_root.nodes_by_identifier[identifier] = DiffNodeIntermediate(
+                identifier=identifier,
                 db_id=database_path.node_db_id,
                 from_time=database_path.node_changed_at,
                 status=database_path.node_status,
@@ -577,20 +574,7 @@ class DiffQueryParser:
                 if database_path.node_branch_support is BranchSupportType.AGNOSTIC
                 else None,
             )
-        diff_node = diff_root.nodes_by_id[node_id]
-        # special handling for nodes that have their kind updated, which results in 2 nodes with the same uuid
-        if diff_node.db_id != database_path.node_db_id and (
-            database_path.node_changed_at > diff_node.from_time
-            or (
-                database_path.node_changed_at >= diff_node.from_time
-                and (diff_node.status, database_path.node_status)
-                == (RelationshipStatus.DELETED, RelationshipStatus.ACTIVE)
-            )
-        ):
-            diff_node.kind = database_path.node_kind
-            diff_node.db_id = database_path.node_db_id
-            diff_node.from_time = database_path.node_changed_at
-            diff_node.status = database_path.node_status
+        diff_node = diff_root.nodes_by_identifier[identifier]
         diff_node.track_database_path(database_path=database_path)
         return diff_node
 
@@ -634,7 +618,9 @@ class DiffQueryParser:
         from_time = self.from_time
         if branch_name == self.base_branch_name:
             new_node_field_specifiers = self.get_new_node_field_specifiers()
-            if attribute_name in new_node_field_specifiers.get(diff_node.uuid, set()):
+            if new_node_field_specifiers.has_entry(
+                node_uuid=diff_node.uuid, kind=diff_node.kind, field_name=attribute_name
+            ):
                 from_time = self.diff_branched_from_time
         if attribute_name not in diff_node.attributes_by_name:
             diff_node.attributes_by_name[attribute_name] = DiffAttributeIntermediate(
@@ -678,7 +664,9 @@ class DiffQueryParser:
             from_time = self.from_time
             if branch_name == self.base_branch_name:
                 new_node_field_specifiers = self.get_new_node_field_specifiers()
-                if relationship_schema.get_identifier() in new_node_field_specifiers.get(diff_node.uuid, set()):
+                if new_node_field_specifiers.has_entry(
+                    node_uuid=diff_node.uuid, kind=diff_node.kind, field_name=relationship_schema.get_identifier()
+                ):
                     from_time = self.diff_branched_from_time
             diff_relationship = DiffRelationshipIntermediate(
                 name=relationship_schema.name,
@@ -700,8 +688,10 @@ class DiffQueryParser:
             branch_diff_root = self._diff_root_by_branch.get(branch)
             if not branch_diff_root:
                 continue
-            for node_id, diff_node in branch_diff_root.nodes_by_id.items():
-                base_diff_node = base_diff_root.nodes_by_id.get(node_id)
+            base_diff_nodes_by_uuid = {n.uuid: n for n in base_diff_root.nodes_by_identifier.values()}
+            for identifier, diff_node in branch_diff_root.nodes_by_identifier.items():
+                # changes on a base branch node with a given UUID should apply to all diff branch nodes with that UUID
+                base_diff_node = base_diff_nodes_by_uuid.get(identifier.uuid)
                 if not base_diff_node:
                     continue
                 self._apply_attribute_previous_values(diff_node=diff_node, base_diff_node=base_diff_node)
@@ -771,7 +761,7 @@ class DiffQueryParser:
         base_diff_root = self._diff_root_by_branch.get(self.base_branch_name)
         if not base_diff_root:
             return
-        for node_diff in base_diff_root.nodes_by_id.values():
+        for node_diff in base_diff_root.nodes_by_identifier.values():
             for attribute_diff in node_diff.attributes_by_name.values():
                 for property_diff in attribute_diff.properties_by_type.values():
                     ordered_diff_values = property_diff.get_ordered_values_asc()