infrahub-server 1.2.9rc0__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/diff/repository/deserializer.py

@@ -16,6 +16,7 @@ from ..model.path import (
     EnrichedDiffRoot,
     EnrichedDiffRootMetadata,
     EnrichedDiffSingleRelationship,
+    NodeIdentifier,
     deserialize_tracking_id,
 )
 from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
@@ -25,13 +26,15 @@ class EnrichedDiffDeserializer:
     def __init__(self, parent_adder: DiffParentNodeAdder) -> None:
         self.parent_adder = parent_adder
         self._diff_root_map: dict[str, EnrichedDiffRoot] = {}
-        self._diff_node_map: dict[tuple[str, str], EnrichedDiffNode] = {}
-        self._diff_node_attr_map: dict[tuple[str, str, str], EnrichedDiffAttribute] = {}
-        self._diff_node_rel_group_map: dict[tuple[str, str, str], EnrichedDiffRelationship] = {}
-        self._diff_node_rel_element_map: dict[tuple[str, str, str, str], EnrichedDiffSingleRelationship] = {}
-        self._diff_prop_map: dict[tuple[str, str, str, str] | tuple[str, str, str, str, str], EnrichedDiffProperty] = {}
-        # {EnrichedDiffRoot: [(node_uuid, parents_path: Neo4jPath), ...]}
-        self._parents_path_map: dict[EnrichedDiffRoot, list[tuple[str, Neo4jPath]]] = {}
+        self._diff_node_map: dict[tuple[str, NodeIdentifier], EnrichedDiffNode] = {}
+        self._diff_node_attr_map: dict[tuple[str, NodeIdentifier, str], EnrichedDiffAttribute] = {}
+        self._diff_node_rel_group_map: dict[tuple[str, NodeIdentifier, str], EnrichedDiffRelationship] = {}
+        self._diff_node_rel_element_map: dict[tuple[str, NodeIdentifier, str, str], EnrichedDiffSingleRelationship] = {}
+        self._diff_prop_map: dict[
+            tuple[str, NodeIdentifier, str, str] | tuple[str, str, str, str, str], EnrichedDiffProperty
+        ] = {}
+        # {EnrichedDiffRoot: [(NodeIdentifier, parents_path: Neo4jPath), ...]}
+        self._parents_path_map: dict[EnrichedDiffRoot, list[tuple[NodeIdentifier, Neo4jPath]]] = {}
 
     def initialize(self) -> None:
         self._diff_root_map = {}
@@ -42,10 +45,12 @@ class EnrichedDiffDeserializer:
         self._diff_prop_map = {}
         self._parents_path_map = {}
 
-    def _track_parents_path(self, enriched_root: EnrichedDiffRoot, node_uuid: str, parents_path: Neo4jPath) -> None:
+    def _track_parents_path(
+        self, enriched_root: EnrichedDiffRoot, node_identifier: NodeIdentifier, parents_path: Neo4jPath
+    ) -> None:
         if enriched_root not in self._parents_path_map:
             self._parents_path_map[enriched_root] = []
-        self._parents_path_map[enriched_root].append((node_uuid, parents_path))
+        self._parents_path_map[enriched_root].append((node_identifier, parents_path))
 
     async def read_result(self, result: QueryResult, include_parents: bool) -> None:
         enriched_root = self._deserialize_diff_root(root_node=result.get_node("diff_root"))
@@ -58,7 +63,7 @@ class EnrichedDiffDeserializer:
             parents_path = result.get("parents_path")
             if parents_path and isinstance(parents_path, Neo4jPath):
                 self._track_parents_path(
-                    enriched_root=enriched_root, node_uuid=enriched_node.uuid, parents_path=parents_path
+                    enriched_root=enriched_root, node_identifier=enriched_node.identifier, parents_path=parents_path
                 )
 
         node_conflict_node = result.get(label="diff_node_conflict")
@@ -79,11 +84,13 @@ class EnrichedDiffDeserializer:
     ) -> None:
         for attribute_result in result.get_nested_node_collection("diff_attributes"):
             diff_attr_node, diff_attr_property_node, diff_attr_property_conflict = attribute_result
