infrahub-server 1.2.11__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/core/diff/query/save.py

@@ -30,8 +30,7 @@ class EnrichedDiffRootsUpsertQuery(Query):
         query = """
 UNWIND $diff_root_list AS diff_root_map
 WITH diff_root_map
-CALL {
-    WITH diff_root_map
+CALL (diff_root_map) {
     MERGE (diff_root:DiffRoot {uuid: diff_root_map.uuid})
     SET diff_root.base_branch = diff_root_map.base_branch
     SET diff_root.diff_branch = diff_root_map.diff_branch
@@ -43,8 +42,7 @@ CALL {
 WITH DISTINCT diff_root AS diff_root
 WITH collect(diff_root) AS diff_roots
 WHERE SIZE(diff_roots) = 2
-CALL {
-    WITH diff_roots
+CALL (diff_roots) {
     WITH diff_roots[0] AS base_diff_node, diff_roots[1] AS branch_diff_node
     MERGE (base_diff_node)-[:DIFF_HAS_PARTNER]-(branch_diff_node)
     SET (base_diff_node).partner_uuid = (branch_diff_node).uuid
@@ -80,6 +78,7 @@ class EnrichedNodeBatchCreateQuery(Query):
 
     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
@@ -98,7 +97,7 @@ SET
     diff_node.is_node_kind_migration = node_map.node_properties.is_node_kind_migration,
     diff_node.path_identifier = node_map.node_properties.path_identifier
 WITH root_uuid, node_map, diff_node, has_node_conflict
-CALL {
+CALL (diff_node) {
     // -------------------------
     // delete parent-child relationships for included nodes, they will be added in EnrichedNodesLinkQuery
     // -------------------------
@@ -107,94 +106,104 @@ CALL {
     DELETE parent_rel
 }
 OPTIONAL MATCH (diff_node)-[:DIFF_HAS_CONFLICT]->(current_node_conflict:DiffConflict)
-CALL {
+CALL (diff_node, current_node_conflict, has_node_conflict) {
     // -------------------------
     // create a node-level conflict, if necessary
     // -------------------------
     WITH diff_node, current_node_conflict, has_node_conflict
-    WITH diff_node, current_node_conflict, has_node_conflict
     WHERE current_node_conflict IS NULL AND has_node_conflict = TRUE
     CREATE (diff_node)-[:DIFF_HAS_CONFLICT]->(:DiffConflict)
 }
-CALL {
+CALL (current_node_conflict, has_node_conflict) {
     // -------------------------
     // delete a node-level conflict, if necessary
     // -------------------------
     WITH current_node_conflict, has_node_conflict
-    WITH current_node_conflict, has_node_conflict
     WHERE current_node_conflict IS NOT NULL AND has_node_conflict = FALSE
     DETACH DELETE current_node_conflict
 }
 WITH root_uuid, node_map, diff_node, has_node_conflict, node_map.conflict_params AS node_conflict_params
-CALL {
+CALL (diff_node, has_node_conflict, node_conflict_params) {
     // -------------------------
     // set the properties of the node-level conflict, if necessary
     // -------------------------
     WITH diff_node, has_node_conflict, node_conflict_params
-    WITH diff_node, has_node_conflict, node_conflict_params
     WHERE has_node_conflict = TRUE
     OPTIONAL MATCH (diff_node)-[:DIFF_HAS_CONFLICT]->(node_conflict:DiffConflict)
     SET node_conflict = node_conflict_params
 }
-CALL {
-    // -------------------------
-    // 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
-    // -------------------------
+// -------------------------
+// resetting the UNWIND and starting over here reduces memory usage
+// -------------------------
+WITH root_uuid LIMIT 1
+UNWIND $node_details_list AS node_details
+WITH
+    node_details.root_uuid AS root_uuid,
+    node_details.node_map AS node_map,
+    toString(node_details.node_map.node_properties.uuid) AS node_uuid,
+    node_details.node_map.node_properties.db_id AS node_db_id
+MATCH (:DiffRoot {uuid: root_uuid})-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_uuid, db_id: node_db_id})
+WITH diff_node, node_map, %(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
+// -------------------------
+WITH DISTINCT diff_node, node_map
+CALL (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
+    // remove stale properties for this attribute
     // -------------------------
-    WITH diff_attribute, node_attribute
+    WITH diff_attribute, node_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
     // -------------------------
-    // remove stale properties for this attribute
+    // set attribute property values
     // -------------------------
-    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
-    }
+    WITH DISTINCT diff_attribute, node_attribute
     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 |
+    CALL (has_prop_conflict, current_attr_prop_conflict) {
+        WITH has_prop_conflict, current_attr_prop_conflict
+        WHERE has_prop_conflict = FALSE AND current_attr_prop_conflict IS NOT NULL
         DETACH DELETE current_attr_prop_conflict
-    )
-    FOREACH (i in CASE WHEN has_prop_conflict = TRUE THEN [1] ELSE [] END |
+    }
+    CALL (has_prop_conflict, diff_attr_prop, attr_property) {
+        WITH has_prop_conflict
+        WHERE has_prop_conflict = TRUE
         MERGE (diff_attr_prop)-[:DIFF_HAS_CONFLICT]->(diff_attr_prop_conflict:DiffConflict)
         SET diff_attr_prop_conflict = attr_property.conflict_params
-    )
+    }
 }
 // -------------------------
+// resetting the UNWIND and starting over here reduces memory usage
+// -------------------------
+WITH 1 AS resetting LIMIT 1
+UNWIND $node_details_list AS node_details
+WITH
+    node_details.root_uuid AS root_uuid,
+    node_details.node_map AS node_map,
+    toString(node_details.node_map.node_properties.uuid) AS node_uuid,
+    node_details.node_map.node_properties.db_id AS node_db_id
+MATCH (:DiffRoot {uuid: root_uuid})-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid: node_uuid, db_id: node_db_id})
+// -------------------------
 // remove stale relationships for this node
 // -------------------------
-CALL {
-    WITH diff_node, node_map
-    WITH diff_node, %(rel_name_list_comp)s AS rel_names
+CALL (diff_node, node_map) {
+    WITH %(rel_name_list_comp)s AS rel_names
     OPTIONAL MATCH (diff_node)-[:DIFF_HAS_RELATIONSHIP]->(rel_to_delete:DiffRelationship)
     WHERE NOT (rel_to_delete.name IN rel_names)
     OPTIONAL MATCH (rel_to_delete)-[*..8]->(next_to_delete)
@@ -212,9 +221,8 @@ SET diff_relationship = node_relationship.node_properties
 // remove stale elements for this relationship group
 // -------------------------
 WITH diff_relationship, node_relationship
-CALL {
-    WITH diff_relationship, node_relationship
-    WITH diff_relationship, %(rel_peers_list_comp)s AS rel_peers
+CALL (diff_relationship, node_relationship) {
+    WITH %(rel_peers_list_comp)s AS rel_peers
     OPTIONAL MATCH (diff_relationship)-[:DIFF_HAS_ELEMENT]->(element_to_delete:DiffRelationshipElement)
     WHERE NOT (element_to_delete.peer_id IN rel_peers)
     OPTIONAL MATCH (element_to_delete)-[*..6]->(next_to_delete)
@@ -236,20 +244,23 @@ 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 |
+CALL (has_element_conflict, current_element_conflict) {
+    WITH has_element_conflict
+    WHERE has_element_conflict = FALSE
     DETACH DELETE current_element_conflict
-)
-FOREACH (i in CASE WHEN has_element_conflict = TRUE THEN [1] ELSE [] END |
+}
+CALL (has_element_conflict, diff_relationship_element, node_single_relationship) {
+    WITH has_element_conflict
+    WHERE has_element_conflict = TRUE
     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
+CALL (diff_relationship_element, node_single_relationship) {
+    WITH %(element_props_list_comp)s AS element_props
     OPTIONAL MATCH (diff_relationship_element)-[:DIFF_HAS_PROPERTY]->(property_to_delete:DiffProperty)
     WHERE NOT (property_to_delete.property_type IN element_props)
     OPTIONAL MATCH (property_to_delete)-[*..4]->(next_to_delete)
@@ -271,13 +282,18 @@ 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 |
+
+CALL (has_property_conflict, diff_relationship_property_conflict) {
+    WITH has_property_conflict
+    WHERE has_property_conflict = FALSE
     DETACH DELETE diff_relationship_property_conflict
-)
-FOREACH (i in CASE WHEN has_property_conflict = TRUE THEN [1] ELSE [] END |
+}
+CALL (has_property_conflict, diff_relationship_property, node_relationship_property) {
+    WITH has_property_conflict
+    WHERE has_property_conflict = TRUE
     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"
@@ -451,10 +467,9 @@ WITH keys($parent_node_map) AS child_node_uuids
 MATCH (diff_root:DiffRoot {uuid: $root_uuid})
 MATCH (diff_root)-[:DIFF_HAS_NODE]->(child_node:DiffNode)
 WHERE child_node.uuid IN child_node_uuids
-CALL {
-    WITH diff_root, child_node
-    WITH diff_root, child_node, $parent_node_map[child_node.uuid] AS sub_map
-    WITH diff_root, child_node, sub_map, keys(sub_map) AS relationship_names
+CALL (diff_root, child_node) {
+    WITH $parent_node_map[child_node.uuid] AS sub_map
+    WITH sub_map, keys(sub_map) AS relationship_names
     MATCH (child_node)-[:DIFF_HAS_RELATIONSHIP]->(diff_rel_group:DiffRelationship)
     WHERE diff_rel_group.name IN relationship_names
     WITH diff_root, diff_rel_group, toString(sub_map[diff_rel_group.name]) AS parent_uuid

infrahub/core/diff/query/summary_counts_enricher.py

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

infrahub/core/diff/query/time_range_query.py

@@ -37,7 +37,6 @@ class EnrichedDiffTimeRangeQuery(Query):
             "from_time": self.from_time.to_string(),
             "to_time": self.to_time.to_string(),
         }
-        # ruff: noqa: E501
         query = """
         // get the roots of all diffs in the query
         MATCH (diff_root:DiffRoot)

