infrahub-server 1.2.10__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/query/diff.py

@@ -121,10 +121,9 @@ class DiffCalculationQuery(DiffQuery):
 
     previous_base_path_query = """
 WITH DISTINCT diff_path AS diff_path, has_more_data
-CALL {
-    WITH diff_path
-    WITH diff_path, nodes(diff_path) AS d_nodes, relationships(diff_path) AS d_rels
-    WITH diff_path, d_rels[0] AS r_root, d_nodes[1] AS n, d_rels[1] AS r_node, d_nodes[2] AS attr_rel, d_rels[2] AS r_prop
+CALL (diff_path) {
+    WITH nodes(diff_path) AS d_nodes, relationships(diff_path) AS d_rels
+    WITH d_rels[0] AS r_root, d_nodes[1] AS n, d_rels[1] AS r_node, d_nodes[2] AS attr_rel, d_rels[2] AS r_prop
     // -------------------------------------
     // add base branch paths before branched_from, if they exist
     // -------------------------------------
@@ -158,10 +157,9 @@ CALL {
 WITH diff_path, latest_base_path, has_more_data
 UNWIND [diff_path, latest_base_path] AS penultimate_path
 WITH DISTINCT penultimate_path, has_more_data
-CALL {
-    WITH penultimate_path
-    WITH penultimate_path, nodes(penultimate_path) AS d_nodes, relationships(penultimate_path) AS d_rels
-    WITH penultimate_path, d_rels[0] AS r_root, d_nodes[1] AS n, d_rels[1] AS r_node, d_nodes[2] AS attr_rel, d_rels[2] AS r_prop
+CALL (penultimate_path) {
+    WITH nodes(penultimate_path) AS d_nodes, relationships(penultimate_path) AS d_rels
+    WITH d_rels[0] AS r_root, d_nodes[1] AS n, d_rels[1] AS r_node, d_nodes[2] AS attr_rel, d_rels[2] AS r_prop
     // -------------------------------------
     // Add peer-side of any relationships to get the peer's ID
     // -------------------------------------
@@ -201,6 +199,13 @@ WITH reduce(
     diff_rel_paths = [], item IN [penultimate_path, peer_path] |
     CASE WHEN item IS NULL THEN diff_rel_paths ELSE diff_rel_paths + [item] END
 ) AS diff_rel_paths, has_more_data
+// ------------------------
+// make sure we still include has_more_data if diff_rel_paths is empty
+// ------------------------
+WITH CASE
+    WHEN diff_rel_paths = [] THEN [NULL]
+    ELSE diff_rel_paths
+END AS diff_rel_paths, has_more_data
     """
 
     def get_previous_base_path_query(self, db: InfrahubDatabase) -> str:
@@ -292,8 +297,7 @@ WITH one_result[0] AS p, one_result[1] AS q, one_result[2] AS diff_rel, one_resu
 // -------------------------------------
 // Exclude nodes added then removed on branch within timeframe
 // -------------------------------------
