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

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
@@ -1487,7 +1469,7 @@ class NodeGetHierarchyQuery(Query):
 
         clean_filters = extract_field_filters(field_name=self.direction.value, filters=self.filters)
 
-        if clean_filters and "id" in clean_filters or "ids" in clean_filters:
+        if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:
             where_clause.append("peer.uuid IN $peer_ids")
             self.params["peer_ids"] = clean_filters.get("ids", [])
             if clean_filters.get("id", None):
@@ -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

@@ -217,8 +217,7 @@ class RelationshipQuery(Query):
         )
         source_query_match = """
             MATCH (s:Node { uuid: $source_id })
-            CALL {
-                WITH s
+            CALL (s) {
                 MATCH (s)-[r:IS_PART_OF]->(:Root)
                 WHERE %(source_filter)s
                 RETURN r.status = "active" AS s_is_active
@@ -246,8 +245,7 @@ class RelationshipQuery(Query):
             )
             destination_query_match = """
             MATCH (d:Node { uuid: $destination_id })
-            CALL {
-                WITH d
+            CALL (d) {
                 MATCH (d)-[r:IS_PART_OF]->(:Root)
                 WHERE %(destination_filter)s
                 RETURN r.status = "active" AS d_is_active
@@ -524,8 +522,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 +533,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 +544,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 +555,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 +650,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
@@ -683,7 +676,7 @@ class RelationshipGetPeerQuery(Query):
         where_clause = ['all(r IN rels WHERE r.status = "active")']
         clean_filters = extract_field_filters(field_name=self.schema.name, filters=self.filters)
 
-        if clean_filters and "id" in clean_filters or "ids" in clean_filters:
+        if (clean_filters and "id" in clean_filters) or "ids" in clean_filters:
             where_clause.append("peer.uuid IN $peer_ids")
             self.params["peer_ids"] = clean_filters.get("ids", [])
             if clean_filters.get("id", None):
@@ -726,22 +719,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 +748,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 +789,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 +928,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 +991,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
@@ -1048,7 +1035,7 @@ class RelationshipDeleteAllQuery(Query):
         self.node_id = node_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
+    async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:
         self.params["source_id"] = kwargs["node_id"]
         self.params["branch"] = self.branch.name
 
@@ -1082,8 +1069,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 +1089,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 +1108,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 +1177,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

infrahub/core/query/resource_manager.py

@@ -220,8 +220,7 @@ class NumberPoolGetUsed(Query):
 
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })
-        CALL {
-            WITH pool
+        CALL (pool) {
             MATCH (pool)-[res:IS_RESERVED]->(av:AttributeValue)<-[hv:HAS_VALUE]-(attr:Attribute)
             WHERE
                 attr.name = $attribute_name

infrahub/core/query/standard_node.py

@@ -3,28 +3,42 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.query import Query, QueryType
+from infrahub.exceptions import InitializationError
 
 if TYPE_CHECKING:
+    from uuid import UUID
+
     from infrahub.core.node.standard import StandardNode
     from infrahub.database import InfrahubDatabase
 
 
 class StandardNodeQuery(Query):
     def __init__(
-        self, node: StandardNode = None, node_id: str | None = None, node_db_id: int | None = None, **kwargs: Any
-    ):
-        self.node = node
+        self,
+        node: StandardNode | None = None,
+        node_id: UUID | None = None,
+        node_db_id: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._node = node
         self.node_id = node_id
         self.node_db_id = node_db_id
 
-        if not self.node_id and self.node:
+        if not self.node_id and self._node:
             self.node_id = self.node.uuid
 
-        if not self.node_db_id and self.node:
+        if not self.node_db_id and self._node:
             self.node_db_id = self.node.id
 
         super().__init__(**kwargs)
 
+    @property
+    def node(self) -> StandardNode:
+        if self._node:
+            return self._node
+
+        raise InitializationError("The query is not initialized with a node")
+
 
 class RootNodeCreateQuery(StandardNodeQuery):
     name = "standard_node_create"

infrahub/core/query/subquery.py

@@ -61,7 +61,7 @@ async def build_subquery_filter(
     where_str = " AND ".join(field_where)
     branch_level_str = "reduce(br_lvl = 0, r in relationships(path) | br_lvl + r.branch_level)"
     froms_str = db.render_list_comprehension(items="relationships(path)", item_name="from")
-    to_return = f"{node_alias} AS {prefix}"
+    to_return = f"{prefix}"
     with_extra = ""
     final_with_extra = ""
     is_isnull = filter_name == "isnull"
@@ -82,7 +82,6 @@ async def build_subquery_filter(
         elif field is not None and field.is_attribute:
             is_active_filter = "(latest_node_details[2]).value = 'NULL'"
     query = f"""
-    WITH {node_alias}
     {match} path = {filter_str}
     WHERE {where_str}
     WITH
@@ -94,7 +93,7 @@ async def build_subquery_filter(
     ORDER BY branch_level DESC, froms[-1] DESC, froms[-2] DESC
     WITH head(collect([is_active, {node_alias}{with_extra}])) AS latest_node_details
     WHERE {is_active_filter}
-    WITH latest_node_details[1] AS {node_alias}{final_with_extra}
+    WITH latest_node_details[1] AS {prefix}{final_with_extra}
     RETURN {to_return}
     """
     return query, params, prefix
@@ -174,7 +173,6 @@ async def build_subquery_order(
         to_return_str_parts.append(f"CASE WHEN is_active = TRUE THEN {expression} ELSE NULL END AS {alias}")
     to_return_str = ", ".join(to_return_str_parts)
     query = f"""
-    WITH {node_alias}
     OPTIONAL MATCH path = {filter_str}
     WHERE {where_str}
     WITH {with_str_to_alias}

infrahub/core/relationship/constraints/count.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.constants import RelationshipCardinality, RelationshipDirection
+from infrahub.core.node import Node
 from infrahub.core.query.relationship import RelationshipCountPerNodeQuery
 from infrahub.core.schema import MainSchemaTypes
 from infrahub.database import InfrahubDatabase
@@ -25,7 +26,7 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
         self.db = db
         self.branch = branch
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:  # noqa: ARG002
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         branch = await registry.get_branch(db=self.db) if not self.branch else self.branch
 
         # NOTE adding resolve here because we need to retrieve the real ID
@@ -63,7 +64,7 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
 
         query = await RelationshipCountPerNodeQuery.init(
             db=self.db,
-            node_ids=[node.uuid for node in nodes_to_validate],
+            node_ids=[n.uuid for n in nodes_to_validate],
             identifier=relm.schema.identifier,
             direction=relm.schema.direction.neighbor_direction,
             branch=branch,
@@ -74,14 +75,14 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
         # Need to adjust the number based on what we will add / remove
         #  +1 for max_count
         #  -1 for min_count
-        for node in nodes_to_validate:
-            if node.max_count and count_per_peer[node.uuid] + 1 > node.max_count:
+        for node_to_validate in nodes_to_validate:
+            if node_to_validate.max_count and count_per_peer[node_to_validate.uuid] + 1 > node_to_validate.max_count:
                 raise ValidationError(
-                    f"Node {node.uuid} has {count_per_peer[node.uuid] + 1} peers "
-                    f"for {relm.schema.identifier}, maximum of {node.max_count} allowed",
+                    f"Node {node_to_validate.uuid} has {count_per_peer[node_to_validate.uuid] + 1} peers "
+                    f"for {relm.schema.identifier}, maximum of {node_to_validate.max_count} allowed",
                 )
-            if node.min_count and count_per_peer[node.uuid] - 1 < node.min_count:
+            if node_to_validate.min_count and count_per_peer[node_to_validate.uuid] - 1 < node_to_validate.min_count:
                 raise ValidationError(
-                    f"Node {node.uuid} has {count_per_peer[node.uuid] - 1} peers "
-                    f"for {relm.schema.identifier}, no fewer than {node.min_count} allowed",
+                    f"Node {node_to_validate.uuid} has {count_per_peer[node_to_validate.uuid] - 1} peers "
+                    f"for {relm.schema.identifier}, no fewer than {node_to_validate.min_count} allowed",
                 )

infrahub/core/relationship/constraints/interface.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 
+from infrahub.core.node import Node
 from infrahub.core.schema import MainSchemaTypes
 
 from ..model import RelationshipManager
@@ -7,4 +8,4 @@ from ..model import RelationshipManager
 
 class RelationshipManagerConstraintInterface(ABC):
     @abstractmethod
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None: ...
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None: ...

infrahub/core/relationship/constraints/peer_kind.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.node import Node
 from infrahub.core.query.node import NodeListGetInfoQuery
 from infrahub.core.schema import MainSchemaTypes
 from infrahub.core.schema.generic_schema import GenericSchema
@@ -26,7 +27,7 @@ class RelationshipPeerKindConstraint(RelationshipManagerConstraintInterface):
         self.db = db
         self.branch = branch
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:  # noqa: ARG002
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         branch = await registry.get_branch(db=self.db) if not self.branch else self.branch
         peer_schema = registry.schema.get(name=relm.schema.peer, branch=branch, duplicate=False)
         if isinstance(peer_schema, GenericSchema):