infrahub/core/diff/repository/repository.py

@@ -377,6 +377,10 @@ class DiffRepository:
         await query.execute(db=self.db)
         return query.get_summary()
 
+    async def delete_all_diff_roots(self) -> None:
+        query = await EnrichedDiffDeleteQuery.init(db=self.db)
+        await query.execute(db=self.db)
+
     async def delete_diff_roots(self, diff_root_uuids: list[str]) -> None:
         query = await EnrichedDiffDeleteQuery.init(db=self.db, enriched_diff_root_uuids=diff_root_uuids)
         await query.execute(db=self.db)

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 28
+GRAPH_VERSION = 30

infrahub/core/manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import copy
 from functools import reduce
 from typing import TYPE_CHECKING, Any, Iterable, Literal, TypeVar, overload
 
@@ -1339,22 +1340,24 @@ class NodeManager:
         nodes: list[Node],
         branch: Branch | str | None = None,
         at: Timestamp | str | None = None,
+        cascade_delete: bool = True,
     ) -> list[Node]:
         """Returns list of deleted nodes because of cascading deletes"""
         branch = await registry.get_branch(branch=branch, db=db)
-        node_delete_validator = NodeDeleteValidator(db=db, branch=branch)
-        ids_to_delete = await node_delete_validator.get_ids_to_delete(nodes=nodes, at=at)
-        node_ids = {node.get_id() for node in nodes}
-        missing_ids_to_delete = ids_to_delete - node_ids
-        if missing_ids_to_delete:
-            node_map = await cls.get_many(db=db, ids=list(missing_ids_to_delete), branch=branch, at=at)
-            nodes += list(node_map.values())
-        deleted_nodes = []
-        for node in nodes:
+        nodes_to_delete = copy(nodes)
+        if cascade_delete:
+            node_delete_validator = NodeDeleteValidator(db=db, branch=branch)
+            ids_to_delete = await node_delete_validator.get_ids_to_delete(nodes=nodes, at=at)
+            node_ids = {node.get_id() for node in nodes}
+            missing_ids_to_delete = ids_to_delete - node_ids
+            if missing_ids_to_delete:
+                node_map = await cls.get_many(db=db, ids=list(missing_ids_to_delete), branch=branch, at=at)
+                nodes_to_delete += list(node_map.values())
+
+        for node in nodes_to_delete:
             await node.delete(db=db, at=at)