-            if diff_attr_node is None or diff_attr_property_node is None:
+            if diff_attr_node is None:
                 continue
             enriched_attribute = self._deserialize_diff_attr(
                 diff_attr_node=diff_attr_node, enriched_root=enriched_root, enriched_node=enriched_node
             )
+            if diff_attr_property_node is None:
+                continue
             enriched_property = self._deserialize_diff_attr_property(
                 diff_attr_property_node=diff_attr_property_node,
                 enriched_attr=enriched_attribute,
@@ -130,17 +137,21 @@ class EnrichedDiffDeserializer:
     def _deserialize_parents(self) -> None:
         for enriched_root, node_path_tuples in self._parents_path_map.items():
             self.parent_adder.initialize(enriched_diff_root=enriched_root)
-            for node_uuid, parents_path in node_path_tuples:
+            for node_identifier, parents_path in node_path_tuples:
                 # Remove the node itself from the path
                 parents_path_slice = parents_path.nodes[1:]
 
                 # TODO Ensure the list is even
-                current_node_uuid = node_uuid
+                current_node_identifier = node_identifier
                 for rel, parent in zip(parents_path_slice[::2], parents_path_slice[1::2], strict=False):
+                    parent_identifier = NodeIdentifier(
+                        uuid=parent.get("uuid"),
+                        kind=parent.get("kind"),
+                        db_id=parent.get("db_id"),
+                    )
                     parent_request = ParentNodeAddRequest(
-                        node_id=current_node_uuid,
-                        parent_id=parent.get("uuid"),
-                        parent_kind=parent.get("kind"),
+                        node_identifier=current_node_identifier,
+                        parent_identifier=parent_identifier,
                         parent_label=parent.get("label"),
                         parent_rel_name=rel.get("name"),
                         parent_rel_identifier=rel.get("identifier"),
@@ -148,7 +159,7 @@ class EnrichedDiffDeserializer:
                         parent_rel_label=rel.get("label"),
                     )
                     self.parent_adder.add_parent(parent_request=parent_request)
-                    current_node_uuid = parent.get("uuid")
+                    current_node_identifier = parent_identifier
 
     @classmethod
     def _get_str_or_none_property_value(cls, node: Neo4jNode, property_name: str) -> str | None:
@@ -189,17 +200,20 @@ class EnrichedDiffDeserializer:
 
     def _deserialize_diff_node(self, node_node: Neo4jNode, enriched_root: EnrichedDiffRoot) -> EnrichedDiffNode:
         node_uuid = str(node_node.get("uuid"))
-        node_key = (enriched_root.uuid, node_uuid)
+        node_kind = str(node_node.get("kind"))
+        node_db_id = node_node.get("db_id")
+        node_identifier = NodeIdentifier(uuid=node_uuid, kind=node_kind, db_id=node_db_id)
+        node_key = (enriched_root.uuid, node_identifier)
         if node_key in self._diff_node_map:
             return self._diff_node_map[node_key]
 
         timestamp_str = self._get_str_or_none_property_value(node=node_node, property_name="changed_at")
         enriched_node = EnrichedDiffNode(
-            uuid=node_uuid,
-            kind=str(node_node.get("kind")),
+            identifier=node_identifier,
             label=str(node_node.get("label")),
             changed_at=Timestamp(timestamp_str) if timestamp_str else None,
             action=DiffAction(str(node_node.get("action"))),
+            is_node_kind_migration=bool(node_node.get("is_node_kind_migration")),
             path_identifier=str(node_node.get("path_identifier")),
             num_added=int(node_node.get("num_added", 0)),
             num_updated=int(node_node.get("num_updated", 0)),
@@ -215,7 +229,7 @@ class EnrichedDiffDeserializer:
         self, diff_attr_node: Neo4jNode, enriched_root: EnrichedDiffRoot, enriched_node: EnrichedDiffNode
     ) -> EnrichedDiffAttribute:
         attr_name = str(diff_attr_node.get("name"))
-        attr_key = (enriched_root.uuid, enriched_node.uuid, attr_name)
+        attr_key = (enriched_root.uuid, enriched_node.identifier, attr_name)
         if attr_key in self._diff_node_attr_map:
             return self._diff_node_attr_map[attr_key]
 
@@ -238,7 +252,7 @@ class EnrichedDiffDeserializer:
         self, relationship_group_node: Neo4jNode, enriched_root: EnrichedDiffRoot, enriched_node: EnrichedDiffNode
     ) -> EnrichedDiffRelationship:
         diff_rel_name = str(relationship_group_node.get("name"))
