infrahub-server 1.1.7__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/core/diff/query/merge.py

@@ -28,7 +28,7 @@ class DiffMergeQuery(Query):
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "node_diff_dicts": self.node_diff_dicts,
             "at": self.at.to_string(),
@@ -339,7 +339,7 @@ class DiffMergePropertiesQuery(Query):
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "property_diff_dicts": self.property_diff_dicts,
             "at": self.at.to_string(),
@@ -514,7 +514,7 @@ class DiffMergeRollbackQuery(Query):
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "at": self.at.to_string(),
             "target_branch": self.target_branch.name,

infrahub/core/diff/query/merge_tracking_id.py

@@ -15,7 +15,7 @@ class EnrichedDiffMergedTrackingIdQuery(Query):
         super().__init__(**kwargs)
         self.tracking_ids = tracking_ids
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"tracking_ids": [t_id.serialize() for t_id in self.tracking_ids]}
         query = """
         MATCH (d_root:DiffRoot)

infrahub/core/diff/query/roots_metadata.py

@@ -29,7 +29,7 @@ class EnrichedDiffRootsMetadataQuery(Query):
         self.to_time = to_time
         self.tracking_id = tracking_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "diff_branch_names": self.diff_branch_names,
             "base_branch_names": self.base_branch_names,

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
@@ -25,7 +25,7 @@ class EnrichedDiffRootsUpsertQuery(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
         self.params = self._build_diff_root_params(enriched_diffs=self.enriched_diffs)
         query = """
 UNWIND $diff_root_list AS diff_root_map
@@ -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
@@ -77,38 +78,63 @@ 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
-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:
-        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}
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        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
@@ -31,7 +33,7 @@ class DiffSummaryCountsEnricherQuery(Query):
             raise RuntimeError("tracking_id or diff_id is required")
         self.node_uuids = node_uuids
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    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,
@@ -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/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,

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})

infrahub/core/diff/repository/deserializer.py

@@ -18,10 +18,12 @@ from ..model.path import (
     EnrichedDiffSingleRelationship,
     deserialize_tracking_id,
 )
+from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
 
 
 class EnrichedDiffDeserializer:
-    def __init__(self) -> None:
+    def __init__(self, parent_adder: DiffParentNodeAdder) -> None:
+        self.parent_adder = parent_adder
         self._diff_root_map: dict[str, EnrichedDiffRoot] = {}
         self._diff_node_map: dict[tuple[str, str], EnrichedDiffNode] = {}
         self._diff_node_attr_map: dict[tuple[str, str, str], EnrichedDiffAttribute] = {}
@@ -127,14 +129,15 @@ class EnrichedDiffDeserializer:
 
     def _deserialize_parents(self) -> None:
         for enriched_root, node_path_tuples in self._parents_path_map.items():
+            self.parent_adder.initialize(enriched_diff_root=enriched_root)
             for node_uuid, parents_path in node_path_tuples:
                 # Remove the node itself from the path
                 parents_path_slice = parents_path.nodes[1:]
 
                 # TODO Ensure the list is even
                 current_node_uuid = node_uuid
-                for rel, parent in zip(parents_path_slice[::2], parents_path_slice[1::2]):
-                    enriched_root.add_parent(
+                for rel, parent in zip(parents_path_slice[::2], parents_path_slice[1::2], strict=False):
+                    parent_request = ParentNodeAddRequest(
                         node_id=current_node_uuid,
                         parent_id=parent.get("uuid"),
                         parent_kind=parent.get("kind"),
@@ -144,6 +147,7 @@ class EnrichedDiffDeserializer:
                         parent_rel_cardinality=RelationshipCardinality(rel.get("cardinality")),
                         parent_rel_label=rel.get("label"),
                     )
+                    self.parent_adder.add_parent(parent_request=parent_request)
                     current_node_uuid = parent.get("uuid")
 
     @classmethod
@@ -164,6 +168,7 @@ class EnrichedDiffDeserializer:
     def build_diff_root_metadata(cls, root_node: Neo4jNode) -> EnrichedDiffRootMetadata:
         from_time = Timestamp(str(root_node.get("from_time")))
         to_time = Timestamp(str(root_node.get("to_time")))
+        partner_uuid = cls._get_str_or_none_property_value(node=root_node, property_name="partner_uuid")
         tracking_id_str = str(root_node.get("tracking_id"))
         tracking_id = deserialize_tracking_id(tracking_id_str=tracking_id_str)
         return EnrichedDiffRootMetadata(
@@ -172,7 +177,7 @@ class EnrichedDiffDeserializer:
             from_time=from_time,
             to_time=to_time,
             uuid=str(root_node.get("uuid")),
-            partner_uuid=str(root_node.get("partner_uuid")),
+            partner_uuid=partner_uuid,
             tracking_id=tracking_id,
             num_added=int(root_node.get("num_added", 0)),
             num_updated=int(root_node.get("num_updated", 0)),