-CALL {
-    WITH p, q, row_from_time
+CALL (p, q, row_from_time) {
     OPTIONAL MATCH (q)<-[is_part_of:IS_PART_OF {branch: $branch_name}]-(p)
     WHERE row_from_time <= is_part_of.from < $to_time
     WITH DISTINCT is_part_of.status AS rel_status
@@ -305,8 +309,7 @@ WHERE intra_branch_update = FALSE
 // -------------------------------------
 // Get every path on this branch under each node
 // -------------------------------------
-CALL {
-    WITH p, q, diff_rel, row_from_time
+CALL (p, q, diff_rel, row_from_time) {
     OPTIONAL MATCH path = (
         (q)<-[top_diff_rel:IS_PART_OF]-(p)-[r_node]-(node)-[r_prop]-(prop)
     )
@@ -333,12 +336,11 @@ CALL {
         p.uuid IS NULL OR prop.uuid IS NULL OR p.uuid <> prop.uuid
         OR type(r_node) <> "IS_RELATED" OR type(r_prop) <> "IS_RELATED"
     )
-    WITH path, p, node, prop, r_prop, r_node, type(r_node) AS rel_type, row_from_time
+    WITH path, node, prop, r_prop, r_node, type(r_node) AS rel_type, row_from_time
     // -------------------------------------
     // Exclude attributes/relationships added then removed on branch within timeframe
     // -------------------------------------
-    CALL {
-        WITH p, rel_type, node, row_from_time
+    CALL (p, rel_type, node, row_from_time) {
         OPTIONAL MATCH (p)-[rel_to_check {branch: $branch_name}]-(node)
         WHERE row_from_time <= rel_to_check.from < $to_time
         AND type(rel_to_check) = rel_type
@@ -477,8 +479,7 @@ END AS row_from_time
 // Exclude attributes/relationship under nodes deleted on this branch in the timeframe
 // because those were all handled above at the node level
 // -------------------------------------
-CALL {
-    WITH root, p, row_from_time
+CALL (root, p, row_from_time) {
     OPTIONAL MATCH (root)<-[r_root_deleted:IS_PART_OF {branch: $branch_name}]-(p)
     WHERE row_from_time <= r_root_deleted.from < $to_time
     WITH r_root_deleted
@@ -492,8 +493,7 @@ WHERE node_deleted = FALSE
 // Exclude relationships added and deleted within the timeframe
 // -------------------------------------
 WITH root, r_root, p, diff_rel, q, has_more_data, row_from_time, type(diff_rel) AS rel_type
-CALL {
-    WITH p, rel_type, q, row_from_time
+CALL (p, rel_type, q, row_from_time) {
     OPTIONAL MATCH (p)-[rel_to_check {branch: $branch_name}]-(q)
     WHERE row_from_time <= rel_to_check.from < $to_time
     AND type(rel_to_check) = rel_type
@@ -506,8 +506,7 @@ WHERE intra_branch_update = FALSE
 // -------------------------------------
 // Get every path on this branch under each attribute/relationship
 // -------------------------------------
-CALL {
-    WITH root, r_root, p, diff_rel, q
+CALL (root, r_root, p, diff_rel, q) {
     OPTIONAL MATCH path = (
         (root:Root)<-[mid_r_root:IS_PART_OF]-(p)-[mid_diff_rel]-(q)-[r_prop]-(prop)
     )
@@ -542,8 +541,7 @@ CALL {
 // Exclude properties added and deleted within the timeframe
 // -------------------------------------
 WITH q, nodes(latest_prop_path)[3] AS prop, type(relationships(latest_prop_path)[2]) AS rel_type, latest_prop_path, has_more_data, row_from_time
-CALL {
-    WITH q, rel_type, prop, row_from_time
+CALL (q, rel_type, prop, row_from_time) {
     OPTIONAL MATCH (q)-[rel_to_check {branch: $branch_name}]-(prop)
     WHERE row_from_time <= rel_to_check.from < $to_time
     AND type(rel_to_check) = rel_type
@@ -710,14 +708,12 @@ ORDER BY
     r_node.from DESC,
     r_root.from DESC
 WITH n, p, row_from_time, diff_rel, diff_rel_path, has_more_data
-CALL {
+CALL (n, p, row_from_time){
     // -------------------------------------
     // Exclude properties under nodes and attributes/relationships deleted
     // on this branch in the timeframe because those were all handled above
     // -------------------------------------
-    WITH n, p, row_from_time
-    CALL {
-        WITH n, row_from_time
+    CALL (n, row_from_time) {
         OPTIONAL MATCH (root:Root)<-[r_root_deleted:IS_PART_OF {branch: $branch_name}]-(n)
         WHERE r_root_deleted.from < $to_time
         WITH r_root_deleted
@@ -725,9 +721,8 @@ CALL {
         LIMIT 1
         RETURN COALESCE(r_root_deleted.status = "deleted", FALSE) AS node_deleted
     }
-    WITH n, p, row_from_time, node_deleted
-    CALL {
-        WITH n, p, row_from_time
+    WITH node_deleted
+    CALL (n, p, row_from_time) {
         OPTIONAL MATCH (n)-[r_node_deleted {branch: $branch_name}]-(p)
         WHERE row_from_time <= r_node_deleted.from < $to_time
         AND type(r_node_deleted) IN ["HAS_ATTRIBUTE", "IS_RELATED"]
@@ -796,8 +791,7 @@ AND (
 // -------------------------------------
 // Ignore node created and deleted on this branch
 // -------------------------------------
-CALL {
-    WITH n
+CALL (n) {
     OPTIONAL MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n)
     WITH diff_rel
     ORDER BY diff_rel.from ASC

infrahub/core/query/ipam.py

@@ -80,8 +80,7 @@ class IPPrefixSubnetFetch(Query):
         // First match on IPNAMESPACE
         MATCH (ns:%(ns_label)s)
         WHERE ns.uuid = $ns_id
-        CALL {
-            WITH ns
+        CALL (ns) {
             MATCH (ns)-[r:IS_PART_OF]-(root:Root)
             WHERE %(branch_filter)s
             RETURN ns as ns1, r as r1
@@ -104,8 +103,7 @@ class IPPrefixSubnetFetch(Query):
         // ---
         // FIND ALL CHILDREN OF THESE PREFIXES
         // ---
-        CALL {
-            WITH all_prefixes
+        CALL (all_prefixes) {
             UNWIND all_prefixes as prefix
             OPTIONAL MATCH (prefix)<-[:IS_RELATED]-(ch_rel:Relationship)<-[:IS_RELATED]-(children:BuiltinIPPrefix)
             WHERE ch_rel.name = "parent__child"
@@ -171,8 +169,7 @@ class IPPrefixIPAddressFetch(Query):
         // First match on IPNAMESPACE
         MATCH (ns:%(ns_label)s)
         WHERE ns.uuid = $ns_id
-        CALL {
-            WITH ns
+        CALL (ns) {
             MATCH (ns)-[r:IS_PART_OF]-(root:Root)
             WHERE %(branch_filter)s
             RETURN ns as ns1, r as r1
@@ -271,8 +268,7 @@ class IPPrefixUtilization(Query):
         query = f"""
         MATCH (pfx:Node)
         WHERE pfx.uuid IN $ids
-        CALL {{
-            WITH pfx
+        CALL (pfx) {{
             MATCH (pfx)-[r_rel1:IS_RELATED]-(rl:Relationship)<-[r_rel2:IS_RELATED]-(child:Node)
             WHERE rl.name IN [{", ".join(self.allocated_kinds_rel)}]
             AND any(l IN labels(child) WHERE l IN [{", ".join(self.allocated_kinds)}])
@@ -425,8 +421,7 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         // Get prefix node's current parent, if it exists
         // ------------------
-        CALL {
-            WITH ip_node
+        CALL (ip_node) {
             OPTIONAL MATCH parent_prefix_path = (ip_node)-[r1:IS_RELATED]->(:Relationship {name: "parent__child"})-[r2:IS_RELATED]->(current_parent:%(ip_prefix_kind)s)
             WHERE all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
             RETURN current_parent, (r1.status = "active" AND r2.status = "active") AS parent_is_active
@@ -444,8 +439,7 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         // Get prefix node's current prefix children, if any exist
         // ------------------
-        CALL {
-            WITH ip_node
+        CALL (ip_node) {
             OPTIONAL MATCH child_prefix_path = (ip_node)<-[r1:IS_RELATED]-(:Relationship {name: "parent__child"})<-[r2:IS_RELATED]-(current_prefix_child:%(ip_prefix_kind)s)
             WHERE all(r IN relationships(child_prefix_path) WHERE (%(branch_filter)s))
             WITH current_prefix_child, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -457,8 +451,7 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         // Get prefix node's current address children, if any exist
         // ------------------
-        CALL {
-            WITH ip_node
+        CALL (ip_node) {
             OPTIONAL MATCH child_address_path = (ip_node)-[r1:IS_RELATED]-(:Relationship {name: "ip_prefix__ip_address"})-[r2:IS_RELATED]-(current_address_child:%(ip_address_kind)s)
             WHERE all(r IN relationships(child_address_path) WHERE (%(branch_filter)s))
             WITH current_address_child, (r1.status = "active" AND r2.status = "active") AS is_active
@@ -480,8 +473,7 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         // Identify the correct parent, if any, for the prefix node
         // ------------------
-        CALL {
-            WITH ip_namespace
+        CALL (ip_namespace) {
             OPTIONAL MATCH parent_path = (ip_namespace)-[pr1:IS_RELATED {status: "active"}]-(ns_rel:Relationship {name: "ip_namespace__ip_prefix"})
             -[pr2:IS_RELATED {status: "active"}]-(maybe_new_parent:%(ip_prefix_kind)s)
             -[har:HAS_ATTRIBUTE]->(:Attribute {name: "prefix"})
@@ -517,9 +509,8 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         // Identify the correct children, if any, for the prefix node
         // ------------------
-        CALL {
+        CALL (ip_namespace, ip_node) {
             // Get ALL possible children for the prefix node
-            WITH ip_namespace, ip_node
             OPTIONAL MATCH child_path = (
                  (ip_namespace)-[r1:IS_RELATED]
                  -(ns_rel:Relationship)-[r2:IS_RELATED]
@@ -558,12 +549,11 @@ class IPPrefixReconcileQuery(Query):
         WITH ip_namespace, ip_node, current_parent, current_children, new_parent, collect([maybe_new_child, latest_mnc_attribute]) AS maybe_children_ips
         WITH ip_namespace, ip_node, current_parent, current_children, new_parent, maybe_children_ips, range(0, size(maybe_children_ips) - 1) AS child_indices
         UNWIND child_indices as ind
-        CALL {
+        CALL (ind, maybe_children_ips) {
             // ------------------
             // Filter all possible children to remove those that have a more-specific parent
             // among the list of all possible children
             // ------------------
-            WITH ind, maybe_children_ips
             WITH ind, maybe_children_ips AS ips
             RETURN REDUCE(
                 has_more_specific_parent = FALSE, potential_parent IN ips |

infrahub/core/query/node.py

@@ -207,12 +207,11 @@ class NodeCreateAllQuery(NodeQuery):
         attrs_query = """
         WITH distinct n
         UNWIND $attrs AS attr
-        CALL {
-            WITH n, attr
+        CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
             MERGE (av:AttributeValue { value: attr.content.value, is_default: attr.content.is_default })
-            WITH n, attr, av, a
+            WITH av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
@@ -232,13 +231,12 @@ class NodeCreateAllQuery(NodeQuery):
         attrs_iphost_query = """
         WITH distinct n
         UNWIND $attrs_iphost AS attr_iphost
-        CALL {
-            WITH n, attr_iphost
+        CALL (n, attr_iphost) {
             WITH n, attr_iphost AS attr
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
             MERGE (av:AttributeValue:AttributeIPHost { %(iphost_prop)s })
-            WITH n, attr, av, a
+            WITH attr, av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
@@ -259,13 +257,12 @@ class NodeCreateAllQuery(NodeQuery):
         attrs_ipnetwork_query = """
         WITH distinct n
         UNWIND $attrs_ipnetwork AS attr_ipnetwork
-        CALL {
-            WITH n, attr_ipnetwork
+        CALL (n, attr_ipnetwork) {
             WITH n, attr_ipnetwork AS attr
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
             MERGE (av:AttributeValue:AttributeIPNetwork { %(ipnetwork_prop)s })
-            WITH n, attr, av, a
+            WITH attr, av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
@@ -286,8 +283,7 @@ class NodeCreateAllQuery(NodeQuery):
         rels_bidir_query = """
         WITH distinct n
         UNWIND $rels_bidir AS rel
-        CALL {
-            WITH n, rel
+        CALL (n, rel) {
             MERGE (d:Node { uuid: rel.destination_id })
             CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
             CREATE (n)-[:IS_RELATED %(rel_prop)s ]->(rl)
@@ -310,8 +306,7 @@ class NodeCreateAllQuery(NodeQuery):
         rels_out_query = """
         WITH distinct n
         UNWIND $rels_out AS rel_out
-        CALL {
-            WITH n, rel_out
+        CALL (n, rel_out) {
             WITH n, rel_out as rel
             MERGE (d:Node { uuid: rel.destination_id })
             CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
@@ -335,8 +330,7 @@ class NodeCreateAllQuery(NodeQuery):
         rels_in_query = """
         WITH distinct n
         UNWIND $rels_in AS rel_in
-        CALL {
-            WITH n, rel_in
+        CALL (n, rel_in) {
             WITH n, rel_in AS rel
             MERGE (d:Node { uuid: rel.destination_id })
             CREATE (rl:Relationship { uuid: rel.uuid, name: rel.name, branch_support: rel.branch_support })
@@ -424,8 +418,7 @@ class NodeDeleteQuery(NodeQuery):
             node_filter, node_filter_params = self.branch.get_query_filter_path(at=self.at, variable_name="r")
             node_query_match = """
                 MATCH (n:Node { uuid: $uuid })
-                CALL {
-                    WITH n
+                CALL (n) {
                     MATCH (n)-[r:IS_PART_OF]->(:Root)
                     WHERE %(node_filter)s
                     RETURN r.status = "active" AS is_active
@@ -520,8 +513,7 @@ class NodeListGetAttributeQuery(Query):
         self.add_to_query(query)
 
         query = """
-        CALL {
-            WITH n, a
+        CALL (n, a) {
             MATCH (n)-[r:HAS_ATTRIBUTE]-(a:Attribute)
             WHERE %(branch_filter)s
             RETURN n as n1, r as r1, a as a1
@@ -533,8 +525,7 @@ class NodeListGetAttributeQuery(Query):
         WITH n, r1, a
         MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
         WHERE %(branch_filter)s
-        CALL {
-            WITH a, av
+        CALL (a, av) {
             MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
             WHERE %(branch_filter)s
             RETURN a as a1, r as r2, av as av1
@@ -698,14 +689,12 @@ class NodeListGetRelationshipsQuery(Query):
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH (n)<-[:IS_RELATED]-(rel:Relationship)<-[:IS_RELATED]-(peer)
             WHERE ($inbound_identifiers IS NULL OR rel.name in $inbound_identifiers)
             AND n.uuid <> peer.uuid
             WITH DISTINCT n, rel, peer
-            CALL {
-                WITH n, rel, peer
+            CALL (n, rel, peer) {
                 MATCH (n)<-[r:IS_RELATED]-(rel)
                 WHERE (%(filters)s)
                 WITH n, rel, peer, r
@@ -729,8 +718,7 @@ class NodeListGetRelationshipsQuery(Query):
             WHERE ($outbound_identifiers IS NULL OR rel.name in $outbound_identifiers)
             AND n.uuid <> peer.uuid
             WITH DISTINCT n, rel, peer
-            CALL {
-                WITH n, rel, peer
+            CALL (n, rel, peer) {
                 MATCH (n)-[r:IS_RELATED]->(rel)
                 WHERE (%(filters)s)
                 WITH n, rel, peer, r
@@ -754,8 +742,7 @@ class NodeListGetRelationshipsQuery(Query):
             WHERE ($bidirectional_identifiers IS NULL OR rel.name in $bidirectional_identifiers)
             AND n.uuid <> peer.uuid
             WITH DISTINCT n, rel, peer
-            CALL {
-                WITH n, rel, peer
+            CALL (n, rel, peer) {
                 MATCH (n)-[r:IS_RELATED]->(rel)
                 WHERE (%(filters)s)
                 WITH n, rel, peer, r
@@ -849,8 +836,7 @@ class NodeListGetInfoQuery(Query):
         query = """
         MATCH p = (root:Root)<-[:IS_PART_OF]-(n:Node)
         WHERE n.uuid IN $ids
-        CALL {
-            WITH root, n
+        CALL (root, n) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(n:Node)
             WHERE %(branch_filter)s
             RETURN n as n1, r as r1
@@ -1046,8 +1032,7 @@ class NodeGetListQuery(Query):
         if not self.branch.is_default:
             topquery = """
             MATCH (n:%(node_kind)s)
-            CALL {
-                WITH n
+            CALL (n) {
                 MATCH (root:Root)<-[r:IS_PART_OF]-(n)
                 WHERE %(branch_filter)s
                 RETURN r
@@ -1152,7 +1137,7 @@ class NodeGetListQuery(Query):
             )
 
             filter_params.update(subquery_params)
-            filter_query.append("CALL {")
+            filter_query.append("CALL (n) {")
             filter_query.append(subquery)
             filter_query.append("}")
             filter_query.append(f"WITH {with_str}")
@@ -1201,7 +1186,7 @@ class NodeGetListQuery(Query):
             with_str = ", ".join(self._get_tracked_variables())
 
             sort_params.update(subquery_params)
-            sort_query.append("CALL {")
+            sort_query.append("CALL (n) {")
             sort_query.append(subquery)
             sort_query.append("}")
             sort_query.append(f"WITH {with_str}")
@@ -1215,8 +1200,7 @@ class NodeGetListQuery(Query):
         froms_str = db.render_list_comprehension(items="relationships(profile_path)", item_name="from")
         profiles_per_node_query = (
             """
-            CALL {
-                WITH n
+            CALL (n) {
                 OPTIONAL MATCH profile_path = (n)-[:IS_RELATED]->(profile_r:Relationship)<-[:IS_RELATED]-(maybe_profile_n:Node)-[:IS_PART_OF]->(:Root)
                 WHERE profile_r.name = "node__profile"
                 AND all(r in relationships(profile_path) WHERE %(branch_filter)s)
@@ -1234,8 +1218,7 @@ class NodeGetListQuery(Query):
             WITH %(with_str)s, CASE
                 WHEN ordered_is_actives[0] = True THEN maybe_profile_n ELSE NULL
             END AS profile_n
-            CALL {
-                WITH profile_n
+            CALL (profile_n) {
                 OPTIONAL MATCH profile_priority_path = (profile_n)-[pr1:HAS_ATTRIBUTE]->(a:Attribute)-[pr2:HAS_VALUE]->(av:AttributeValue)
                 WHERE a.name = "profile_priority"
                 AND all(r in relationships(profile_priority_path) WHERE %(branch_filter)s and r.status = "active")
@@ -1276,7 +1259,7 @@ class NodeGetListQuery(Query):
             self._track_variable(profile_attr.profile_value_query_variable)
             with_str = ", ".join(self._get_tracked_variables())
 
-            attributes_queries.append("CALL {")
+            attributes_queries.append("CALL (profile_n) {")
             attributes_queries.append(subquery)
             attributes_queries.append("}")
             attributes_queries.append(f"WITH {with_str}")
@@ -1457,17 +1440,16 @@ class NodeGetHierarchyQuery(Query):
         MATCH path = (n:Node { uuid: $uuid } )%(filter)s(peer:Node)
         WHERE $hierarchy IN LABELS(peer) and all(r IN relationships(path) WHERE (%(branch_filter)s))
         WITH n, collect(last(nodes(path))) AS peers_with_duplicates
-        CALL {
-            WITH peers_with_duplicates
+        CALL (peers_with_duplicates) {
             UNWIND peers_with_duplicates AS pwd
             RETURN DISTINCT pwd AS peer
         }
+
         """ % {"filter": filter_str, "branch_filter": branch_filter}
 
         if not self.branch.is_default:
             query += """
-        CALL {
-            WITH n, peer
+        CALL (n, peer) {
             MATCH path = (n)%(filter)s(peer)
             WHERE all(r IN relationships(path) WHERE (%(branch_filter)s))
             WITH %(with_clause)s
@@ -1532,7 +1514,7 @@ class NodeGetHierarchyQuery(Query):
                 [f"{subquery_result_name} as {label}" if label == "peer" else label for label in self.return_labels]
             )
 
-            self.add_subquery(subquery=subquery, with_clause=with_str)
+            self.add_subquery(subquery=subquery, node_alias="peer", with_clause=with_str)
 
         # ----------------------------------------------------------------------------
         # ORDER Results
@@ -1560,7 +1542,7 @@ class NodeGetHierarchyQuery(Query):
                 self.order_by.append(subquery_result_name)
                 self.params.update(subquery_params)
 
-                self.add_subquery(subquery=subquery)
+                self.add_subquery(subquery=subquery, node_alias="peer")
 
                 order_cnt += 1
         else:

infrahub/core/query/relationship.py

@@ -524,8 +524,7 @@ class RelationshipDeleteQuery(RelationshipQuery):
         CREATE (s)%(r1)s(rl)
         CREATE (rl)%(r2)s(d)
         WITH rl
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[edge:IS_VISIBLE]->(visible)
             WHERE %(rel_filter)s AND edge.status = "active"
             WITH rl, edge, visible
@@ -536,8 +535,7 @@ class RelationshipDeleteQuery(RelationshipQuery):
             WHERE edge.branch = $branch
             SET edge.to = $at
         }
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[edge:IS_PROTECTED]->(protected)
             WHERE %(rel_filter)s AND edge.status = "active"
             WITH rl, edge, protected
@@ -548,8 +546,7 @@ class RelationshipDeleteQuery(RelationshipQuery):
             WHERE edge.branch = $branch
             SET edge.to = $at
         }
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[edge:HAS_OWNER]->(owner_node)
             WHERE %(rel_filter)s AND edge.status = "active"
             WITH rl, edge, owner_node
@@ -560,8 +557,7 @@ class RelationshipDeleteQuery(RelationshipQuery):
             WHERE edge.branch = $branch
             SET edge.to = $at
         }
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[edge:HAS_SOURCE]->(source_node)
             WHERE %(rel_filter)s AND edge.status = "active"
             WITH rl, edge, source_node
@@ -656,8 +652,7 @@ class RelationshipGetPeerQuery(Query):
         MATCH (source_node:Node)%(arrow_left_start)s[:IS_RELATED]%(arrow_left_end)s(rl:Relationship { name: $rel_identifier })
         WHERE source_node.uuid IN $source_ids
         WITH DISTINCT source_node, rl
-        CALL {
-            WITH rl, source_node
+        CALL (rl, source_node) {
             MATCH path = (source_node)%(path)s(peer:Node)
             WHERE
                 $source_kind IN LABELS(source_node) AND
@@ -726,22 +721,19 @@ class RelationshipGetPeerQuery(Query):
             with_str = ", ".join(
                 [f"{subquery_result_name} as {label}" if label == "peer" else label for label in self.return_labels]
             )
-            self.add_subquery(subquery=subquery, with_clause=with_str)
-
+            self.add_subquery(subquery=subquery, node_alias="peer", with_clause=with_str)
         # ----------------------------------------------------------------------------
         # QUERY Properties
         # ----------------------------------------------------------------------------
         query = """
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[r:IS_VISIBLE]-(is_visible)
             WHERE %(branch_filter)s
             RETURN r AS rel_is_visible, is_visible
             ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
             LIMIT 1
         }
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[r:IS_PROTECTED]-(is_protected)
             WHERE %(branch_filter)s
             RETURN r AS rel_is_protected, is_protected
@@ -758,8 +750,7 @@ class RelationshipGetPeerQuery(Query):
         # We must query them one by one otherwise the second one won't return
         for node_prop in ["source", "owner"]:
             query = """
-        CALL {
-            WITH rl
+        CALL (rl) {
             OPTIONAL MATCH (rl)-[r:HAS_%(node_prop_type)s]-(%(node_prop)s)
             WHERE %(branch_filter)s
             RETURN r AS rel_%(node_prop)s, %(node_prop)s
@@ -800,7 +791,7 @@ class RelationshipGetPeerQuery(Query):
                 self.order_by.append(subquery_result_name)
                 self.params.update(subquery_params)
 
-                self.add_subquery(subquery=subquery)
+                self.add_subquery(subquery=subquery, node_alias="peer")
 
                 order_cnt += 1
 
@@ -939,8 +930,7 @@ class RelationshipGetByIdentifierQuery(Query):
         query = """
         MATCH (rl:Relationship)
         WHERE rl.name IN $identifiers
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (src:Node)-[r1:IS_RELATED]-(rl:Relationship)-[r2:IS_RELATED]-(dst:Node)
             WHERE (size($full_identifiers) = 0 OR [src.kind, rl.name, dst.kind] in $full_identifiers)
             AND NOT src.namespace IN $excluded_namespaces
@@ -1003,8 +993,7 @@ class RelationshipCountPerNodeQuery(Query):
         query = """
         MATCH (peer_node:Node)%(path)s(rl:Relationship { name: $rel_identifier })
         WHERE peer_node.uuid IN $peer_ids AND %(branch_filter)s
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH path = (peer_node:Node)%(path)s(rl)
             WHERE peer_node.uuid IN $peer_ids AND %(branch_filter)s
             RETURN peer_node as peer, r as r1
@@ -1082,8 +1071,7 @@ class RelationshipDeleteAllQuery(Query):
         for arrow_left, arrow_right in (("<-", "-"), ("-", "->")):
             for edge_type in edge_types:
                 sub_query = """
-                    CALL {
-                        WITH rl
+                    CALL (rl) {
                         MATCH (rl)%(arrow_left)s[active_edge:%(edge_type)s]%(arrow_right)s(n)
                         WHERE %(active_rel_filter)s AND active_edge.status ="active"
                         CREATE (rl)%(arrow_left)s[deleted_edge:%(edge_type)s $rel_prop]%(arrow_right)s(n)
@@ -1103,8 +1091,7 @@ class RelationshipDeleteAllQuery(Query):
 
         # We only want to return uuid/kind of `Node` connected through `IS_RELATED` edges.
         query += """
-        CALL {
-            WITH rl
+        CALL (rl) {
             MATCH (rl)-[active_edge:IS_RELATED]->(n)
             WHERE %(active_rel_filter)s
             WITH rl, active_edge, n
@@ -1123,7 +1110,6 @@ class RelationshipDeleteAllQuery(Query):
                 "outbound" as rel_direction
 
             UNION
-
             WITH rl
             MATCH (rl)<-[active_edge:IS_RELATED]-(n)
             WHERE %(active_rel_filter)s
@@ -1193,3 +1179,40 @@ class RelationshipDeleteAllQuery(Query):
             changelog_mapper.delete_relationship(peer_id=peer_uuid, peer_kind=kind, rel_schema=deleted_rel_schema)
 
         return [changelog_mapper.changelog for changelog_mapper in rel_identifier_to_changelog_mapper.values()]
+
+
+class GetAllPeersIds(Query):
+    """
+    Return all peers ids connected to input node. Some peers can be excluded using `exclude_identifiers`.
+    """
+
+    name = "get_peers_ids"
+    type: QueryType = QueryType.READ
+    insert_return = False
+
+    def __init__(self, node_id: str, exclude_identifiers: list[str], **kwargs):
+        self.node_id = node_id
+        self.exclude_identifiers = exclude_identifiers
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
+        self.params["source_id"] = kwargs["node_id"]
+        self.params["branch"] = self.branch.name
+        self.params["exclude_identifiers"] = self.exclude_identifiers
+
+        active_rel_filter, rel_params = self.branch.get_query_filter_path(
+            at=self.at, variable_name="e1", branch_agnostic=self.branch_agnostic
+        )
+        self.params.update(rel_params)
+
+        query = """
+            MATCH (node:Node { uuid: $source_id })-[e1:IS_RELATED]-(rl:Relationship)-[e2:IS_RELATED]-(peer:Node)
+            WHERE %(active_rel_filter)s AND peer.uuid <> node.uuid AND NOT (rl.name IN $exclude_identifiers)
+            WITH DISTINCT(peer.uuid) as uuid
+            RETURN uuid
+        """ % {"active_rel_filter": active_rel_filter}
+
+        self.add_to_query(query)
+
+    def get_peers_uuids(self) -> list[str]:
+        return [row.data["uuid"] for row in self.results]  # type: ignore