-        rel_key = (enriched_root.uuid, enriched_node.uuid, diff_rel_name)
+        rel_key = (enriched_root.uuid, enriched_node.identifier, diff_rel_name)
         if rel_key in self._diff_node_rel_group_map:
             return self._diff_node_rel_group_map[rel_key]
 
@@ -272,7 +286,7 @@ class EnrichedDiffDeserializer:
         diff_element_peer_id = str(relationship_element_node.get("peer_id"))
         rel_element_key = (
             enriched_root.uuid,
-            enriched_node.uuid,
+            enriched_node.identifier,
             enriched_relationship_group.name,
             diff_element_peer_id,
         )
@@ -320,7 +334,7 @@ class EnrichedDiffDeserializer:
         enriched_root: EnrichedDiffRoot,
     ) -> EnrichedDiffProperty:
         diff_prop_type = str(diff_attr_property_node.get("property_type"))
-        attr_property_key = (enriched_root.uuid, enriched_node.uuid, enriched_attr.name, diff_prop_type)
+        attr_property_key = (enriched_root.uuid, enriched_node.identifier, enriched_attr.name, diff_prop_type)
         if attr_property_key in self._diff_prop_map:
             return self._diff_prop_map[attr_property_key]
 

infrahub/core/diff/repository/repository.py

@@ -1,10 +1,10 @@
-from collections import defaultdict
 from typing import AsyncGenerator, Generator, Iterable
 
 from neo4j.exceptions import TransientError
 
 from infrahub import config
 from infrahub.core import registry