-            deleted_nodes.append(node)
 
-        return deleted_nodes
+        return nodes_to_delete
 
 
 def _get_cardinality_one_identifiers_by_kind(

infrahub/core/migrations/graph/__init__.py

@@ -29,6 +29,9 @@ from .m024_missing_hierarchy_backfill import Migration024
 from .m025_uniqueness_nulls import Migration025
 from .m026_0000_prefix_fix import Migration026
 from .m027_delete_isolated_nodes import Migration027
+from .m028_delete_diffs import Migration028
+from .m029_duplicates_cleanup import Migration029
+from .m030_illegal_edges import Migration030
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -63,6 +66,9 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration025,
     Migration026,
     Migration027,
+    Migration028,
+    Migration029,
+    Migration030,
 ]
 
 

infrahub/core/migrations/graph/m003_relationship_parent_optional.py

@@ -26,8 +26,7 @@ class Migration003Query01(Query):
         query = """
         MATCH path = (av2:AttributeValue)-[:HAS_VALUE]-(:Attribute {name: "optional"})-[:HAS_ATTRIBUTE]-(n:SchemaRelationship)-[:HAS_ATTRIBUTE]-(:Attribute {name: "kind"})-[:HAS_VALUE]-(av1:AttributeValue)
         WHERE av1.value = "Parent" AND av2.value = true AND all(r IN relationships(path) WHERE ( %(filters)s ))
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path22 = (av22:AttributeValue)-[r22:HAS_VALUE]-(a2:Attribute {name: "optional"})-[:HAS_ATTRIBUTE]-(n:SchemaRelationship)-[:HAS_ATTRIBUTE]-(:Attribute {name:"kind"})-[:HAS_VALUE]-(av11:AttributeValue)
             WHERE av11.value = "Parent" AND av22.value = true AND all(r IN relationships(path22) WHERE ( %(filters)s ))
             RETURN av22 as av2_sub, r22, a2, path22 as path2

infrahub/core/migrations/graph/m012_convert_account_generic.py

@@ -61,7 +61,7 @@ class Migration012RenameTypeAttributeData(AttributeRenameQuery):
     def render_match(self) -> str:
         query = """
         // Find all the active nodes
