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

infrahub/core/diff/model/path.py

@@ -87,13 +87,13 @@ class NodeIdentifier:
 
     uuid: str
     kind: str
-    labels: frozenset[str]
+    db_id: str
 
     def __hash__(self) -> int:
-        return hash(f"{self.uuid}:{self.kind}:{hash(self.labels)}")
+        return hash(f"{self.uuid}:{self.kind}:{self.db_id}")
 
     def __str__(self) -> str:
-        return f"{self.kind} '{self.uuid}' ({','.join(self.labels)})"
+        return f"{self.kind} '{self.uuid}' ({self.db_id})"
 
 
 @dataclass
@@ -327,6 +327,7 @@ class EnrichedDiffNode(BaseSummary):
     path_identifier: str = field(default="", kw_only=True)
     changed_at: Timestamp | None = field(default=None, kw_only=True)
     action: DiffAction
+    is_node_kind_migration: bool = field(default=False)
     conflict: EnrichedDiffConflict | None = field(default=None)
     attributes: set[EnrichedDiffAttribute] = field(default_factory=set)
     relationships: set[EnrichedDiffRelationship] = field(default_factory=set)
@@ -428,6 +429,7 @@ class EnrichedDiffNode(BaseSummary):
             label="",
             changed_at=calculated_node.changed_at,
             action=calculated_node.action,
