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

infrahub/core/diff/query/merge.py

@@ -36,6 +36,7 @@ class DiffMergeQuery(Query):
             "target_branch": self.target_branch.name,
             "source_branch": self.source_branch_name,
         }
+        # ruff: noqa: E501
         query = """
 UNWIND $node_diff_dicts AS node_diff_map
 CALL {
@@ -242,9 +243,11 @@ CALL {
                 CASE
                     WHEN startNode(source_r_rel_2).uuid = r.uuid THEN "r"
                     ELSE "l"
-                END AS r2_dir
+                END AS r2_dir,
+                source_r_rel_1.hierarchy AS r1_hierarchy,
+                source_r_rel_2.hierarchy AS r2_hierarchy
             }
-            WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
             CALL {
                 WITH n, rel_name, rel_peer_id, related_rel_status
                 OPTIONAL MATCH (n)
@@ -258,12 +261,12 @@ CALL {
                 SET target_r_rel_1.to = $at
                 SET target_r_rel_2.to = $at
             }
-            WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
             // ------------------------------
             // conditionally create new IS_RELATED relationships on target_branch, if necessary
             // ------------------------------
             CALL {
-                WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
                 MATCH (p:Node {uuid: rel_peer_id})
                 OPTIONAL MATCH (n)
                     -[r_rel_1:IS_RELATED {branch: $target_branch, status: related_rel_status}]
@@ -274,42 +277,42 @@ CALL {
                 AND (r_rel_1.to >= $at OR r_rel_1.to IS NULL)
                 AND r_rel_2.from <= $at
                 AND (r_rel_2.to >= $at OR r_rel_2.to IS NULL)
-                WITH n, r, r1_dir, r2_dir, p, related_rel_status, r_rel_1, r_rel_2
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, p, related_rel_status, r_rel_1, r_rel_2
                 WHERE r_rel_1 IS NULL
                 AND r_rel_2 IS NULL
                 // ------------------------------
                 // create IS_RELATED relationships with directions maintained from source
                 // ------------------------------
                 CALL {
-                    WITH n, r, r1_dir, related_rel_status
-                    WITH n, r, r1_dir, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "r"
                     CREATE (n)
-                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         ->(r)
                 }
                 CALL {
-                    WITH n, r, r1_dir, related_rel_status
-                    WITH n, r, r1_dir, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "l"
                     CREATE (n)
-                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         -(r)
                 }
                 CALL {
-                    WITH r, p, r2_dir, related_rel_status
-                    WITH r, p, r2_dir, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "r"
                     CREATE (r)
-                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         ->(p)
                 }
                 CALL {
-                    WITH r, p, r2_dir, related_rel_status
-                    WITH r, p, r2_dir, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "l"
                     CREATE (r)
-                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         -(p)
                 }
             }

infrahub/core/diff/query/save.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Iterable
 
 from infrahub.core.query import Query, QueryType
 from infrahub.database import InfrahubDatabase
@@ -42,6 +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
     WITH diff_roots[0] AS base_diff_node, diff_roots[1] AS branch_diff_node
@@ -81,34 +82,59 @@ class EnrichedNodeBatchCreateQuery(Query):
         self.params = self._build_node_batch_params()
         query = """
 UNWIND $node_details_list AS node_details
-WITH node_details.root_uuid AS root_uuid, node_details.node_map AS node_map
+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
+MERGE (diff_root:DiffRoot {uuid: root_uuid})
+MERGE (diff_root)-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_uuid})
+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.path_identifier = node_map.node_properties.path_identifier
+WITH root_uuid, node_map, diff_node, has_node_conflict
 CALL {
-    WITH root_uuid, node_map
-    MATCH (diff_root {uuid: root_uuid})
-    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/remove node-level conflict
+    // delete parent-child relationships for included nodes, they will be added in EnrichedNodesLinkQuery
     // -------------------------
-    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
-    )
+    WITH diff_node
+    MATCH (diff_node)-[:DIFF_HAS_RELATIONSHIP]->(:DiffRelationship)-[parent_rel:DIFF_HAS_NODE]->(:DiffNode)
+    DELETE parent_rel
+}
+OPTIONAL MATCH (diff_node)-[:DIFF_HAS_CONFLICT]->(current_node_conflict:DiffConflict)
+CALL {
+    // -------------------------
+    // 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 {
+    // -------------------------
+    // 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 {
+    // -------------------------
+    // 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 {
-    WITH root_uuid, node_map
-    MATCH (diff_root {uuid: root_uuid})-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_map.node_properties.uuid})
     // -------------------------
     // remove stale attributes for this node
     // -------------------------
