infrahub-server 1.2.9rc0__py3-none-any.whl → 1.2.11__py3-none-any.whl

infrahub/core/migrations/graph/m028_delete_diffs.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from infrahub.core import registry
+from infrahub.core.diff.repository.repository import DiffRepository
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.dependencies.registry import build_component_registry, get_component_registry
+from infrahub.log import get_logger
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration028(ArbitraryMigration):
+    """Delete all diffs because of an update to how we store diff information. All diffs will need to be recalculated"""
+
+    name: str = "028_diff_delete_bug_fix_update"
+    minimum_version: int = 27
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+
+        return result
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        default_branch = registry.get_branch_from_registry()
+        build_component_registry()
+        component_registry = get_component_registry()
+        diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
+
+        diff_roots = await diff_repo.get_roots_metadata()
+        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        return MigrationResult()

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -81,11 +81,15 @@ class CoreIPAddressPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int | None = None) -> IPAddressType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             ip_prefix = ipaddress.ip_network(resource.prefix.value)  # type: ignore[attr-defined]
             prefix_length = prefixlen or ip_prefix.prefixlen
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -88,11 +88,15 @@ class CoreIPPrefixPool(Node):
         return node
 
     async def get_next(self, db: InfrahubDatabase, prefixlen: int) -> IPNetworkType:
-        # Measure utilization of all prefixes identified as resources
         resources = await self.resources.get_peers(db=db)  # type: ignore[attr-defined]
         ip_namespace = await self.ip_namespace.get_peer(db=db)  # type: ignore[attr-defined]
 
