infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub/core/diff/query/save.py

@@ -11,38 +11,32 @@ from ..model.path import (
     EnrichedDiffRelationship,
     EnrichedDiffs,
     EnrichedDiffSingleRelationship,
+    EnrichedDiffsMetadata,
     EnrichedNodeCreateRequest,
 )
 
 
-class EnrichedDiffRootsCreateQuery(Query):
+class EnrichedDiffRootsUpsertQuery(Query):
     name = "enriched_roots_create"
     type = QueryType.WRITE
     insert_return = False
 
-    def __init__(self, enriched_diffs: EnrichedDiffs, **kwargs: Any) -> None:
+    def __init__(self, enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.enriched_diffs = enriched_diffs
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = self._build_diff_root_params(enriched_diffs=self.enriched_diffs)
         query = """
 UNWIND $diff_root_list AS diff_root_map
 WITH diff_root_map
 CALL {
     WITH diff_root_map
-    MERGE (diff_root:DiffRoot {
-        base_branch: diff_root_map.base_branch,
-        diff_branch: diff_root_map.diff_branch,
-        from_time: diff_root_map.from_time,
-        to_time: diff_root_map.to_time,
-        uuid: diff_root_map.uuid,
-        num_added: diff_root_map.num_added,
-        num_updated: diff_root_map.num_updated,
-        num_removed: diff_root_map.num_removed,
-        num_conflicts: diff_root_map.num_conflicts,
-        contains_conflict: diff_root_map.contains_conflict
-    })
+    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
+    SET diff_root.from_time = diff_root_map.from_time
+    SET diff_root.to_time = diff_root_map.to_time
     SET diff_root.tracking_id = diff_root_map.tracking_id
     RETURN diff_root
 }
@@ -58,7 +52,7 @@ CALL {
         """
         self.add_to_query(query)
 
-    def _build_diff_root_params(self, enriched_diffs: EnrichedDiffs) -> dict[str, Any]:
+    def _build_diff_root_params(self, enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata) -> dict[str, Any]:
         diff_root_list: list[dict[str, Any]] = []
         for enriched_diff in (enriched_diffs.base_branch_diff, enriched_diffs.diff_branch_diff):
             diff_root_list.append(
@@ -69,11 +63,6 @@ CALL {
                     "to_time": enriched_diff.to_time.to_string(),
                     "uuid": enriched_diff.uuid,
                     "tracking_id": enriched_diff.tracking_id.serialize() if enriched_diff.tracking_id else None,
-                    "num_added": enriched_diff.num_added,
-                    "num_updated": enriched_diff.num_updated,
-                    "num_removed": enriched_diff.num_removed,
-                    "num_conflicts": enriched_diff.num_conflicts,
-                    "contains_conflict": enriched_diff.contains_conflict,
                 }
             )
         return {"diff_root_list": diff_root_list}
@@ -88,7 +77,7 @@ class EnrichedNodeBatchCreateQuery(Query):
         super().__init__(**kwargs)
         self.node_create_batch = node_create_batch
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = self._build_node_batch_params()
         query = """
 UNWIND $node_details_list AS node_details
@@ -96,79 +85,195 @@ WITH node_details.root_uuid AS root_uuid, node_details.node_map AS node_map
 CALL {
     WITH root_uuid, node_map
     MATCH (diff_root {uuid: root_uuid})
-    CREATE (diff_root)-[:DIFF_HAS_NODE]->(diff_node:DiffNode)
-    SET diff_node = node_map.node_properties
+    MERGE (diff_root)-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_map.node_properties.uuid})
+    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.path_identifier = node_map.node_properties.path_identifier
     // -------------------------
-    // add node-level conflict
+    // add/remove node-level conflict
     // -------------------------
-    FOREACH (i in CASE WHEN node_map.conflict_params IS NOT NULL THEN [1] ELSE [] END |
-        CREATE (diff_node)-[:DIFF_HAS_CONFLICT]->(diff_node_conflict:DiffConflict)
+    WITH diff_node, node_map
+    OPTIONAL MATCH (diff_node)-[:DIFF_HAS_CONFLICT]->(current_diff_node_conflict:DiffConflict)
+    WITH diff_node, node_map, current_diff_node_conflict, (node_map.conflict_params IS NOT NULL) AS has_node_conflict
+    FOREACH (i in CASE WHEN has_node_conflict = FALSE THEN [1] ELSE [] END |
+        DETACH DELETE current_diff_node_conflict
+    )
+    FOREACH (i in CASE WHEN has_node_conflict = TRUE THEN [1] ELSE [] END |
+        MERGE (diff_node)-[:DIFF_HAS_CONFLICT]->(diff_node_conflict:DiffConflict)
         SET diff_node_conflict = node_map.conflict_params
     )
+}
+CALL {
+    WITH root_uuid, node_map
+    MATCH (diff_root {uuid: root_uuid})-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_map.node_properties.uuid})
     // -------------------------
-    // add attributes for this node
+    // 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
+        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)
+        DETACH DELETE next_to_delete
+        DETACH DELETE attr_to_delete
+    }
+    // -------------------------
+    // add attributes for this node
+    // -------------------------
     CALL {
         WITH diff_node, node_map
         UNWIND node_map.attributes AS node_attribute
-        CREATE (diff_node)-[:DIFF_HAS_ATTRIBUTE]->(diff_attribute:DiffAttribute)
+        MERGE (diff_node)-[:DIFF_HAS_ATTRIBUTE]->(diff_attribute:DiffAttribute {name: node_attribute.node_properties.name})
         SET diff_attribute = node_attribute.node_properties
         // -------------------------
         // add properties for this attribute
         // -------------------------
         WITH diff_attribute, node_attribute
+            // -------------------------
+            // remove stale properties for this attribute
+            // -------------------------
+            CALL {
+            WITH diff_attribute, node_attribute
+            WITH diff_attribute, %(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)
+            DETACH DELETE next_to_delete
+            DETACH DELETE prop_to_delete
+        }
         UNWIND node_attribute.properties AS attr_property
-        CREATE (diff_attribute)-[:DIFF_HAS_PROPERTY]->(diff_attr_prop:DiffProperty)
+        MERGE (diff_attribute)-[:DIFF_HAS_PROPERTY]->(diff_attr_prop:DiffProperty {property_type: attr_property.node_properties.property_type})
         SET diff_attr_prop = attr_property.node_properties
         // -------------------------
-        // add conflict for this property
+        // add/remove conflict for this property
         // -------------------------
-        FOREACH (i in CASE WHEN attr_property.conflict_params IS NOT NULL THEN [1] ELSE [] END |
-            CREATE (diff_attr_prop)-[:DIFF_HAS_CONFLICT]->(diff_attribute_property_conflict:DiffConflict)
-            SET diff_attribute_property_conflict = attr_property.conflict_params
+        WITH diff_attr_prop, attr_property
+        OPTIONAL MATCH (diff_attr_prop)-[:DIFF_HAS_CONFLICT]->(current_attr_prop_conflict:DiffConflict)
+        WITH diff_attr_prop, attr_property, current_attr_prop_conflict, (attr_property.conflict_params IS NOT NULL) AS has_prop_conflict
+        FOREACH (i in CASE WHEN has_prop_conflict = FALSE THEN [1] ELSE [] END |
+            DETACH DELETE current_attr_prop_conflict
+        )
+        FOREACH (i in CASE WHEN has_prop_conflict = TRUE THEN [1] ELSE [] END |
+            MERGE (diff_attr_prop)-[:DIFF_HAS_CONFLICT]->(diff_attr_prop_conflict:DiffConflict)
+            SET diff_attr_prop_conflict = attr_property.conflict_params
         )
     }
     // -------------------------
+    // remove stale relationships for this node
+    // -------------------------
+    WITH diff_node, node_map
+    CALL {
+        WITH diff_node, node_map
+        WITH diff_node, %(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)
+        DETACH DELETE next_to_delete
+        DETACH DELETE rel_to_delete
+    }
+    // -------------------------
     // add relationships for this node
     // -------------------------
     WITH diff_node, node_map
     CALL {
         WITH diff_node, node_map
         UNWIND node_map.relationships as node_relationship
-        CREATE (diff_node)-[:DIFF_HAS_RELATIONSHIP]->(diff_relationship:DiffRelationship)
+        MERGE (diff_node)-[:DIFF_HAS_RELATIONSHIP]->(diff_relationship:DiffRelationship {name: node_relationship.node_properties.name})
         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
+            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)
+            DETACH DELETE next_to_delete
+            DETACH DELETE element_to_delete
+        }
+        // -------------------------
         // add elements for this relationship group
         // -------------------------
         WITH diff_relationship, node_relationship
         UNWIND node_relationship.relationships as node_single_relationship
-        CREATE (diff_relationship)-[:DIFF_HAS_ELEMENT]->(diff_relationship_element:DiffRelationshipElement)
+        MERGE (diff_relationship)-[:DIFF_HAS_ELEMENT]
+            ->(diff_relationship_element:DiffRelationshipElement {peer_id: node_single_relationship.node_properties.peer_id})
         SET diff_relationship_element = node_single_relationship.node_properties
         // -------------------------
-        // add conflict for this relationship element
+        // add/remove conflict for this relationship element
         // -------------------------
-        FOREACH (i in CASE WHEN node_single_relationship.conflict_params IS NOT NULL THEN [1] ELSE [] END |
-            CREATE (diff_relationship_element)-[:DIFF_HAS_CONFLICT]->(diff_relationship_conflict:DiffConflict)
-            SET diff_relationship_conflict = node_single_relationship.conflict_params
+        WITH diff_relationship_element, node_single_relationship
+        OPTIONAL MATCH (diff_relationship_element)-[:DIFF_HAS_CONFLICT]->(current_element_conflict:DiffConflict)
+        WITH diff_relationship_element, node_single_relationship, current_element_conflict,
+            (node_single_relationship.conflict_params IS NOT NULL) AS has_element_conflict
+        FOREACH (i in CASE WHEN has_element_conflict = FALSE THEN [1] ELSE [] END |
+            DETACH DELETE current_element_conflict
         )
+        FOREACH (i in CASE WHEN has_element_conflict = TRUE THEN [1] ELSE [] END |
+            MERGE (diff_relationship_element)-[:DIFF_HAS_CONFLICT]->(element_conflict:DiffConflict)
+            SET element_conflict = node_single_relationship.conflict_params
+        )
+        // -------------------------
+        // 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
+            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)
+            DETACH DELETE next_to_delete
+            DETACH DELETE property_to_delete
+        }
         // -------------------------
         // add properties for this relationship element
         // -------------------------
         WITH diff_relationship_element, node_single_relationship
         UNWIND node_single_relationship.properties as node_relationship_property
-        CREATE (diff_relationship_element)-[:DIFF_HAS_PROPERTY]->(diff_relationship_property:DiffProperty)
+        MERGE (diff_relationship_element)-[:DIFF_HAS_PROPERTY]
+            ->(diff_relationship_property:DiffProperty {property_type: node_relationship_property.node_properties.property_type})
         SET diff_relationship_property = node_relationship_property.node_properties
         // -------------------------
         // add conflict for this relationship element
         // -------------------------
-        FOREACH (i in CASE WHEN node_relationship_property.conflict_params IS NOT NULL THEN [1] ELSE [] END |
-            CREATE (diff_relationship_property)-[:DIFF_HAS_CONFLICT]->(diff_relationship_property_conflict:DiffConflict)
-            SET diff_relationship_property_conflict = node_relationship_property.conflict_params
+        WITH diff_relationship_property, node_relationship_property
+        OPTIONAL MATCH (diff_relationship_property)-[:DIFF_HAS_CONFLICT]->(diff_relationship_property_conflict:DiffConflict)
+        WITH diff_relationship_property, node_relationship_property, diff_relationship_property_conflict,
+            (node_relationship_property.conflict_params IS NOT NULL) AS has_property_conflict
+        FOREACH (i in CASE WHEN has_property_conflict = FALSE THEN [1] ELSE [] END |
+            DETACH DELETE diff_relationship_property_conflict
+        )
+        FOREACH (i in CASE WHEN has_property_conflict = TRUE THEN [1] ELSE [] END |
+            MERGE (diff_relationship_property)-[:DIFF_HAS_CONFLICT]->(property_conflict:DiffConflict)
+            SET property_conflict = node_relationship_property.conflict_params
         )
     }
 }
-        """
+        """ % {
+            "attr_name_list_comp": db.render_list_comprehension(
+                items="node_map.attributes", item_name="node_properties.name"
+            ),
+            "attr_props_list_comp": db.render_list_comprehension(
+                items="node_attribute.properties", item_name="node_properties.property_type"
+            ),
+            "rel_name_list_comp": db.render_list_comprehension(
+                items="node_map.relationships", item_name="node_properties.name"
+            ),
+            "rel_peers_list_comp": db.render_list_comprehension(
+                items="node_relationship.relationships", item_name="node_properties.peer_id"
+            ),
+            "element_props_list_comp": db.render_list_comprehension(
+                items="node_single_relationship.properties", item_name="node_properties.property_type"
+            ),
+        }
         self.add_to_query(query)
 
     def _build_conflict_params(self, enriched_conflict: EnrichedDiffConflict) -> dict[str, Any]:
@@ -218,11 +323,6 @@ CALL {
                 "changed_at": enriched_attribute.changed_at.to_string(),
                 "action": enriched_attribute.action.value,
                 "path_identifier": enriched_attribute.path_identifier,
-                "num_added": enriched_attribute.num_added,
-                "num_updated": enriched_attribute.num_updated,
-                "num_removed": enriched_attribute.num_removed,
-                "num_conflicts": enriched_attribute.num_conflicts,
-                "contains_conflict": enriched_attribute.contains_conflict,
             },
             "properties": property_props,
         }
@@ -243,11 +343,6 @@ CALL {
                 "peer_id": enriched_single_relationship.peer_id,
                 "peer_label": enriched_single_relationship.peer_label,
                 "path_identifier": enriched_single_relationship.path_identifier,
-                "num_added": enriched_single_relationship.num_added,
-                "num_updated": enriched_single_relationship.num_updated,
-                "num_removed": enriched_single_relationship.num_removed,
-                "num_conflicts": enriched_single_relationship.num_conflicts,
-                "contains_conflict": enriched_single_relationship.contains_conflict,
             },
             "conflict_params": conflict_params,
             "properties": property_props,
@@ -269,11 +364,6 @@ CALL {
                 else None,
                 "action": enriched_relationship.action,
                 "path_identifier": enriched_relationship.path_identifier,
-                "num_added": enriched_relationship.num_added,
-                "num_updated": enriched_relationship.num_updated,
-                "num_removed": enriched_relationship.num_removed,
-                "num_conflicts": enriched_relationship.num_conflicts,
-                "contains_conflict": enriched_relationship.contains_conflict,
             },
             "relationships": single_relationship_props,
         }
@@ -296,11 +386,6 @@ CALL {
                 "changed_at": enriched_node.changed_at.to_string() if enriched_node.changed_at else None,
                 "action": enriched_node.action.value,
                 "path_identifier": enriched_node.path_identifier,
-                "num_added": enriched_node.num_added,
-                "num_updated": enriched_node.num_updated,
-                "num_removed": enriched_node.num_removed,
-                "num_conflicts": enriched_node.num_conflicts,
-                "contains_conflict": enriched_node.contains_conflict,
             },
             "conflict_params": conflict_params,
             "attributes": attribute_props,
@@ -328,7 +413,7 @@ class EnrichedNodesLinkQuery(Query):
         super().__init__(**kwargs)
         self.enriched_diffs = enriched_diffs
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         parent_links_list = []
         for diff_root in (self.enriched_diffs.base_branch_diff, self.enriched_diffs.diff_branch_diff):
             for node in diff_root.nodes:

infrahub/core/diff/query/summary_counts_enricher.py

@@ -0,0 +1,220 @@
+from typing import Any
+
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+from ..model.path import TrackingId
+
+
+class DiffSummaryCountsEnricherQuery(Query):
+    """Update summary counters for a given diff"""
+
+    name = "diff_summary_count_enricher"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(
+        self,
+        diff_branch_name: str,
+        tracking_id: TrackingId | None = None,
+        diff_id: str | None = None,
+        node_uuids: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        if (diff_id is None and tracking_id is None) or (diff_id and tracking_id):
+            raise ValueError("EnrichedDiffAllConflictsQuery requires one and only one of `tracking_id` or `diff_id`")
+        self.diff_branch_name = diff_branch_name
+        self.tracking_id = tracking_id
+        self.diff_id = diff_id
+        if self.tracking_id is None and self.diff_id is None:
+            raise RuntimeError("tracking_id or diff_id is required")
+        self.node_uuids = node_uuids
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params = {
+            "diff_branch_name": self.diff_branch_name,
+            "diff_id": self.diff_id,
+            "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,
+            "node_uuids": self.node_uuids,
+        }
+        query = """
+MATCH (root:DiffRoot)
+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 {
+    // ----------------------
+    // handle attribute count updates
+    // ----------------------
+    WITH dn
+    MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute)
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty)-[:DIFF_HAS_CONFLICT]->(dc:DiffConflict)
+        WITH da, count(dc) AS num_conflicts
+        SET da.num_conflicts = num_conflicts
+        SET da.contains_conflict = (num_conflicts > 0)
+    }
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "added"})
+        WITH da, count(dp.action) AS num_added
+        SET da.num_added = num_added
+    }
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "updated"})
+        WITH da, count(dp.action) AS num_updated
+        SET da.num_updated = num_updated
+    }
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "removed"})
+        WITH da, count(dp.action) AS num_removed
+        SET da.num_removed = num_removed
+    }
+}
+CALL {
+    WITH dn
+    MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
+    CALL {
+        // ----------------------
+        // handle relationship element count updates
+        // ----------------------
+        WITH dr
+        MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement)
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[*..4]->(dc:DiffConflict)
+            WITH dre, count(dc) AS num_conflicts
+            SET dre.num_conflicts = num_conflicts
+            SET dre.contains_conflict = (num_conflicts > 0)
+        }
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "added"})
+            WITH dre, count(dp.action) AS num_added
+            SET dre.num_added = num_added
+        }
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "updated"})
+            WITH dre, count(dp.action) AS num_updated
+            SET dre.num_updated = num_updated
+        }
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "removed"})
+            WITH dre, count(dp.action) AS num_removed
+            SET dre.num_removed = num_removed
+        }
+    }
+    // ----------------------
+    // handle relationship count updates
+    // ----------------------
+    OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(conflict_dre:DiffRelationshipElement {contains_conflict: TRUE})
+    WITH dr, sum(conflict_dre.num_conflicts) AS num_conflicts
+    SET dr.num_conflicts = num_conflicts
+    SET dr.contains_conflict = (num_conflicts > 0)
+    WITH dr
+    CALL {
+        WITH dr
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "added"})
+        WITH dr, count(dre.action) AS num_added
+        SET dr.num_added = num_added
+    }
+    CALL {
+        WITH dr
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "updated"})
+        WITH dr, count(dre.action) AS num_updated
+        SET dr.num_updated = num_updated
+    }
+    CALL {
+        WITH dr
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "removed"})
+        WITH dr, count(dre.action) AS num_removed
+        SET dr.num_removed = num_removed
+    }
+}
+// ----------------------
+// handle node count updates
+// ----------------------
+WITH root, dn, coalesce(dn.num_conflicts, 0) AS previous_num_conflicts
+CALL {
+    // ----------------------
+    // 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
+}
+WITH root, dn, previous_num_conflicts, sum(num_conflicts) AS updated_num_conflicts
+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 {
+    // ----------------------
+    // handle node added/updated/removed updates
+    // ----------------------
+    WITH dn
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute)
+    WITH dn, 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 |
+        CASE
+            WHEN a = "added" THEN [counts[0] + 1, counts[1], counts[2]]
+            WHEN a = "updated" THEN [counts[0], counts[1] + 1, counts[2]]
+            WHEN a = "removed" THEN [counts[0], counts[1], counts[2] + 1]
+            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
+    SET dn.num_added = num_added
+    SET dn.num_updated = num_updated
+    SET dn.num_removed = num_removed
+}
+// ----------------------
+// handle conflict updates for parent nodes
+// ----------------------
+WITH root, dn, num_conflicts_delta
+CALL {
+    WITH 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)
+}
+// ----------------------
+// handle root count updates
+// ----------------------
+WITH root, sum(num_conflicts_delta) AS total_conflicts_delta
+CALL {
+    WITH 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
+    OPTIONAL MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode {action: "added"})
+    WITH root, count(dn.action) AS num_added
+    SET root.num_added = num_added
+    WITH root
+    OPTIONAL MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode {action: "updated"})
+    WITH root, count(dn.action) AS num_updated
+    SET root.num_updated = num_updated
+    WITH root
+    OPTIONAL MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode {action: "removed"})
+    WITH root, count(dn.action) AS num_removed
+    SET root.num_removed = num_removed
+}
+        """
+        self.add_to_query(query)

infrahub/core/diff/query/time_range_query.py

@@ -30,7 +30,7 @@ class EnrichedDiffTimeRangeQuery(Query):
         self.from_time = from_time
         self.to_time = to_time
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "base_branch": self.base_branch_name,
             "diff_branch": self.diff_branch_name,
@@ -41,7 +41,8 @@ class EnrichedDiffTimeRangeQuery(Query):
         query = """
         // get the roots of all diffs in the query
         MATCH (diff_root:DiffRoot)
-        WHERE diff_root.base_branch = $base_branch
+        WHERE (diff_root.is_merged IS NULL OR diff_root.is_merged <> TRUE)
+        AND diff_root.base_branch = $base_branch
         AND diff_root.diff_branch = $diff_branch
         AND diff_root.from_time >= $from_time
         AND diff_root.to_time <= $to_time

infrahub/core/diff/query/update_conflict_query.py

@@ -21,7 +21,7 @@ class EnrichedDiffConflictUpdateQuery(Query):
         self.conflict_id = conflict_id
         self.selection = selection
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"conflict_id": self.conflict_id, "selection": self.selection.value if self.selection else None}
         query = """
         MATCH (conflict:DiffConflict {uuid: $conflict_id})