infrahub-server 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

infrahub/core/manager.py

@@ -1229,20 +1229,31 @@ class NodeManager:
         if not prefetch_relationships and not fields:
             return
         cardinality_one_identifiers_by_kind: dict[str, dict[str, RelationshipDirection]] | None = None
-        all_identifiers: list[str] | None = None
+        outbound_identifiers: set[str] | None = None
+        inbound_identifiers: set[str] | None = None
+        bidirectional_identifiers: set[str] | None = None
         if not prefetch_relationships:
             cardinality_one_identifiers_by_kind = _get_cardinality_one_identifiers_by_kind(
                 nodes=nodes_by_id.values(), fields=fields or {}
             )
-            all_identifiers_set: set[str] = set()
+            outbound_identifiers = set()
+            inbound_identifiers = set()
+            bidirectional_identifiers = set()
             for identifier_direction_map in cardinality_one_identifiers_by_kind.values():
-                all_identifiers_set.update(identifier_direction_map.keys())
-            all_identifiers = list(all_identifiers_set)
+                for identifier, direction in identifier_direction_map.items():
+                    if direction is RelationshipDirection.OUTBOUND:
+                        outbound_identifiers.add(identifier)
+                    elif direction is RelationshipDirection.INBOUND:
+                        inbound_identifiers.add(identifier)
+                    elif direction is RelationshipDirection.BIDIR:
+                        bidirectional_identifiers.add(identifier)
 
         query = await NodeListGetRelationshipsQuery.init(
             db=db,
             ids=list(nodes_by_id.keys()),
-            relationship_identifiers=all_identifiers,
+            outbound_identifiers=None if outbound_identifiers is None else list(outbound_identifiers),
+            inbound_identifiers=None if inbound_identifiers is None else list(inbound_identifiers),
+            bidirectional_identifiers=None if bidirectional_identifiers is None else list(bidirectional_identifiers),
             branch=branch,
             at=at,
             branch_agnostic=branch_agnostic,

infrahub/core/migrations/graph/__init__.py

@@ -28,6 +28,7 @@ from .m023_deduplicate_cardinality_one_relationships import Migration023
 from .m024_missing_hierarchy_backfill import Migration024
 from .m025_uniqueness_nulls import Migration025
 from .m026_0000_prefix_fix import Migration026
+from .m027_delete_isolated_nodes import Migration027
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -61,6 +62,7 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration024,
     Migration025,
     Migration026,
+    Migration027,
 ]
 
 

infrahub/core/migrations/graph/m014_remove_index_attr_value.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Sequence
 
+from infrahub.constants.database import IndexType
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.core.query import Query  # noqa: TC001
 from infrahub.database import DatabaseType
-from infrahub.database.constants import IndexType
 from infrahub.database.index import IndexItem
+from infrahub.database.neo4j import IndexManagerNeo4j
 
 from ..shared import GraphMigration
 
@@ -29,13 +30,13 @@ class Migration014(GraphMigration):
         if db.db_type != DatabaseType.NEO4J:
             return result
 
-        async with db.start_transaction() as ts:
-            try:
-                ts.manager.index.init(nodes=[INDEX_TO_DELETE], rels=[])
-                await ts.manager.index.drop()
-            except Exception as exc:
-                result.errors.append(str(exc))
-                return result
+        try:
+            index_manager = IndexManagerNeo4j(db=db)
+            index_manager.init(nodes=[INDEX_TO_DELETE], rels=[])
+            await index_manager.drop()
+        except Exception as exc:
+            result.errors.append(str(exc))
+            return result
 
         return result
 