-        for resource in resources.values():
+        try:
+            weighted_resources = sorted(resources.values(), key=lambda r: r.allocation_weight.value or 0, reverse=True)
+        except AttributeError:
+            weighted_resources = list(resources.values())
+
+        for resource in weighted_resources:
             subnets = await get_subnets(
                 db=db,
                 ip_prefix=ipaddress.ip_network(resource.prefix.value),  # type: ignore[attr-defined]

infrahub/core/protocols.py

@@ -209,6 +209,10 @@ class CoreWebhook(CoreNode):
     validate_certificates: BooleanOptional
 
 
+class CoreWeightedPoolResource(CoreNode):
+    allocation_weight: IntegerOptional
+
+
 class LineageOwner(CoreNode):
     pass
 

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

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Generator
 
 from infrahub import config
-from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType
+from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType, DiffAction, RelationshipStatus
 from infrahub.core.query import Query, QueryType
 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 +108,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
@@ -127,12 +129,13 @@ CALL {
     // add base branch paths before branched_from, if they exist
     // -------------------------------------
     WITH n, attr_rel, r_node, r_prop
+    // 'base_n' instead of 'n' here to get previous value for node with a migrated kind/inheritance
     OPTIONAL MATCH latest_base_path = (:Root)<-[base_r_root:IS_PART_OF {branch: $base_branch_name}]
-        -(n)-[base_r_node {branch: $base_branch_name}]
+        -(base_n {uuid: n.uuid})-[base_r_node {branch: $base_branch_name}]
         -(attr_rel)-[base_r_prop {branch: $base_branch_name}]->(base_prop)
     WHERE type(base_r_node) = type(r_node)
     AND type(base_r_prop) = type(r_prop)
-    AND [%(id_func)s(n), type(base_r_node)] <> [%(id_func)s(base_prop), type(base_r_prop)]
+    AND [%(id_func)s(base_n), type(base_r_node)] <> [%(id_func)s(base_prop), type(base_r_prop)]
     AND all(
         r in relationships(latest_base_path)
         WHERE r.from < $branch_from_time
@@ -142,7 +145,7 @@ CALL {
     // the migration leaves two nodes with the same UUID linked to the same Relationship
     // ------------------------
     AND (
-        n.uuid IS NULL OR base_prop.uuid IS NULL OR n.uuid <> base_prop.uuid
+        base_n.uuid IS NULL OR base_prop.uuid IS NULL OR base_n.uuid <> base_prop.uuid
         OR type(base_r_node) <> "IS_RELATED" OR type(base_r_prop) <> "IS_RELATED"
     )
     WITH latest_base_path, base_r_root, base_r_node, base_r_prop
@@ -198,6 +201,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:
@@ -231,10 +241,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,
             }
@@ -276,7 +286,7 @@ WITH p, q, diff_rel, CASE
     WHEN $new_node_ids_list IS NOT NULL AND p.uuid IN $new_node_ids_list THEN $branch_from_time
     ELSE $from_time
 END AS row_from_time
-ORDER BY p.uuid DESC
+ORDER BY %(id_func)s(p) DESC
 SKIP $offset
 LIMIT $limit
 // -------------------------------------
@@ -313,15 +323,15 @@ CALL {
     AND node.branch_support IN [$branch_aware, $branch_agnostic]
     AND type(r_prop) IN ["IS_VISIBLE", "IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE", "IS_RELATED"]
     AND any(l in labels(prop) WHERE l in ["Boolean", "Node", "AttributeValue"])
-    AND ALL(
-        r in [r_node, r_prop]
-        WHERE r.from < $to_time AND r.branch = top_diff_rel.branch
-    )
     AND (top_diff_rel.to IS NULL OR top_diff_rel.to >= r_node.from)
     AND (r_node.to IS NULL OR r_node.to >= r_prop.from)
     AND [%(id_func)s(p), type(r_node)] <> [%(id_func)s(prop), type(r_prop)]
-    AND top_diff_rel.status = r_node.status
-    AND top_diff_rel.status = r_prop.status
+    AND r_node.from < $to_time
+    AND r_node.branch = top_diff_rel.branch
+    AND r_node.status = top_diff_rel.status
+    AND r_prop.from < $to_time
+    AND r_prop.branch = top_diff_rel.branch
+    AND r_prop.status = top_diff_rel.status
     // ------------------------
     // special handling for nodes that had their kind updated,
     // the migration leaves two nodes with the same UUID linked to the same Relationship
@@ -371,15 +381,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 +411,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 +428,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 +443,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 +473,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 +577,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 +604,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 +621,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 +640,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 +699,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
@@ -690,7 +726,7 @@ CALL {
     CALL {
         WITH n, row_from_time
         OPTIONAL MATCH (root:Root)<-[r_root_deleted:IS_PART_OF {branch: $branch_name}]-(n)
-        WHERE row_from_time <= r_root_deleted.from < $to_time
+        WHERE r_root_deleted.from < $to_time
         WITH r_root_deleted
         ORDER BY r_root_deleted.status DESC
         LIMIT 1
@@ -718,3 +754,85 @@ WITH n, p, type(diff_rel) AS drt, head(collect(diff_rel_path)) AS diff_path, has
         self.add_to_query(self.get_relationship_peer_side_query(db=db))
         self.add_to_query("UNWIND diff_rel_paths AS diff_path")
         self.return_labels = ["DISTINCT diff_path AS diff_path", "has_more_data"]
+
+
+@dataclass
+class MigratedKindNode:
+    uuid: str
+    kind: str
+    db_id: str
+    from_time: Timestamp
+    action: DiffAction
+    has_more_data: bool
+
+
+class DiffMigratedKindNodesQuery(DiffCalculationQuery):
+    name = "diff_migrated_kind_nodes_query"
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        params_dict = self.get_params()
+        self.params.update(params_dict)
+        migrated_kind_nodes_query = """
+// -------------------------------------
+// Identify nodes added/removed on branch in the time frame
+// -------------------------------------
+MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n:Node)
+WHERE (
+    ($from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
+    OR ($from_time <= diff_rel.to < $to_time)
+)
+AND n.branch_support = $branch_aware
+WITH DISTINCT n.uuid AS node_uuid, %(id_func)s(n) AS db_id
+WITH node_uuid, count(*) AS num_nodes_with_uuid
+WHERE num_nodes_with_uuid > 1
+// -------------------------------------
+// Limit the number of nodes
+// -------------------------------------
+WITH node_uuid
+ORDER BY node_uuid
+SKIP $offset
+LIMIT $limit
+WITH collect(node_uuid) AS node_uuids
+WITH node_uuids, size(node_uuids) = $limit AS has_more_data
+MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n:Node)
+WHERE n.uuid IN node_uuids
+AND (
+    ($from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
+    OR ($from_time <= diff_rel.to < $to_time)
+)
+// -------------------------------------
+// Ignore node created and deleted on this branch
+// -------------------------------------
+CALL {
+    WITH n
+    OPTIONAL MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n)
+    WITH diff_rel
+    ORDER BY diff_rel.from ASC
+    WITH collect(diff_rel.status) AS statuses
+    RETURN statuses = ["active", "deleted"] AS intra_branch_update
+}
+WITH n.uuid AS uuid, n.kind AS kind, %(id_func)s(n) AS db_id, diff_rel.from_time AS from_time, diff_rel.status AS status, has_more_data
+WHERE intra_branch_update = FALSE
+        """ % {"id_func": db.get_id_function_name()}
+        self.add_to_query(query=migrated_kind_nodes_query)
+        self.return_labels = [
+            "uuid",
+            "kind",
+            "db_id",
+            "from_time",
+            "status",
+            "has_more_data",
+        ]
+
+    def get_migrated_kind_nodes(self) -> Generator[MigratedKindNode, None, None]:
+        for result in self.get_results():
+            yield MigratedKindNode(
+                uuid=result.get_as_type("uuid", return_type=str),
+                kind=result.get_as_type("kind", return_type=str),
+                db_id=result.get_as_type("db_id", return_type=str),
+                from_time=result.get_as_type("from_time", return_type=Timestamp),
+                action=DiffAction.REMOVED
+                if result.get_as_type("status", return_type=str).lower() == RelationshipStatus.DELETED.value
+                else DiffAction.ADDED,
+                has_more_data=result.get_as_type("has_more_data", bool),
+            )

infrahub/core/query/node.py

@@ -92,6 +92,7 @@ class NodeAttributesFromDB:
 class PeerInfo:
     uuid: str
     kind: str
+    db_id: str
 
 
 class NodeQuery(Query):
@@ -412,9 +413,32 @@ class NodeDeleteQuery(NodeQuery):
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
 
+        if self.branch.is_global or self.branch.is_default:
+            node_query_match = """
+            MATCH (n:Node { uuid: $uuid })
+            OPTIONAL MATCH (n)-[delete_edge:IS_PART_OF {status: "deleted", branch: $branch}]->(:Root)
+            WHERE delete_edge.from <= $at
+            WITH n WHERE delete_edge IS NULL
+            """
+        else:
+            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
+                    MATCH (n)-[r:IS_PART_OF]->(:Root)
+                    WHERE %(node_filter)s
+                    RETURN r.status = "active" AS is_active
+                    ORDER BY r.from DESC
+                    LIMIT 1
+                }
+                WITH n WHERE is_active = TRUE
+                """ % {"node_filter": node_filter}
+            self.params.update(node_filter_params)
+        self.add_to_query(node_query_match)
+
         query = """
         MATCH (root:Root)
-        MATCH (n:Node { uuid: $uuid })
         CREATE (n)-[r:IS_PART_OF { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at }]->(root)
         """
 
@@ -1405,7 +1429,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)
@@ -1438,6 +1462,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)
@@ -1448,10 +1476,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)
 
@@ -1461,7 +1493,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"]
 
@@ -1544,4 +1577,5 @@ class NodeGetHierarchyQuery(Query):
             yield PeerInfo(
                 uuid=peer_node.get("uuid"),
                 kind=peer_node.get("kind"),
+                db_id=peer_node.element_id,
             )