+from infrahub.core.diff.query.drop_nodes import EnrichedDiffDropNodesQuery
 from infrahub.core.diff.query.field_summary import EnrichedDiffNodeFieldSummaryQuery
 from infrahub.core.diff.query.summary_counts_enricher import (
     DiffFieldsSummaryCountsEnricherQuery,
@@ -16,6 +16,7 @@ from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import ResourceNotFoundError
 from infrahub.log import get_logger
 
+from ..model.field_specifiers_map import NodeFieldSpecifierMap
 from ..model.path import (
     ConflictSelection,
     EnrichedDiffConflict,
@@ -26,6 +27,7 @@ from ..model.path import (
     EnrichedDiffsMetadata,
     EnrichedNodeCreateRequest,
     NodeDiffFieldSummary,
+    NodeIdentifier,
     TimeRange,
     TrackingId,
 )
@@ -108,7 +110,7 @@ class DiffRepository:
         diff_branch_names: list[str],
         from_time: Timestamp | None = None,
         to_time: Timestamp | None = None,
-        filters: dict | None = None,
+        filters: EnrichedDiffQueryFilters | None = None,
         include_parents: bool = True,
         limit: int | None = None,
         offset: int | None = None,
@@ -180,11 +182,11 @@ class DiffRepository:
     async def hydrate_diff_pair(
         self,
         enriched_diffs_metadata: EnrichedDiffsMetadata,
-        node_uuids: Iterable[str] | None = None,
+        node_identifiers: Iterable[NodeIdentifier] | None = None,
     ) -> EnrichedDiffs:
-        filters = None
-        if node_uuids:
-            filters = {"ids": list(node_uuids) if node_uuids is not None else None}
+        filters = EnrichedDiffQueryFilters()
+        if node_identifiers:
+            filters.identifiers = list(node_identifiers)
         hydrated_base_diff = await self.get_one(
             diff_branch_name=enriched_diffs_metadata.base_branch_name,
             diff_id=enriched_diffs_metadata.base_branch_diff.uuid,
@@ -207,7 +209,7 @@ class DiffRepository:
         diff_branch_name: str,
         tracking_id: TrackingId | None = None,
         diff_id: str | None = None,
-        filters: dict | None = None,
+        filters: EnrichedDiffQueryFilters | None = None,
         include_parents: bool = True,
     ) -> EnrichedDiffRoot:
         enriched_diffs = await self.get(
@@ -274,6 +276,12 @@ class DiffRepository:
                 )
                 await single_node_query.execute(db=self.db)
 
+    async def _drop_nodes(self, diff_root: EnrichedDiffRoot, node_identifiers: list[NodeIdentifier]) -> None:
+        drop_node_query = await EnrichedDiffDropNodesQuery.init(
+            db=self.db, enriched_diff_uuid=diff_root.uuid, node_identifiers=node_identifiers
+        )
+        await drop_node_query.execute(db=self.db)
+
     @retry_db_transaction(name="enriched_diff_hierarchy_update")
     async def _run_hierarchy_links_update_query(self, diff_root_uuid: str, diff_nodes: list[EnrichedDiffNode]) -> None:
         log.info(f"Updating diff hierarchy links, num_nodes={len(diff_nodes)}")
@@ -321,7 +329,12 @@ class DiffRepository:
                 node_uuids=node_uuids,
             )
 
-    async def save(self, enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata, do_summary_counts: bool = True) -> None:
+    async def save(
+        self,
+        enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata,
+        do_summary_counts: bool = True,
+        node_identifiers_to_drop: list[NodeIdentifier] | None = None,
+    ) -> None:
         # metadata-only update
         if not isinstance(enriched_diffs, EnrichedDiffs):
             await self._save_root_metadata(enriched_diffs=enriched_diffs)
@@ -336,6 +349,8 @@ class DiffRepository:
             await self._save_node_batch(node_create_batch=node_create_batch)
             count_nodes_remaining -= len(node_create_batch)
             log.info(f"Batch saved. {count_nodes_remaining=}")
+        if node_identifiers_to_drop:
+            await self._drop_nodes(diff_root=enriched_diffs.diff_branch_diff, node_identifiers=node_identifiers_to_drop)
         await self._update_hierarchy_links(enriched_diffs=enriched_diffs)
         if do_summary_counts:
             await self._update_summary_counts(diff_root=enriched_diffs.diff_branch_diff)
@@ -501,21 +516,25 @@ class DiffRepository:
         await query.execute(db=self.db)
         return query.get_num_changes_by_branch()
 
-    async def get_node_field_specifiers(self, diff_id: str) -> dict[str, set[str]]:
+    async def get_node_field_specifiers(self, diff_id: str) -> NodeFieldSpecifierMap:
         limit = config.SETTINGS.database.query_size_limit
         offset = 0
-        specifiers: dict[str, set[str]] = defaultdict(set)
+        specifiers_map = NodeFieldSpecifierMap()
         while True:
             query = await EnrichedDiffFieldSpecifiersQuery.init(db=self.db, diff_id=diff_id, offset=offset, limit=limit)
             await query.execute(db=self.db)
             has_data = False
             for field_specifier_tuple in query.get_node_field_specifier_tuples():
-                specifiers[field_specifier_tuple[0]].add(field_specifier_tuple[1])
+                specifiers_map.add_entry(
+                    node_uuid=field_specifier_tuple[0],
+                    kind=field_specifier_tuple[1],
+                    field_name=field_specifier_tuple[2],
+                )
                 has_data = True
             if not has_data:
                 break
             offset += limit
-        return specifiers
+        return specifiers_map
 
     async def add_summary_counts(
         self,

infrahub/core/diff/tasks.py

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

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 26
+GRAPH_VERSION = 28

infrahub/core/manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import copy
 from functools import reduce
 from typing import TYPE_CHECKING, Any, Iterable, Literal, TypeVar, overload
 
@@ -1339,22 +1340,24 @@ class NodeManager:
         nodes: list[Node],
         branch: Branch | str | None = None,
         at: Timestamp | str | None = None,
+        cascade_delete: bool = True,
     ) -> list[Node]:
         """Returns list of deleted nodes because of cascading deletes"""
         branch = await registry.get_branch(branch=branch, db=db)
-        node_delete_validator = NodeDeleteValidator(db=db, branch=branch)
-        ids_to_delete = await node_delete_validator.get_ids_to_delete(nodes=nodes, at=at)
-        node_ids = {node.get_id() for node in nodes}
-        missing_ids_to_delete = ids_to_delete - node_ids
-        if missing_ids_to_delete:
-            node_map = await cls.get_many(db=db, ids=list(missing_ids_to_delete), branch=branch, at=at)
-            nodes += list(node_map.values())
-        deleted_nodes = []
-        for node in nodes:
+        nodes_to_delete = copy(nodes)
+        if cascade_delete:
+            node_delete_validator = NodeDeleteValidator(db=db, branch=branch)
+            ids_to_delete = await node_delete_validator.get_ids_to_delete(nodes=nodes, at=at)
+            node_ids = {node.get_id() for node in nodes}
+            missing_ids_to_delete = ids_to_delete - node_ids
+            if missing_ids_to_delete:
+                node_map = await cls.get_many(db=db, ids=list(missing_ids_to_delete), branch=branch, at=at)
+                nodes_to_delete += list(node_map.values())
+
+        for node in nodes_to_delete:
             await node.delete(db=db, at=at)
-            deleted_nodes.append(node)
 
-        return deleted_nodes
+        return nodes_to_delete
 
 
 def _get_cardinality_one_identifiers_by_kind(

infrahub/core/migrations/graph/__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/m003_relationship_parent_optional.py

@@ -26,8 +26,7 @@ class Migration003Query01(Query):
         query = """
         MATCH path = (av2:AttributeValue)-[:HAS_VALUE]-(:Attribute {name: "optional"})-[:HAS_ATTRIBUTE]-(n:SchemaRelationship)-[:HAS_ATTRIBUTE]-(:Attribute {name: "kind"})-[:HAS_VALUE]-(av1:AttributeValue)
         WHERE av1.value = "Parent" AND av2.value = true AND all(r IN relationships(path) WHERE ( %(filters)s ))
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path22 = (av22:AttributeValue)-[r22:HAS_VALUE]-(a2:Attribute {name: "optional"})-[:HAS_ATTRIBUTE]-(n:SchemaRelationship)-[:HAS_ATTRIBUTE]-(:Attribute {name:"kind"})-[:HAS_VALUE]-(av11:AttributeValue)
             WHERE av11.value = "Parent" AND av22.value = true AND all(r IN relationships(path22) WHERE ( %(filters)s ))
             RETURN av22 as av2_sub, r22, a2, path22 as path2

infrahub/core/migrations/graph/m013_convert_git_password_credential.py

@@ -98,8 +98,7 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
         // --------------------------------
         MATCH (git_repo)-[:HAS_ATTRIBUTE]-(git_attr_name:Attribute)-[:HAS_VALUE]->(git_name_value:AttributeValue)
         WHERE git_attr_name.name = "name"
-        CALL {
-            WITH git_repo
+        CALL (git_repo) {
             MATCH path1 = (git_repo)-[r1:HAS_ATTRIBUTE]-(git_attr_name2:Attribute)-[r2:HAS_VALUE]->(git_name_value2:AttributeValue)
             WHERE git_attr_name2.name = "name"
               AND all(r IN relationships(path1) WHERE %(filters)s)
@@ -204,8 +203,7 @@ class Migration013ConvertCoreRepositoryWithoutCred(Query):
         WHERE a.name in ["username", "password"]
             AND av.value = "NULL"
             AND all(r IN relationships(path) WHERE %(filters)s AND r.status = "active")
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(filters)s
             RETURN node as n1, r as r1

infrahub/core/migrations/graph/m019_restore_rels_to_time.py

@@ -97,8 +97,7 @@ class DeleteNodesRelsQuery(Query):
         // - on deleted edge branch
         // - or on any branch and deleted node is agnostic
         // - or deleted node is aware and rel is agnostic
-        CALL {
-            WITH rel, deleted_edge
+        CALL (rel, deleted_edge) {
             OPTIONAL MATCH (rel)-[peer_active_edge {status: "active"}]-(peer_1)
             WHERE (peer_active_edge.branch = deleted_edge.branch OR (rel.branch_support <> $branch_agnostic AND deleted_edge.branch = $global_branch))
             AND peer_active_edge.to IS NULL
@@ -160,62 +159,52 @@ class DeleteNodesRelsQuery(Query):
         // Below CALL subqueries are called once for each rel-peer_2 pair for which we want to create a deleted edge.
         // Note that with current infrahub relationships edges design, only one of this CALL should be matched per pair.
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:IS_RELATED]->(peer_2)
             MERGE (rel)-[:IS_RELATED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:IS_PROTECTED]->(peer_2)
             MERGE (rel)-[:IS_PROTECTED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:IS_VISIBLE]->(peer_2)
             MERGE (rel)-[:IS_VISIBLE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:HAS_OWNER]->(peer_2)
             MERGE (rel)-[:HAS_OWNER {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)-[:HAS_SOURCE]->(peer_2)
             MERGE (rel)-[:HAS_SOURCE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]->(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:IS_RELATED]-(peer_2)
             MERGE (rel)<-[:IS_RELATED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:IS_PROTECTED]-(peer_2)
             MERGE (rel)<-[:IS_PROTECTED {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:IS_VISIBLE]-(peer_2)
             MERGE (rel)<-[:IS_VISIBLE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:HAS_OWNER]-(peer_2)
             MERGE (rel)<-[:HAS_OWNER {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }
 
-        CALL {
-            WITH rel, peer_2, branch, branch_level, deleted_time
+        CALL (rel, peer_2, branch, branch_level, deleted_time) {
             MATCH (rel)<-[:HAS_SOURCE]-(peer_2)
             MERGE (rel)<-[:HAS_SOURCE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
         }

infrahub/core/migrations/graph/m020_duplicate_edges.py

@@ -33,8 +33,7 @@ WHERE num_duplicate_edges > 1
 // -------------------
 WITH DISTINCT a, branch, branch_level, status, from, to, attr_val, attr_default
 WITH attr_val, attr_default, collect([a, branch, branch_level, status, from, to]) AS details_list
-CALL {
-    WITH attr_val, attr_default
+CALL (attr_val, attr_default) {
     MATCH (av:AttributeValue {value: attr_val, is_default: attr_default})
     RETURN av AS the_one_av
     ORDER by %(id_func)s(av) ASC
@@ -53,11 +52,10 @@ WITH a, branch, status, from, to, attr_val, attr_default, %(id_func)s(fresh_e) A
 // -------------------
 // get the identical edges for a given set of Attribute node, edge properties, AttributeValue.value
 // -------------------
-CALL {
+CALL (a, branch, status, from, to, attr_val, attr_default, e_id_to_keep) {
     // -------------------
     // delete the duplicate edges a given set of Attribute node, edge properties, AttributeValue.value
     // -------------------
-    WITH a, branch, status, from, to, attr_val, attr_default, e_id_to_keep
     MATCH (a)-[e:HAS_VALUE]->(av:AttributeValue {value: attr_val, is_default: attr_default})
     WHERE %(id_func)s(e) <> e_id_to_keep
     AND e.branch = branch AND e.status = status AND e.from = from
@@ -99,8 +97,7 @@ WITH DISTINCT a, branch, branch_level, status, from, to, b
 CREATE (a)-[fresh_e:%(edge_type)s {branch: branch, branch_level: branch_level, status: status, from: from}]->(b)
 SET fresh_e.to = to
 WITH a, branch, status, from, to, b, %(id_func)s(fresh_e) AS e_id_to_keep
-CALL {
-    WITH a, branch, status, from, to, b, e_id_to_keep
+CALL (a, branch, status, from, to, b, e_id_to_keep) {
     MATCH (a)-[e:%(edge_type)s]->(b)
     WHERE %(id_func)s(e) <> e_id_to_keep
     AND e.branch = branch AND e.status = status AND e.from = from

infrahub/core/migrations/graph/m021_missing_hierarchy_merge.py

@@ -24,8 +24,7 @@ class SetMissingHierarchyQuery(Query):
         WITH r.default_branch AS default_branch
         MATCH (n:Node)-[main_e:IS_RELATED {branch: default_branch}]-(rel:Relationship)
         WHERE main_e.hierarchy IS NULL
-        CALL {
-            WITH n, main_e, rel
+        CALL (n, main_e, rel) {
             MATCH (n)-[branch_e:IS_RELATED]-(rel)
             WHERE branch_e.hierarchy IS NOT NULL
             AND branch_e.branch <> main_e.branch

infrahub/core/migrations/graph/m024_missing_hierarchy_backfill.py

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

infrahub/core/migrations/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/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/migrations/query/attribute_add.py

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