+            is_node_kind_migration=calculated_node.is_node_kind_migration,
             attributes={
                 EnrichedDiffAttribute.from_calculated_attribute(calculated_attribute=attr)
                 for attr in calculated_node.attributes
@@ -686,6 +688,7 @@ class DiffNode:
     identifier: NodeIdentifier
     changed_at: Timestamp
     action: DiffAction
+    is_node_kind_migration: bool = field(default=False)
     attributes: list[DiffAttribute] = field(default_factory=list)
     relationships: list[DiffRelationship] = field(default_factory=list)
 

infrahub/core/diff/query/merge.py

@@ -20,6 +20,7 @@ class DiffMergeQuery(Query):
         node_diff_dicts: dict[str, Any],
         at: Timestamp,
         target_branch: Branch,
+        migrated_kinds_id_map: dict[str, str],
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
@@ -27,6 +28,7 @@ class DiffMergeQuery(Query):
         self.at = at
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
+        self.migrated_kinds_id_map = migrated_kinds_id_map
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
@@ -35,19 +37,29 @@ class DiffMergeQuery(Query):
             "branch_level": self.target_branch.hierarchy_level,
             "target_branch": self.target_branch.name,
             "source_branch": self.source_branch_name,
+            "migrated_kinds_id_map": self.migrated_kinds_id_map,
+            "migrated_kinds_uuids": list(self.migrated_kinds_id_map.keys()),
         }
         # ruff: noqa: E501
         query = """
 UNWIND $node_diff_dicts AS node_diff_map
+WITH node_diff_map, node_diff_map.uuid IN $migrated_kinds_uuids AS is_node_kind_migration
+WITH node_diff_map, is_node_kind_migration, CASE
+    WHEN $migrated_kinds_uuids IS NULL THEN NULL
+    WHEN is_node_kind_migration THEN $migrated_kinds_id_map[node_diff_map.uuid]
+    ELSE NULL
+END AS node_db_id
 CALL {
-    WITH node_diff_map
+    WITH node_diff_map, node_db_id
     MATCH (n:Node {uuid: node_diff_map.uuid})
+    WHERE node_db_id IS NULL
+    OR %(id_func)s(n) = node_db_id
     RETURN n
 }
-WITH n, node_diff_map
+WITH n, node_diff_map, is_node_kind_migration
 CALL {
-    WITH n, node_diff_map
-    WITH n, node_diff_map, CASE
+    WITH n, node_diff_map, is_node_kind_migration
+    WITH n, node_diff_map, is_node_kind_migration, CASE
         WHEN node_diff_map.action = "ADDED" THEN "active"
         WHEN node_diff_map.action = "REMOVED" THEN "deleted"
         ELSE NULL
@@ -56,9 +68,11 @@ CALL {
         // ------------------------------
         // only make IS_PART_OF updates if node is ADDED or REMOVED
         // ------------------------------
-        WITH n, node_diff_map, node_rel_status
-        WITH n, node_diff_map, node_rel_status
+        WITH n, node_diff_map, node_rel_status, is_node_kind_migration
+        WITH n, node_diff_map, node_rel_status, is_node_kind_migration
         WHERE node_rel_status IS NOT NULL
+        // nodes with a migrated kind are handled in DiffMergeMigratedKindsQuery
+        AND is_node_kind_migration = FALSE
         MATCH (root:Root)
         // ------------------------------
         // set IS_PART_OF.to, optionally, target branch
@@ -214,22 +228,30 @@ CALL {
         // ------------------------------
         CALL {
             WITH n, relationship_diff_map
-            WITH n, relationship_diff_map.peer_id AS rel_peer_id, relationship_diff_map.name AS rel_name, CASE
-                WHEN relationship_diff_map.action = "ADDED" THEN "active"
-                WHEN relationship_diff_map.action = "REMOVED" THEN "deleted"
-                ELSE NULL
-            END AS related_rel_status
+            WITH
+                n, relationship_diff_map.peer_id AS rel_peer_id, relationship_diff_map.name AS rel_name,
+                CASE
+                    WHEN relationship_diff_map.action = "ADDED" THEN "active"
+                    WHEN relationship_diff_map.action = "REMOVED" THEN "deleted"
+                    ELSE NULL
+                END AS related_rel_status,
+                CASE
+                    WHEN $migrated_kinds_uuids IS NULL THEN NULL
+                    WHEN relationship_diff_map.peer_id IN $migrated_kinds_uuids THEN $migrated_kinds_id_map[relationship_diff_map.peer_id]
+                    ELSE NULL
+                END AS rel_peer_db_id
             // ------------------------------
             // determine the directions of each IS_RELATED
             // ------------------------------
             CALL {
-                WITH n, rel_name, rel_peer_id, related_rel_status
+                WITH n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
                 MATCH (n)
                     -[source_r_rel_1:IS_RELATED]
                     -(r:Relationship {name: rel_name})
                     -[source_r_rel_2:IS_RELATED]
-                    -(:Node {uuid: rel_peer_id})
-                WHERE source_r_rel_1.branch IN [$source_branch, $target_branch]
+                    -(rel_peer:Node {uuid: rel_peer_id})
+                WHERE (rel_peer_db_id IS NULL OR %(id_func)s(rel_peer) = rel_peer_db_id)
+                AND source_r_rel_1.branch IN [$source_branch, $target_branch]
                 AND source_r_rel_2.branch IN [$source_branch, $target_branch]
                 AND source_r_rel_1.from <= $at AND source_r_rel_1.to IS NULL
                 AND source_r_rel_2.from <= $at AND source_r_rel_2.to IS NULL
@@ -247,27 +269,29 @@ CALL {
                 source_r_rel_1.hierarchy AS r1_hierarchy,
                 source_r_rel_2.hierarchy AS r2_hierarchy
             }
-            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
             CALL {
-                WITH n, rel_name, rel_peer_id, related_rel_status
+                WITH n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
                 OPTIONAL MATCH (n)
                     -[target_r_rel_1:IS_RELATED {branch: $target_branch, status: "active"}]
                     -(:Relationship {name: rel_name})
                     -[target_r_rel_2:IS_RELATED {branch: $target_branch, status: "active"}]
-                    -(:Node {uuid: rel_peer_id})
+                    -(rel_peer:Node {uuid: rel_peer_id})
                 WHERE related_rel_status = "deleted"
+                AND (rel_peer_db_id IS NULL OR %(id_func)s(rel_peer) = rel_peer_db_id)
                 AND target_r_rel_1.from <= $at AND target_r_rel_1.to IS NULL
                 AND target_r_rel_2.from <= $at AND target_r_rel_2.to IS NULL
                 SET target_r_rel_1.to = $at
                 SET target_r_rel_2.to = $at
             }
-            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
             // ------------------------------
             // conditionally create new IS_RELATED relationships on target_branch, if necessary
             // ------------------------------
             CALL {
-                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
                 MATCH (p:Node {uuid: rel_peer_id})
+                WHERE rel_peer_db_id IS NULL OR %(id_func)s(p) = rel_peer_db_id
                 OPTIONAL MATCH (n)
                     -[r_rel_1:IS_RELATED {branch: $target_branch, status: related_rel_status}]
                     -(:Relationship {name: rel_name})
@@ -320,7 +344,7 @@ CALL {
     }
 }
 RETURN 1 AS done
-        """
+        """ % {"id_func": db.get_id_function_name()}
         self.add_to_query(query=query)
 
 
@@ -334,6 +358,7 @@ class DiffMergePropertiesQuery(Query):
         property_diff_dicts: dict[str, Any],
         at: Timestamp,
         target_branch: Branch,
+        migrated_kinds_id_map: dict[str, str],
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
@@ -341,6 +366,7 @@ class DiffMergePropertiesQuery(Query):
         self.at = at
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
+        self.migrated_kinds_id_map = migrated_kinds_id_map
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
@@ -349,53 +375,70 @@ class DiffMergePropertiesQuery(Query):
             "branch_level": self.target_branch.hierarchy_level,
             "target_branch": self.target_branch.name,
             "source_branch": self.source_branch_name,
+            "migrated_kinds_id_map": self.migrated_kinds_id_map,
+            "migrated_kinds_uuids": list(self.migrated_kinds_id_map.keys()),
         }
         query = """
 UNWIND $property_diff_dicts AS attr_rel_prop_diff