@@ -125,138 +151,131 @@ CALL {
     // -------------------------
     // add attributes for this node
     // -------------------------
-    CALL {
-        WITH diff_node, node_map
-        UNWIND node_map.attributes AS node_attribute
-        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
-        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/remove conflict for this property
-        // -------------------------
-        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
-        )
-    }
+    UNWIND node_map.attributes AS node_attribute
+    MERGE (diff_node)-[:DIFF_HAS_ATTRIBUTE]->(diff_attribute:DiffAttribute {name: node_attribute.node_properties.name})
+    SET diff_attribute = node_attribute.node_properties
     // -------------------------
-    // remove stale relationships for this node
+    // add properties for this attribute
+    // -------------------------
+    WITH diff_attribute, node_attribute
+    // -------------------------
+    // remove stale properties for this attribute
     // -------------------------
-    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)
+        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 rel_to_delete
+        DETACH DELETE prop_to_delete
     }
+    UNWIND node_attribute.properties AS attr_property
+    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 relationships for this node
+    // add/remove conflict for this property
     // -------------------------
+    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
+// -------------------------
+CALL {
     WITH diff_node, node_map
-    CALL {
-        WITH diff_node, node_map
-        UNWIND node_map.relationships as node_relationship
-        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
-        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/remove conflict for this relationship element
-        // -------------------------
-        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
-        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
-        // -------------------------
-        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
-        )
-    }
+    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
+UNWIND node_map.relationships as node_relationship
+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
+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/remove conflict for this relationship element
+// -------------------------
+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
+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
+// -------------------------
+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"
@@ -409,47 +428,34 @@ class EnrichedNodesLinkQuery(Query):
     type = QueryType.WRITE
     insert_return = False
 
-    def __init__(self, enriched_diffs: EnrichedDiffs, **kwargs: Any) -> None:
+    def __init__(self, diff_root_uuid: str, diff_nodes: Iterable[EnrichedDiffNode], **kwargs: Any) -> None:
         super().__init__(**kwargs)
-        self.enriched_diffs = enriched_diffs
+        self.diff_root_uuid = diff_root_uuid
+        self.diff_nodes = diff_nodes
 
     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:
-                parent_links_list.extend(self._build_node_parent_links(enriched_node=node, root_uuid=diff_root.uuid))
-        self.params = {"node_links_list": parent_links_list}
+        parent_node_map: dict[str, dict[str, str]] = {}
+        for diff_node in self.diff_nodes:
+            if diff_node.uuid not in parent_node_map:
+                parent_node_map[diff_node.uuid] = {}
+            for relationship in diff_node.relationships:
+                for parent_node in relationship.nodes:
+                    parent_node_map[diff_node.uuid][relationship.name] = parent_node.uuid
+        self.params = {"root_uuid": self.diff_root_uuid, "parent_node_map": parent_node_map}
         query = """
-UNWIND $node_links_list AS node_link_details
-WITH
-    node_link_details.root_uuid AS root_uuid,
-    node_link_details.parent_uuid AS parent_uuid,
-    node_link_details.child_uuid AS child_uuid,
-    node_link_details.relationship_name AS relationship_name
+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 root_uuid, parent_uuid, child_uuid, relationship_name
-    MATCH (diff_root {uuid: root_uuid})
+    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
+    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
     MATCH (diff_root)-[:DIFF_HAS_NODE]->(parent_node:DiffNode {uuid: parent_uuid})
-        -[:DIFF_HAS_RELATIONSHIP]->(diff_rel_group:DiffRelationship {name: relationship_name})
-    MATCH (diff_root)-[:DIFF_HAS_NODE]->(child_node:DiffNode {uuid: child_uuid})
-    MERGE (diff_rel_group)-[:DIFF_HAS_NODE]->(child_node)
+    MERGE (diff_rel_group)-[:DIFF_HAS_NODE]->(parent_node)
 }
         """
         self.add_to_query(query)