-        CALL {
+        CALL () {
             MATCH (node:%(node_kind)s)
             WHERE exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $prev_attr.name }))
                 AND NOT exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $new_attr.name }))

infrahub/core/migrations/graph/m013_convert_git_password_credential.py

@@ -77,7 +77,6 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
 
         self.params["rel_identifier"] = "gitrepository__credential"
 
-        # ruff: noqa: E501
         query = """
         // --------------------------------
         // Identify the git repositories to convert
@@ -98,8 +97,7 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
         // --------------------------------
         MATCH (git_repo)-[:HAS_ATTRIBUTE]-(git_attr_name:Attribute)-[:HAS_VALUE]->(git_name_value:AttributeValue)
         WHERE git_attr_name.name = "name"
-        CALL {
-            WITH git_repo
+        CALL (git_repo) {
             MATCH path1 = (git_repo)-[r1:HAS_ATTRIBUTE]-(git_attr_name2:Attribute)-[r2:HAS_VALUE]->(git_name_value2:AttributeValue)
             WHERE git_attr_name2.name = "name"
               AND all(r IN relationships(path1) WHERE %(filters)s)
@@ -195,7 +193,6 @@ class Migration013ConvertCoreRepositoryWithoutCred(Query):
 
         self.params["current_time"] = self.at.to_string()
 
-        # ruff: noqa: E501
         query = """
         // --------------------------------
         // Identify the git repositories to convert
@@ -204,8 +201,7 @@ class Migration013ConvertCoreRepositoryWithoutCred(Query):
         WHERE a.name in ["username", "password"]
             AND av.value = "NULL"
             AND all(r IN relationships(path) WHERE %(filters)s AND r.status = "active")
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(filters)s
             RETURN node as n1, r as r1

infrahub/core/migrations/graph/m015_diff_format_update.py

@@ -31,6 +31,5 @@ class Migration015(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_roots_metadata()
-        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        await diff_repo.delete_all_diff_roots()
         return MigrationResult()

infrahub/core/migrations/graph/m016_diff_delete_bug_fix.py

@@ -31,6 +31,5 @@ class Migration016(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_roots_metadata()
-        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        await diff_repo.delete_all_diff_roots()
         return MigrationResult()