infrahub/core/migrations/graph/m027_delete_isolated_nodes.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class DeleteIsolatedNodesQuery(Query):
+    name = "delete_isolated_nodes_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+        MATCH p = (s: Node)-[r]-(d)
+        WHERE NOT exists((s)-[:IS_PART_OF]-(:Root))
+        DELETE r
+
+        WITH p
+        UNWIND nodes(p) AS n
+        MATCH (n)
+        WHERE NOT exists((n)--())
+        DELETE n
+        """
+        self.add_to_query(query)
+
+
+class Migration027(GraphMigration):
+    """
+    While deleting a branch containing some allocated nodes from a resource pool, relationship
+    between pool node and resource node might be agnostic (eg: for IPPrefixPool) and incorrectly deleted,
+    resulting in a node still linked to the resource pool but not linked to Root anymore.
+    This query deletes nodes not linked to Root and their relationships (supposed to be agnostic).
+    """
+
+    name: str = "027_deleted_isolated_nodes"
+    minimum_version: int = 26
+    queries: Sequence[type[Query]] = [DeleteIsolatedNodesQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/protocols.py

@@ -478,6 +478,7 @@ class CoreTransformJinja2(CoreTransformation):
 class CoreTransformPython(CoreTransformation):
     file_path: String
     class_name: String
+    convert_query_response: BooleanOptional
 
 
 class CoreUserValidator(CoreValidator):

infrahub/core/query/branch.py

@@ -51,23 +51,33 @@ class DeleteBranchRelationshipsQuery(Query):
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        if config.SETTINGS.database.db_type == config.DatabaseType.MEMGRAPH:
-            query = """
-            MATCH p = (s)-[r]-(d)
-            WHERE r.branch = $branch_name
-            DELETE r
-            """
-        else:
-            query = """
-            MATCH p = (s)-[r]-(d)
-            WHERE r.branch = $branch_name
-            DELETE r
-            WITH *
-            UNWIND nodes(p) AS n
-            MATCH (n)
-            WHERE NOT exists((n)--())
-            DELETE n
-            """
+        query = """
+        MATCH (s)-[r1]-(d)
+        WHERE r1.branch = $branch_name
+        DELETE r1
+
+        WITH collect(DISTINCT s) + collect(DISTINCT d) AS nodes
+
+        // Collect node IDs for filtering
+        WITH nodes, [n in nodes | n.uuid] as nodes_uuids
+
+        // Also delete agnostic relationships that would not have been deleted above
+        MATCH (s2: Node)-[r2]-(d2)
+        WHERE NOT exists((s2)-[:IS_PART_OF]-(:Root))
+        AND s2.uuid IN nodes_uuids
+        DELETE r2
+
+        WITH nodes, collect(DISTINCT s2) + collect(DISTINCT d2) as additional_nodes
+
+        WITH nodes + additional_nodes as nodes
+
+        // Delete nodes that are no longer connected to any other nodes
+        UNWIND nodes AS n
+        WITH DISTINCT n
+        MATCH (n)
+        WHERE NOT exists((n)--())
+        DELETE n
+        """
         self.params["branch_name"] = self.branch_name
         self.add_to_query(query)
 

infrahub/core/query/diff.py

@@ -9,6 +9,7 @@ from infrahub.core.timestamp import Timestamp
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
+    from infrahub.core.diff.model.field_specifiers_map import NodeFieldSpecifierMap
     from infrahub.database import InfrahubDatabase
 
 
@@ -106,8 +107,8 @@ class DiffCalculationQuery(DiffQuery):
         self,
         base_branch: Branch,
         diff_branch_from_time: Timestamp,
-        current_node_field_specifiers: dict[str, set[str]] | None = None,
-        new_node_field_specifiers: dict[str, set[str]] | None = None,
+        current_node_field_specifiers: NodeFieldSpecifierMap | None = None,
+        new_node_field_specifiers: NodeFieldSpecifierMap | None = None,
         **kwargs: Any,
     ):
         self.base_branch = base_branch
@@ -231,10 +232,10 @@ class DiffNodePathsQuery(DiffCalculationQuery):
         self.params.update(params_dict)
         self.params.update(
             {
-                "new_node_ids_list": list(self.new_node_field_specifiers.keys())
+                "new_node_ids_list": self.new_node_field_specifiers.get_uuids_list()
                 if self.new_node_field_specifiers
                 else None,
-                "current_node_ids_list": list(self.current_node_field_specifiers.keys())
+                "current_node_ids_list": self.current_node_field_specifiers.get_uuids_list()
                 if self.current_node_field_specifiers
                 else None,
             }
@@ -371,15 +372,16 @@ class DiffFieldPathsQuery(DiffCalculationQuery):
 
         self.params.update(
             {
-                "current_node_field_specifiers_map": {
-                    node_uuid: list(field_names)
-                    for node_uuid, field_names in self.current_node_field_specifiers.items()
-                }
+                "current_node_ids_list": self.current_node_field_specifiers.get_uuids_list()
+                if self.current_node_field_specifiers
+                else None,
+                "new_node_ids_list": self.new_node_field_specifiers.get_uuids_list()
+                if self.new_node_field_specifiers
+                else None,
+                "current_node_field_specifiers_map": self.current_node_field_specifiers.get_uuid_field_names_map()
                 if self.current_node_field_specifiers is not None
                 else None,
-                "new_node_field_specifiers_map": {
-                    node_uuid: list(field_names) for node_uuid, field_names in self.new_node_field_specifiers.items()
-                }
+                "new_node_field_specifiers_map": self.new_node_field_specifiers.get_uuid_field_names_map()
                 if self.new_node_field_specifiers is not None
                 else None,
             }
@@ -400,16 +402,16 @@ AND (r_root.to IS NULL OR diff_rel.branch <> r_root.branch OR r_root.to >= diff_
 // node ID and field name filtering first pass
 AND (
     (
-        $current_node_field_specifiers_map IS NOT NULL
-        AND $current_node_field_specifiers_map[p.uuid] IS NOT NULL
+        $current_node_ids_list IS NOT NULL
+        AND p.uuid IN $current_node_ids_list
         AND q.name IN $current_node_field_specifiers_map[p.uuid]
     ) OR (
-        $new_node_field_specifiers_map IS NOT NULL
-        AND $new_node_field_specifiers_map[p.uuid] IS NOT NULL
+        $new_node_ids_list IS NOT NULL
+        AND p.uuid IN $new_node_ids_list
         AND q.name IN $new_node_field_specifiers_map[p.uuid]
     ) OR (
-        $current_node_field_specifiers_map IS NULL
-        AND $new_node_field_specifiers_map IS NULL
+        $new_node_ids_list IS NULL
+        AND $current_node_ids_list IS NULL
     )
 )
 // node ID and field name filtering second pass
@@ -417,8 +419,12 @@ AND (
     // time-based filters for nodes already included in the diff or fresh changes
     (
         (
-            ($current_node_field_specifiers_map IS NOT NULL AND q.name IN $current_node_field_specifiers_map[p.uuid])
-            OR ($current_node_field_specifiers_map IS NULL AND $new_node_field_specifiers_map IS NULL)
+            (
+                $current_node_ids_list IS NOT NULL
+                AND p.uuid IN $current_node_ids_list
+                AND q.name IN $current_node_field_specifiers_map[p.uuid]
+            )
+            OR ($current_node_ids_list IS NULL AND $new_node_ids_list IS NULL)
         )
         AND (r_root.from < $from_time OR p.branch_support = $branch_agnostic)
         AND (
@@ -428,7 +434,11 @@ AND (
     )
     // time-based filters for new nodes
     OR (
-        ($new_node_field_specifiers_map IS NOT NULL AND q.name IN $new_node_field_specifiers_map[p.uuid])
+        (
+            $new_node_ids_list IS NOT NULL
+            AND p.uuid IN $new_node_ids_list
+            AND q.name IN $new_node_field_specifiers_map[p.uuid]
+        )
         AND (r_root.from < $branch_from_time OR p.branch_support = $branch_agnostic)
         AND (
             ($branch_from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
@@ -454,7 +464,11 @@ WITH one_result[0] AS root, one_result[1] AS r_root, one_result[2] AS p, one_res
 // Add correct from_time for row
 // -------------------------------------
 WITH root, r_root, p, diff_rel, q, has_more_data, CASE
-    WHEN $new_node_field_specifiers_map IS NOT NULL AND q.name IN $new_node_field_specifiers_map[p.uuid] THEN $branch_from_time
+    WHEN
+        $new_node_ids_list IS NOT NULL
+        AND p.uuid IN $new_node_ids_list
+        AND q.name IN $new_node_field_specifiers_map[p.uuid]
+    THEN $branch_from_time
     ELSE $from_time
 END AS row_from_time
 // -------------------------------------
@@ -554,15 +568,16 @@ class DiffPropertyPathsQuery(DiffCalculationQuery):
 
         self.params.update(
             {
-                "current_node_field_specifiers_map": {
-                    node_uuid: list(field_names)
-                    for node_uuid, field_names in self.current_node_field_specifiers.items()
-                }
+                "current_node_ids_list": self.current_node_field_specifiers.get_uuids_list()
+                if self.current_node_field_specifiers
+                else None,
+                "new_node_ids_list": self.new_node_field_specifiers.get_uuids_list()
+                if self.new_node_field_specifiers
+                else None,
+                "current_node_field_specifiers_map": self.current_node_field_specifiers.get_uuid_field_names_map()
                 if self.current_node_field_specifiers is not None
                 else None,
-                "new_node_field_specifiers_map": {
-                    node_uuid: list(field_names) for node_uuid, field_names in self.new_node_field_specifiers.items()
-                }
+                "new_node_field_specifiers_map": self.new_node_field_specifiers.get_uuid_field_names_map()
                 if self.new_node_field_specifiers is not None
                 else None,
             }
@@ -580,16 +595,16 @@ AND type(r_node) IN ["HAS_ATTRIBUTE", "IS_RELATED"]
 // node ID and field name filtering first pass
 AND (
     (
-        $current_node_field_specifiers_map IS NOT NULL
-        AND $current_node_field_specifiers_map[n.uuid] IS NOT NULL
+        $current_node_ids_list IS NOT NULL
+        AND n.uuid IN $current_node_ids_list
         AND p.name IN $current_node_field_specifiers_map[n.uuid]
     ) OR (
-        $new_node_field_specifiers_map IS NOT NULL
-        AND $new_node_field_specifiers_map[n.uuid] IS NOT NULL
+        $new_node_ids_list IS NOT NULL
+        AND n.uuid IN $new_node_ids_list
         AND p.name IN $new_node_field_specifiers_map[n.uuid]
     ) OR (
-        $current_node_field_specifiers_map IS NULL
-        AND $new_node_field_specifiers_map IS NULL
+        $new_node_ids_list IS NULL
+        AND $current_node_ids_list IS NULL
     )
 )
 // node ID and field name filtering second pass
@@ -597,8 +612,12 @@ AND (
     // time-based filters for nodes already included in the diff or fresh changes
     (
         (
-            ($current_node_field_specifiers_map IS NOT NULL AND p.name IN $current_node_field_specifiers_map[n.uuid])
-            OR ($current_node_field_specifiers_map IS NULL AND $new_node_field_specifiers_map IS NULL)
+            (
+                $current_node_ids_list IS NOT NULL
+                AND n.uuid IN $current_node_ids_list
+                AND p.name IN $current_node_field_specifiers_map[n.uuid]
+            )
+            OR ($current_node_ids_list IS NULL AND $new_node_ids_list IS NULL)
         )
         AND (
             ($from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
@@ -612,7 +631,11 @@ AND (
     )
     // time-based filters for new nodes
     OR (
-        ($new_node_field_specifiers_map IS NOT NULL AND p.name IN $new_node_field_specifiers_map[n.uuid])
+        (
+            $new_node_ids_list IS NOT NULL
+            AND n.uuid IN $new_node_ids_list
+            AND p.name IN $new_node_field_specifiers_map[n.uuid]
+        )
         AND (
             ($branch_from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
             OR ($branch_from_time <= diff_rel.to < $to_time)
@@ -667,7 +690,11 @@ WITH one_result[0] AS diff_rel_path, one_result[1] AS r_root, one_result[2] AS n
 // Add correct from_time for row
 // -------------------------------------
 WITH diff_rel_path, r_root, n, r_node, p, diff_rel, has_more_data, CASE
-    WHEN $new_node_field_specifiers_map IS NOT NULL AND p.name IN $new_node_field_specifiers_map[n.uuid] THEN $branch_from_time
+    WHEN
+        $new_node_ids_list IS NOT NULL
+        AND n.uuid IN $new_node_ids_list
+        AND p.name IN $new_node_field_specifiers_map[n.uuid]
+    THEN $branch_from_time
     ELSE $from_time
 END AS row_from_time
 WITH diff_rel_path, r_root, n, r_node, p, diff_rel, has_more_data, row_from_time

infrahub/core/query/node.py

@@ -92,6 +92,7 @@ class NodeAttributesFromDB:
 class PeerInfo:
     uuid: str
     kind: str
+    labels: frozenset[str]
 
 
 class NodeQuery(Query):
@@ -649,51 +650,118 @@ class NodeListGetRelationshipsQuery(Query):
     type: QueryType = QueryType.READ
     insert_return: bool = False
 
-    def __init__(self, ids: list[str], relationship_identifiers: list[str] | None = None, **kwargs):
+    def __init__(
+        self,
+        ids: list[str],
+        outbound_identifiers: list[str] | None = None,
+        inbound_identifiers: list[str] | None = None,
+        bidirectional_identifiers: list[str] | None = None,
+        **kwargs,
+    ):
         self.ids = ids
-        self.relationship_identifiers = relationship_identifiers
+        self.outbound_identifiers = outbound_identifiers
+        self.inbound_identifiers = inbound_identifiers
+        self.bidirectional_identifiers = bidirectional_identifiers
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
-        self.params["relationship_identifiers"] = self.relationship_identifiers
+        self.params["outbound_identifiers"] = self.outbound_identifiers
+        self.params["inbound_identifiers"] = self.inbound_identifiers
+        self.params["bidirectional_identifiers"] = self.bidirectional_identifiers
 
         rels_filter, rels_params = self.branch.get_query_filter_path(at=self.at, branch_agnostic=self.branch_agnostic)
         self.params.update(rels_params)
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
-        MATCH paths_in = ((n)<-[r1:IS_RELATED]-(rel:Relationship)<-[r2:IS_RELATED]-(peer))
-        WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
-        AND all(r IN relationships(paths_in) WHERE (%(filters)s))
-        AND n.uuid <> peer.uuid
-        RETURN n, rel, peer, r1, r2, "inbound" as direction
-        UNION
-        MATCH (n:Node) WHERE n.uuid IN $ids
-        MATCH paths_out = ((n)-[r1:IS_RELATED]->(rel:Relationship)-[r2:IS_RELATED]->(peer))
-        WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
-        AND all(r IN relationships(paths_out) WHERE (%(filters)s))
-        AND n.uuid <> peer.uuid
-        RETURN n, rel, peer, r1, r2, "outbound" as direction
-        UNION
-        MATCH (n:Node) WHERE n.uuid IN $ids
-        MATCH paths_bidir = ((n)-[r1:IS_RELATED]->(rel:Relationship)<-[r2:IS_RELATED]-(peer))
-        WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
-        AND all(r IN relationships(paths_bidir) WHERE (%(filters)s))
-        AND n.uuid <> peer.uuid
-        RETURN n, rel, peer, r1, r2, "bidirectional" as direction
+        CALL {
+            WITH 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
+                MATCH (n)<-[r:IS_RELATED]-(rel)
+                WHERE (%(filters)s)
+                WITH n, rel, peer, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH n, rel, peer, r AS r1
+                WHERE r1.status = "active"
+                MATCH (rel)<-[r:IS_RELATED]-(peer)
+                WHERE (%(filters)s)
+                WITH r1, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH r1, r AS r2
+                WHERE r2.status = "active"
+                RETURN 1 AS is_active
+            }
+            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "inbound" as direction
+            UNION
+            WITH n
+            MATCH (n)-[:IS_RELATED]->(rel:Relationship)-[:IS_RELATED]->(peer)
+            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
+                MATCH (n)-[r:IS_RELATED]->(rel)
+                WHERE (%(filters)s)
+                WITH n, rel, peer, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH n, rel, peer, r AS r1
+                WHERE r1.status = "active"
+                MATCH (rel)-[r:IS_RELATED]->(peer)
+                WHERE (%(filters)s)
+                WITH r1, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH r1, r AS r2
+                WHERE r2.status = "active"
+                RETURN 1 AS is_active
+            }
+            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "outbound" as direction
+            UNION
+            WITH n
+            MATCH (n)-[:IS_RELATED]->(rel:Relationship)<-[:IS_RELATED]-(peer)
+            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
+                MATCH (n)-[r:IS_RELATED]->(rel)
+                WHERE (%(filters)s)
+                WITH n, rel, peer, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH n, rel, peer, r AS r1
+                WHERE r1.status = "active"
+                MATCH (rel)<-[r:IS_RELATED]-(peer)
+                WHERE (%(filters)s)
+                WITH r1, r
+                ORDER BY r.from DESC
+                LIMIT 1
+                WITH r1, r AS r2
+                WHERE r2.status = "active"
+                RETURN 1 AS is_active
+            }
+            RETURN n.uuid AS n_uuid, rel.name AS rel_name, peer.uuid AS peer_uuid, "bidirectional" as direction
+        }
+        RETURN DISTINCT n_uuid, rel_name, peer_uuid, direction
         """ % {"filters": rels_filter}