-
-    def _build_node_parent_links(self, enriched_node: EnrichedDiffNode, root_uuid: str) -> list[dict[str, str]]:
-        if not enriched_node.relationships:
-            return []
-        parent_links = []
-        for relationship in enriched_node.relationships:
-            for child_node in relationship.nodes:
-                parent_links.append(
-                    {
-                        "parent_uuid": enriched_node.uuid,
-                        "relationship_name": relationship.name,
-                        "child_uuid": child_node.uuid,
-                        "root_uuid": root_uuid,
-                    }
-                )
-                parent_links.extend(self._build_node_parent_links(enriched_node=child_node, root_uuid=root_uuid))
-        return parent_links

infrahub/core/diff/query/summary_counts_enricher.py

@@ -6,10 +6,10 @@ from infrahub.database import InfrahubDatabase
 from ..model.path import TrackingId
 
 
-class DiffSummaryCountsEnricherQuery(Query):
-    """Update summary counters for a given diff"""
+class DiffFieldsSummaryCountsEnricherQuery(Query):
+    """Update summary counters for the attributes and relationshipsin in a diff"""
 
-    name = "diff_summary_count_enricher"
+    name = "diff_fields_summary_count_enricher"
     type = QueryType.WRITE
     insert_return = False
 
@@ -23,7 +23,9 @@ class DiffSummaryCountsEnricherQuery(Query):
     ) -> 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`")
+            raise ValueError(
+                "DiffFieldsSummaryCountsEnricherQuery 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
@@ -138,6 +140,51 @@ CALL {
         SET dr.num_removed = num_removed
     }
 }
+        """
+        self.add_to_query(query)
+
+
+class DiffNodesSummaryCountsEnricherQuery(Query):
+    """Update summary counters for the nodes and root in a diff"""
+
+    name = "diff_nodes_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(
+                "DiffNodesSummaryCountsEnricherQuery 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
 // ----------------------
 // handle node count updates
 // ----------------------

infrahub/core/diff/query_parser.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 from infrahub.core.constants import (
@@ -99,7 +99,7 @@ class DiffPropertyIntermediate:
         return self._ordered_values
 
     @property
-    def earliest_diff_value(self) -> Optional[DiffValueIntermediate]:
+    def earliest_diff_value(self) -> DiffValueIntermediate | None:
         ordered_values = self.get_ordered_values_asc()
         if not ordered_values:
             return None
@@ -461,7 +461,7 @@ class DiffQueryParser:
         diff_branch: Branch,
         schema_manager: SchemaManager,
         from_time: Timestamp,
-        to_time: Optional[Timestamp] = None,
+        to_time: Timestamp | None = None,
         previous_node_field_specifiers: dict[str, set[str]] | None = None,
     ) -> None:
         self.base_branch_name = base_branch.name
@@ -733,7 +733,7 @@ class DiffQueryParser:
                 base_property_set = base_diff_relationship.properties_by_db_id.get(db_id)
                 if not base_property_set:
                     continue
-                base_diff_property_by_type: dict[DatabaseEdgeType, Optional[DiffRelationshipPropertyIntermediate]] = {
+                base_diff_property_by_type: dict[DatabaseEdgeType, DiffRelationshipPropertyIntermediate | None] = {
                     DatabaseEdgeType(p.property_type): None for p in property_set
                 }
                 base_diff_property_by_type[DatabaseEdgeType.IS_RELATED] = None