infrahub-server 1.2.12__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
@@ -99,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
     // -------------------------
@@ -108,31 +106,28 @@ 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
@@ -158,8 +153,7 @@ DETACH DELETE attr_to_delete
 // add attributes for this node
 // -------------------------
 WITH DISTINCT diff_node, node_map
-CALL {
-    WITH 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
@@ -182,15 +176,13 @@ CALL {
     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
-    CALL {
-        WITH has_prop_conflict, current_attr_prop_conflict
+    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
     }
-    CALL {
-        WITH has_prop_conflict, diff_attr_prop, attr_property
-        WITH has_prop_conflict, diff_attr_prop, attr_property
+    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
@@ -210,9 +202,8 @@ MATCH (:DiffRoot {uuid: root_uuid})-[:DIFF_HAS_NODE]->(diff_node:DiffNode {uuid:
 // -------------------------
 // remove stale relationships for this node
 // -------------------------
-CALL {
-    WITH diff_node, node_map
-    WITH diff_node, node_map, %(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)
@@ -230,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, node_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)
@@ -254,15 +244,13 @@ 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
-CALL {
-    WITH has_element_conflict, current_element_conflict
-    WITH has_element_conflict, current_element_conflict
+CALL (has_element_conflict, current_element_conflict) {
+    WITH has_element_conflict
     WHERE has_element_conflict = FALSE
     DETACH DELETE current_element_conflict
 }
-CALL {
-    WITH has_element_conflict, diff_relationship_element, node_single_relationship
-    WITH has_element_conflict, diff_relationship_element, node_single_relationship
+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
@@ -271,9 +259,8 @@ CALL {
 // 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, node_single_relationship, %(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)
@@ -295,15 +282,14 @@ 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
-CALL {
-    WITH has_property_conflict, diff_relationship_property_conflict
-    WITH has_property_conflict, diff_relationship_property_conflict
+
+CALL (has_property_conflict, diff_relationship_property_conflict) {
+    WITH has_property_conflict
     WHERE has_property_conflict = FALSE
     DETACH DELETE diff_relationship_property_conflict
 }
-CALL {
-    WITH has_property_conflict, diff_relationship_property, node_relationship_property
-    WITH has_property_conflict, diff_relationship_property, node_relationship_property
+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
@@ -481,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/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/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()

infrahub/core/migrations/graph/m019_restore_rels_to_time.py

@@ -97,8 +97,7 @@ class DeleteNodesRelsQuery(Query):
         // - on deleted edge branch
         // - or on any branch and deleted node is agnostic
         // - or deleted node is aware and rel is agnostic
-        CALL {
-            WITH rel, deleted_edge
+        CALL (rel, deleted_edge) {
             OPTIONAL MATCH (rel)-[peer_active_edge {status: "active"}]-(peer_1)
             WHERE (peer_active_edge.branch = deleted_edge.branch OR (rel.branch_support <> $branch_agnostic AND deleted_edge.branch = $global_branch))
             AND peer_active_edge.to IS NULL
@@ -160,62 +159,52 @@ class DeleteNodesRelsQuery(Query):
         // Below CALL subqueries are called once for each rel-peer_2 pair for which we want to create a deleted edge.
         // Note that with current infrahub relationships edges design, only one of this CALL should be matched per pair.
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:IS_RELATED]->(peer_2)
             MERGE (rel)-[:IS_RELATED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:IS_PROTECTED]->(peer_2)
             MERGE (rel)-[:IS_PROTECTED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:IS_VISIBLE]->(peer_2)
             MERGE (rel)-[:IS_VISIBLE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:HAS_OWNER]->(peer_2)
             MERGE (rel)-[:HAS_OWNER {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:HAS_SOURCE]->(peer_2)
             MERGE (rel)-[:HAS_SOURCE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:IS_RELATED]-(peer_2)
             MERGE (rel)<-[:IS_RELATED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:IS_PROTECTED]-(peer_2)
             MERGE (rel)<-[:IS_PROTECTED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:IS_VISIBLE]-(peer_2)
             MERGE (rel)<-[:IS_VISIBLE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:HAS_OWNER]-(peer_2)
             MERGE (rel)<-[:HAS_OWNER {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:HAS_SOURCE]-(peer_2)
             MERGE (rel)<-[:HAS_SOURCE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }

infrahub/core/migrations/graph/m020_duplicate_edges.py

@@ -33,8 +33,7 @@ WHERE num_duplicate_edges > 1
 // -------------------
 WITH DISTINCT a, branch, branch_level, status, from, to, attr_val, attr_default
 WITH attr_val, attr_default, collect([a, branch, branch_level, status, from, to]) AS details_list
-CALL {
-    WITH attr_val, attr_default
+CALL (attr_val, attr_default) {
     MATCH (av:AttributeValue {value: attr_val, is_default: attr_default})
     RETURN av AS the_one_av
     ORDER by %(id_func)s(av) ASC
@@ -53,11 +52,10 @@ WITH a, branch, status, from, to, attr_val, attr_default, %(id_func)s(fresh_e) A
 // -------------------
 // get the identical edges for a given set of Attribute node, edge properties, AttributeValue.value
 // -------------------
-CALL {
+CALL (a, branch, status, from, to, attr_val, attr_default, e_id_to_keep) {
     // -------------------
     // delete the duplicate edges a given set of Attribute node, edge properties, AttributeValue.value
     // -------------------
-    WITH a, branch, status, from, to, attr_val, attr_default, e_id_to_keep
     MATCH (a)-[e:HAS_VALUE]->(av:AttributeValue {value: attr_val, is_default: attr_default})
     WHERE %(id_func)s(e) <> e_id_to_keep
     AND e.branch = branch AND e.status = status AND e.from = from
@@ -99,8 +97,7 @@ WITH DISTINCT a, branch, branch_level, status, from, to, b
 CREATE (a)-[fresh_e:%(edge_type)s {branch: branch, branch_level: branch_level, status: status, from: from}]->(b)
 SET fresh_e.to = to
 WITH a, branch, status, from, to, b, %(id_func)s(fresh_e) AS e_id_to_keep
-CALL {
-    WITH a, branch, status, from, to, b, e_id_to_keep
+CALL (a, branch, status, from, to, b, e_id_to_keep) {
     MATCH (a)-[e:%(edge_type)s]->(b)
     WHERE %(id_func)s(e) <> e_id_to_keep
     AND e.branch = branch AND e.status = status AND e.from = from

infrahub/core/migrations/graph/m021_missing_hierarchy_merge.py

@@ -24,8 +24,7 @@ class SetMissingHierarchyQuery(Query):
         WITH r.default_branch AS default_branch
         MATCH (n:Node)-[main_e:IS_RELATED {branch: default_branch}]-(rel:Relationship)
         WHERE main_e.hierarchy IS NULL
-        CALL {
-            WITH n, main_e, rel
+        CALL (n, main_e, rel) {
             MATCH (n)-[branch_e:IS_RELATED]-(rel)
             WHERE branch_e.hierarchy IS NOT NULL
             AND branch_e.branch <> main_e.branch

infrahub/core/migrations/graph/m023_deduplicate_cardinality_one_relationships.py

@@ -52,7 +52,7 @@ class DedupCardinalityOneRelsQuery(Query):
         # of a one-to-many BIDIR relationship.
         query = """
 
-        CALL {
+        CALL () {
             MATCH (rel_node: Relationship)-[edge:IS_RELATED]->(n: Node)<-[edge_2:IS_RELATED]-(rel_node_2: Relationship {name: rel_node.name})
             WHERE rel_node.name in $rel_one_identifiers_inbound[n.kind]
                 AND edge.branch = edge_2.branch
@@ -64,7 +64,7 @@ class DedupCardinalityOneRelsQuery(Query):
             DETACH DELETE rel_node
         }
 
-        CALL {
+        CALL () {
             MATCH (rel_node_3: Relationship)<-[edge_3:IS_RELATED]-(n: Node)-[edge_4:IS_RELATED]->(rel_node_4: Relationship {name: rel_node_3.name})
             WHERE rel_node_3.name in $rel_one_identifiers_outbound[n.kind]
                 AND edge_3.branch = edge_4.branch