-
         self.add_to_query(query)
-
-        self.return_labels = ["n", "rel", "peer", "r1", "r2", "direction"]
+        self.return_labels = ["n_uuid", "rel_name", "peer_uuid", "direction"]
 
     def get_peers_group_by_node(self) -> GroupedPeerNodes:
         gpn = GroupedPeerNodes()
-        for result in self.get_results_group_by(("n", "uuid"), ("rel", "name"), ("peer", "uuid")):
-            node_id = result.get("n").get("uuid")
-            rel_name = result.get("rel").get("name")
-            peer_id = result.get("peer").get("uuid")
+        for result in self.get_results():
+            node_id = result.get("n_uuid")
+            rel_name = result.get("rel_name")
+            peer_id = result.get("peer_uuid")
             direction = str(result.get("direction"))
             direction_enum = {
                 "inbound": RelationshipDirection.INBOUND,
@@ -1338,7 +1406,7 @@ class NodeGetHierarchyQuery(Query):
 
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002,PLR0915
         hierarchy_schema = self.node_schema.get_hierarchy_schema(db=db, branch=self.branch)
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
@@ -1371,6 +1439,10 @@ class NodeGetHierarchyQuery(Query):
             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
             MATCH path = (n)%(filter)s(peer)
@@ -1381,10 +1453,14 @@ class NodeGetHierarchyQuery(Query):
             LIMIT 1
         }
         WITH peer1 as peer, is_active
