infrahub-server 1.2.10__py3-none-any.whl → 1.3.0a0__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
@@ -98,7 +96,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,43 +105,38 @@ 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 {
+CALL (diff_node, node_map) {
     // -------------------------
     // 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
+    CALL (diff_node, node_map) {
+        WITH %(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)
@@ -163,9 +156,8 @@ CALL {
     // -------------------------
     // remove stale properties for this attribute
     // -------------------------
-    CALL {
-        WITH diff_attribute, node_attribute
-        WITH diff_attribute, %(attr_props_list_comp)s AS prop_types
+    CALL (diff_attribute, node_attribute) {
+        WITH %(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)
@@ -192,9 +184,8 @@ CALL {
 // -------------------------
 // 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 +203,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)
@@ -247,9 +237,8 @@ FOREACH (i in CASE WHEN has_element_conflict = TRUE THEN [1] ELSE [] END |
 // 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)
@@ -451,10 +440,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_parser.py

@@ -526,7 +526,11 @@ class DiffQueryParser:
         return self._current_node_field_specifiers
 
     def read_result(self, query_result: QueryResult) -> None:
-        path = query_result.get_path(label="diff_path")
+        try:
+            path = query_result.get_path(label="diff_path")
+        except ValueError:
+            # the path was null, so nothing to read
+            return
         database_path = DatabasePath.from_cypher_path(cypher_path=path)
         self._parse_path(database_path=database_path)
         self._current_node_field_specifiers = None

infrahub/core/diff/tasks.py

@@ -20,7 +20,7 @@ log = get_logger()
 async def update_diff(model: RequestDiffUpdate, service: InfrahubServices) -> None:
     await add_tags(branches=[model.branch_name])
 
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=False) as db:
         component_registry = get_component_registry()
         base_branch = await registry.get_branch(db=db, branch=registry.default_branch)
         diff_branch = await registry.get_branch(db=db, branch=model.branch_name)
@@ -40,7 +40,7 @@ async def update_diff(model: RequestDiffUpdate, service: InfrahubServices) -> No
 async def refresh_diff(branch_name: str, diff_id: str, service: InfrahubServices) -> None:
     await add_tags(branches=[branch_name])
 
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=False) as db:
         component_registry = get_component_registry()
         base_branch = await registry.get_branch(db=db, branch=registry.default_branch)
         diff_branch = await registry.get_branch(db=db, branch=branch_name)
@@ -53,7 +53,7 @@ async def refresh_diff(branch_name: str, diff_id: str, service: InfrahubServices
 async def refresh_diff_all(branch_name: str, context: InfrahubContext, service: InfrahubServices) -> None:
     await add_tags(branches=[branch_name])
 
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=True) as db:
         component_registry = get_component_registry()
         default_branch = registry.get_branch_from_registry()
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)

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/m013_convert_git_password_credential.py

@@ -98,8 +98,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)
@@ -204,8 +203,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/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/m024_missing_hierarchy_backfill.py

@@ -39,8 +39,7 @@ class BackfillMissingHierarchyQuery(Query):
         MATCH (rel:Relationship {name: "parent__child"})-[e:IS_RELATED]-(n:Node)
         WHERE e.hierarchy IS NULL
         WITH DISTINCT rel, n, default_branch
-        CALL {
-            WITH rel, n, default_branch
+        CALL (rel, n, default_branch) {
             MATCH (rel)-[e:IS_RELATED {branch: default_branch}]-(n)
             RETURN e
             ORDER BY e.from DESC

infrahub/core/migrations/query/attribute_add.py

@@ -61,8 +61,7 @@ class AttributeAddQuery(Query):
         MERGE (is_visible_value:Boolean { value: $is_visible_default })
         WITH av, is_protected_value, is_visible_value
         MATCH p = (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH (root:Root)<-[r1:IS_PART_OF]-(n)
             OPTIONAL MATCH (n)-[r2:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name })
             WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))

infrahub/core/migrations/query/attribute_rename.py

@@ -126,8 +126,7 @@ class AttributeRenameQuery(Query):
 
         add_uuid = db.render_uuid_generation(node_label="new_attr", node_attr="uuid")
         query = """
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -137,8 +136,7 @@ class AttributeRenameQuery(Query):
         WITH n1 as active_node, r1 as rb
         WHERE rb.status = "active"
         // Find all the attributes that need to be updated
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH (active_node)-[r:HAS_ATTRIBUTE]-(attr:Attribute { name: $prev_attr.name })
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as r1, attr as attr1
@@ -151,8 +149,7 @@ class AttributeRenameQuery(Query):
         %(add_uuid)s
         WITH active_attr, new_attr
         MATCH (active_attr)-[]-(peer)
-        CALL {
-            WITH active_attr, peer
+        CALL (active_attr, peer) {
             MATCH (active_attr)-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_attr as a1, r as r1, peer as p1

infrahub/core/migrations/query/delete_element_in_schema.py

@@ -116,8 +116,7 @@ class DeleteElementInSchemaQuery(Query):
 
         # ruff: noqa: E501
         query = """
-        CALL {
-            WITH attr_node
+        CALL (attr_node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(attr_node)
             WHERE %(branch_filter)s
             RETURN attr_node as n1, r as r1
@@ -130,8 +129,7 @@ class DeleteElementInSchemaQuery(Query):
 
         // Process Outbound Relationship
         MATCH (element_to_delete)-[]->(peer)
-        CALL {
-            WITH element_to_delete, peer
+        CALL (element_to_delete, peer) {
             MATCH (element_to_delete)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN element_to_delete as n1, r as rel_outband1, peer as p1
@@ -150,8 +148,7 @@ class DeleteElementInSchemaQuery(Query):
         WITH DISTINCT(element_to_delete) AS element_to_delete
         // Process Inbound Relationship
         MATCH (element_to_delete)<-[]-(peer)
-        CALL {
-            WITH element_to_delete, peer
+        CALL (element_to_delete, peer) {
             MATCH (element_to_delete)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN element_to_delete as n1, r as rel_inband1, peer as p1