+WITH attr_rel_prop_diff, CASE
+    WHEN $migrated_kinds_uuids IS NULL THEN NULL
+    WHEN attr_rel_prop_diff.node_uuid IN $migrated_kinds_uuids THEN $migrated_kinds_id_map[attr_rel_prop_diff.node_uuid]
+    ELSE NULL
+END AS node_db_id,
+CASE
+    WHEN $migrated_kinds_uuids IS NULL THEN NULL
+    WHEN attr_rel_prop_diff.peer_uuid IN $migrated_kinds_uuids THEN $migrated_kinds_id_map[attr_rel_prop_diff.peer_uuid]
+    ELSE NULL
+END AS peer_db_id
 CALL {
     // ------------------------------
     // find the Attribute node
     // ------------------------------
-    WITH attr_rel_prop_diff
+    WITH attr_rel_prop_diff, node_db_id, peer_db_id
     CALL {
-        WITH attr_rel_prop_diff
+        WITH attr_rel_prop_diff, node_db_id
         OPTIONAL MATCH (n:Node {uuid: attr_rel_prop_diff.node_uuid})
             -[has_attr:HAS_ATTRIBUTE]
             ->(attr:Attribute {name: attr_rel_prop_diff.attribute_name})
         WHERE attr_rel_prop_diff.attribute_name IS NOT NULL
+        AND (node_db_id IS NULL OR %(id_func)s(n) = node_db_id)
         AND has_attr.branch IN [$source_branch, $target_branch]
         RETURN attr
         ORDER BY has_attr.from DESC
         LIMIT 1
     }
     CALL {
-        WITH attr_rel_prop_diff
+        WITH attr_rel_prop_diff, node_db_id, peer_db_id
         OPTIONAL MATCH (n:Node {uuid: attr_rel_prop_diff.node_uuid})
             -[r1:IS_RELATED]
             -(rel:Relationship {name: attr_rel_prop_diff.relationship_id})
             -[r2:IS_RELATED]
-            -(:Node {uuid: attr_rel_prop_diff.peer_uuid})
+            -(rel_peer:Node {uuid: attr_rel_prop_diff.peer_uuid})
         WHERE attr_rel_prop_diff.relationship_id IS NOT NULL
+        AND (node_db_id IS NULL OR %(id_func)s(n) = node_db_id)
+        AND (peer_db_id IS NULL OR %(id_func)s(rel_peer) = peer_db_id)
         AND r1.branch IN [$source_branch, $target_branch]
         AND r2.branch IN [$source_branch, $target_branch]
         RETURN rel
         ORDER BY r1.branch_level DESC, r2.branch_level DESC, r1.from DESC, r2.from DESC
         LIMIT 1
     }
-    WITH attr_rel_prop_diff, COALESCE(attr, rel) AS attr_rel
+    WITH attr_rel_prop_diff, COALESCE(attr, rel) AS attr_rel, peer_db_id
+    WHERE attr_rel IS NOT NULL
     UNWIND attr_rel_prop_diff.properties AS property_diff
     // ------------------------------
     // handle updates for properties under this attribute/relationship
     // ------------------------------
     CALL {
-        WITH attr_rel, property_diff
+        WITH attr_rel, property_diff, peer_db_id
         // ------------------------------
         // identify the correct property node to link
         // ------------------------------
         CALL {
-            WITH attr_rel, property_diff
+            WITH attr_rel, property_diff, peer_db_id
             OPTIONAL MATCH (peer:Node {uuid: property_diff.value})
             WHERE property_diff.property_type IN ["HAS_SOURCE", "HAS_OWNER"]
+            AND (peer_db_id IS NULL OR %(id_func)s(peer) = peer_db_id)
             // ------------------------------
             // the serialized diff might not include the values for IS_VISIBLE and IS_PROTECTED in
             // some cases, so we need to figure them out here
@@ -497,10 +540,203 @@ CALL {
         }
     }
 }
-        """
+        """ % {"id_func": db.get_id_function_name()}
         self.add_to_query(query=query)
 
 
+class DiffMergeMigratedKindsQuery(Query):
+    name = "diff_merge_migrated_kinds"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(
+        self,
+        migrated_uuids: list[str],
+        at: Timestamp,
+        target_branch: Branch,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.migrated_uuids = migrated_uuids
+        self.at = at
+        self.target_branch = target_branch
+        self.source_branch_name = self.branch.name
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params = {
+            "migrated_uuids": self.migrated_uuids,
+            "at": self.at.to_string(),
+            "branch_level": self.target_branch.hierarchy_level,
+            "target_branch": self.target_branch.name,
+            "source_branch": self.source_branch_name,
+        }
+        query = """
+MATCH (n:Node)
+WHERE n.uuid IN $migrated_uuids
+CALL {
+    // --------------
+    // for each migrated node (created or deleted), find its latest edges on the source branch,
+    // check if they exist on the target, create them if not
+    // --------------
+    WITH n
+    MATCH (n)-[]-(peer)
+    WITH DISTINCT n, peer
+    CALL {
+        // --------------
+        // get the latest outbound edge for each type between n and peer
+        // --------------
+        WITH n, peer
+        MATCH (n)-[e {branch: $source_branch}]->(peer)
+        WHERE e.from <= $at AND e.to IS NULL
+        WITH e, type(e) AS edge_type
+        ORDER BY edge_type, e.from DESC
+        WITH edge_type, head(collect(e)) AS latest_source_edge
+        RETURN edge_type, latest_source_edge
+    }
+    CALL {
+        // --------------
+        // for each n, peer, edge_type, get the latest edge on target
+        // --------------
+        WITH n, peer, edge_type
+        OPTIONAL MATCH (n)-[e {branch: $target_branch}]->(peer)
+        WHERE type(e) = edge_type AND e.from <= $at
+        RETURN e AS latest_target_edge
+        ORDER BY e.from DESC
+        LIMIT 1
+    }
+    // --------------
+    // ignore edges of this type that already have the correct status on the target branch
+    // --------------
+    WITH n, peer, edge_type, latest_source_edge, latest_target_edge
+    WHERE (latest_target_edge IS NULL AND latest_source_edge.status = "active")
+    OR latest_source_edge.status <> latest_target_edge.status
+    CALL {
+        // --------------
+        // set the to time on active target branch edges that we are setting to deleted
+        // --------------
+        WITH latest_source_edge, latest_target_edge
+        WITH latest_source_edge, latest_target_edge
+        WHERE latest_target_edge IS NOT NULL
+        AND latest_source_edge.status = "deleted"
+        AND latest_target_edge.status = "active"
+        AND latest_target_edge.to IS NULL
+        SET latest_target_edge.to = $at
+    }
+    // --------------
+    // create the outbound edges on the target branch, one subquery per possible type
+    // --------------
+    CALL {
+        WITH n, latest_source_edge, peer, edge_type
+        WITH n, latest_source_edge, peer, edge_type
+        WHERE edge_type = "IS_PART_OF"
+        CREATE (n)-[new_edge:IS_PART_OF]->(peer)
+        SET new_edge = properties(latest_source_edge)
+        SET new_edge.from = $at
+        SET new_edge.branch_level = $branch_level
+        SET new_edge.branch = $target_branch
+    }
+    CALL {
+        WITH n, latest_source_edge, peer, edge_type
+        WITH n, latest_source_edge, peer, edge_type
+        WHERE edge_type = "IS_RELATED"
+        CREATE (n)-[new_edge:IS_RELATED]->(peer)
+        SET new_edge = properties(latest_source_edge)
+        SET new_edge.from = $at
+        SET new_edge.branch_level = $branch_level
+        SET new_edge.branch = $target_branch
+    }
+    CALL {
+        WITH n, latest_source_edge, peer, edge_type
+        WITH n, latest_source_edge, peer, edge_type
+        WHERE edge_type = "HAS_ATTRIBUTE"
+        CREATE (n)-[new_edge:HAS_ATTRIBUTE]->(peer)
+        SET new_edge = properties(latest_source_edge)
+        SET new_edge.from = $at
+        SET new_edge.branch_level = $branch_level
+        SET new_edge.branch = $target_branch
+    }
+    // --------------
+    // do all of this again for inbound edges
+    // --------------
+    WITH DISTINCT n, peer
+    CALL {
+        // --------------
+        // get the latest inbound edge for each type between n and peer
+        // --------------
+        WITH n, peer
+        MATCH (n)<-[e {branch: $source_branch}]-(peer)
+        WHERE e.from <= $at AND e.to IS NULL
+        WITH e, type(e) AS edge_type
+        ORDER BY edge_type, e.from DESC
+        WITH edge_type, head(collect(e)) AS latest_source_edge
+        RETURN edge_type, latest_source_edge
+    }
+    CALL {
+        // --------------
+        // for each n, peer, edge_type, get the latest edge on target
+        // --------------
+        WITH n, peer, edge_type
+        OPTIONAL MATCH (n)<-[e {branch: $target_branch}]-(peer)
+        WHERE type(e) = edge_type AND e.from <= $at
+        RETURN e AS latest_target_edge
+        ORDER BY e.from DESC
+        LIMIT 1
+    }
+    // --------------
+    // ignore edges of this type that already have the correct status on the target branch
+    // --------------
+    WITH n, peer, edge_type, latest_source_edge, latest_target_edge
+    WHERE latest_target_edge IS NULL OR latest_source_edge.status <> latest_target_edge.status
+    CALL {
+        // --------------
+        // set the to time on active target branch edges that we are setting to deleted
+        // --------------
+        WITH latest_source_edge, latest_target_edge
+        WITH latest_source_edge, latest_target_edge
+        WHERE latest_target_edge IS NOT NULL
+        AND latest_source_edge.status = "deleted"
+        AND latest_target_edge.status = "active"
+        AND latest_target_edge.to IS NULL
+        SET latest_target_edge.to = $at
+    }
+    // --------------
+    // create the outbound edges on the target branch, one subquery per possible type
+    // --------------
+    CALL {
+        WITH n, latest_source_edge, peer, edge_type
+        WITH n, latest_source_edge, peer, edge_type
+        WHERE edge_type = "IS_RELATED"
+        CREATE (n)<-[new_edge:IS_RELATED]-(peer)
+        SET new_edge = properties(latest_source_edge)
+        SET new_edge.from = $at
+        SET new_edge.branch_level = $branch_level
+        SET new_edge.branch = $target_branch
+    }
+    CALL {
+        WITH n, latest_source_edge, peer, edge_type
+        WITH n, latest_source_edge, peer, edge_type
+        WHERE edge_type = "HAS_OWNER"
+        CREATE (n)<-[new_edge:HAS_OWNER]-(peer)
+        SET new_edge = properties(latest_source_edge)
+        SET new_edge.from = $at
+        SET new_edge.branch_level = $branch_level
+        SET new_edge.branch = $target_branch
+    }
+    CALL {
+        WITH n, latest_source_edge, peer, edge_type
+        WITH n, latest_source_edge, peer, edge_type
+        WHERE edge_type = "HAS_SOURCE"
+        CREATE (n)<-[new_edge:HAS_SOURCE]-(peer)
+        SET new_edge = properties(latest_source_edge)
+        SET new_edge.from = $at
+        SET new_edge.branch_level = $branch_level
+        SET new_edge.branch = $target_branch
+    }
+}
+        """
+        self.add_to_query(query)
+
+
 class DiffMergeRollbackQuery(Query):
     name = "diff_merge_rollback"
     type = QueryType.WRITE

infrahub/core/diff/query/save.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any, Iterable
 
 from infrahub.core.query import Query, QueryType
@@ -86,16 +85,17 @@ 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.db_labels = node_map.node_properties.db_labels,
     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 {
@@ -403,7 +403,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_labels": json.dumps(list(enriched_node.identifier.labels)),
+                "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,

infrahub/core/diff/query_parser.py

@@ -558,7 +558,7 @@ class DiffQueryParser:
 
     def _get_diff_node(self, database_path: DatabasePath, diff_root: DiffRootIntermediate) -> DiffNodeIntermediate:
         identifier = NodeIdentifier(
-            uuid=database_path.node_id, kind=database_path.node_kind, labels=database_path.node_labels
+            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(
@@ -571,19 +571,6 @@ class DiffQueryParser:
                 else None,
             )
         diff_node = diff_root.nodes_by_identifier[identifier]
-        # 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.identifier.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.track_database_path(database_path=database_path)
         return diff_node
 
@@ -697,8 +684,10 @@ class DiffQueryParser:
             branch_diff_root = self._diff_root_by_branch.get(branch)
             if not branch_diff_root:
                 continue
+            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():
-                base_diff_node = base_diff_root.nodes_by_identifier.get(identifier)
+                # 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)

infrahub/core/diff/repository/deserializer.py

@@ -1,5 +1,3 @@
-import json
-
 from neo4j.graph import Node as Neo4jNode
 from neo4j.graph import Path as Neo4jPath
 
@@ -86,11 +84,13 @@ class EnrichedDiffDeserializer:
     ) -> None:
         for attribute_result in result.get_nested_node_collection("diff_attributes"):
             diff_attr_node, diff_attr_property_node, diff_attr_property_conflict = attribute_result
-            if diff_attr_node is None or diff_attr_property_node is None:
+            if diff_attr_node is None:
                 continue
             enriched_attribute = self._deserialize_diff_attr(
                 diff_attr_node=diff_attr_node, enriched_root=enriched_root, enriched_node=enriched_node
             )
+            if diff_attr_property_node is None:
+                continue
             enriched_property = self._deserialize_diff_attr_property(
                 diff_attr_property_node=diff_attr_property_node,
                 enriched_attr=enriched_attribute,
@@ -147,7 +147,7 @@ class EnrichedDiffDeserializer:
                     parent_identifier = NodeIdentifier(
                         uuid=parent.get("uuid"),
                         kind=parent.get("kind"),
-                        labels=frozenset(json.loads(parent.get("db_labels"))),
+                        db_id=parent.get("db_id"),
                     )
                     parent_request = ParentNodeAddRequest(
                         node_identifier=current_node_identifier,
@@ -201,8 +201,8 @@ class EnrichedDiffDeserializer:
     def _deserialize_diff_node(self, node_node: Neo4jNode, enriched_root: EnrichedDiffRoot) -> EnrichedDiffNode:
         node_uuid = str(node_node.get("uuid"))
         node_kind = str(node_node.get("kind"))
-        node_db_labels = frozenset(json.loads(node_node.get("db_labels")))
-        node_identifier = NodeIdentifier(uuid=node_uuid, kind=node_kind, labels=node_db_labels)
+        node_db_id = node_node.get("db_id")
+        node_identifier = NodeIdentifier(uuid=node_uuid, kind=node_kind, db_id=node_db_id)
         node_key = (enriched_root.uuid, node_identifier)
         if node_key in self._diff_node_map:
             return self._diff_node_map[node_key]
@@ -213,6 +213,7 @@ class EnrichedDiffDeserializer:
             label=str(node_node.get("label")),
             changed_at=Timestamp(timestamp_str) if timestamp_str else None,
             action=DiffAction(str(node_node.get("action"))),
+            is_node_kind_migration=bool(node_node.get("is_node_kind_migration")),
             path_identifier=str(node_node.get("path_identifier")),
             num_added=int(node_node.get("num_added", 0)),
             num_updated=int(node_node.get("num_updated", 0)),

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 27
+GRAPH_VERSION = 28

infrahub/core/migrations/graph/m028_delete_diffs.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from infrahub.core import registry
+from infrahub.core.diff.repository.repository import DiffRepository
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.dependencies.registry import build_component_registry, get_component_registry
+from infrahub.log import get_logger
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration028(ArbitraryMigration):
+    """Delete all diffs because of an update to how we store diff information. All diffs will need to be recalculated"""
+
+    name: str = "028_diff_delete_bug_fix_update"
+    minimum_version: int = 27
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+
+        return result
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        default_branch = registry.get_branch_from_registry()
+        build_component_registry()
+        component_registry = get_component_registry()
+        diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
+
+        diff_roots = await diff_repo.get_roots_metadata()
+        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        return MigrationResult()