-        """ % {"filter": filter_str, "branch_filter": branch_filter, "with_clause": with_clause}
+            """ % {"filter": filter_str, "branch_filter": branch_filter, "with_clause": with_clause}
+        else:
+            query += """
+        WITH peer
+            """
 
         self.add_to_query(query)
-        where_clause = ["is_active = TRUE"]
+        where_clause = ["is_active = TRUE"] if not self.branch.is_default else []
 
         clean_filters = extract_field_filters(field_name=self.direction.value, filters=self.filters)
 
@@ -1394,7 +1470,8 @@ class NodeGetHierarchyQuery(Query):
             if clean_filters.get("id", None):
                 self.params["peer_ids"].append(clean_filters.get("id"))
 
-        self.add_to_query("WHERE " + " AND ".join(where_clause))
+        if where_clause:
+            self.add_to_query("WHERE " + " AND ".join(where_clause))
 
         self.return_labels = ["peer"]
 
@@ -1477,4 +1554,5 @@ class NodeGetHierarchyQuery(Query):
             yield PeerInfo(
                 uuid=peer_node.get("uuid"),
                 kind=peer_node.get("kind"),
+                labels=peer_node.labels,
             )

infrahub/core/query/relationship.py

@@ -73,12 +73,21 @@ class RelationshipPeerData:
     source_id: UUID
     """UUID of the Source Node."""
 
+    source_kind: str
+    """Kind of the Source Node."""
+
+    source_labels: frozenset[str]
+    """Labels of the Source Node."""
+
     peer_id: UUID
     """UUID of the Peer Node."""
 
     peer_kind: str
     """Kind of the Peer Node."""
 
+    peer_labels: frozenset[str]
+    """Labels of the Peer Node."""
+
     properties: dict[str, FlagPropertyData | NodePropertyData]
     """UUID of the Relationship Node."""
 
@@ -752,10 +761,15 @@ class RelationshipGetPeerQuery(Query):
     def get_peers(self) -> Generator[RelationshipPeerData, None, None]:
         for result in self.get_results_group_by(("peer", "uuid"), ("source_node", "uuid")):
             rels = result.get("rels")
+            source_node = result.get_node("source_node")
+            peer_node = result.get_node("peer")
             data = RelationshipPeerData(
-                source_id=result.get_node("source_node").get("uuid"),
-                peer_id=result.get_node("peer").get("uuid"),
-                peer_kind=result.get_node("peer").get("kind"),
+                source_id=source_node.get("uuid"),
+                source_kind=source_node.get("kind"),
+                source_labels=source_node.labels,
+                peer_id=peer_node.get("uuid"),
+                peer_kind=peer_node.get("kind"),
+                peer_labels=peer_node.labels,
                 rel_node_db_id=result.get("rl").element_id,
                 rel_node_id=result.get("rl").get("uuid"),
                 updated_at=rels[0]["from"],