infrahub-server 1.3.2__py3-none-any.whl → 1.3.3__py3-none-any.whl

infrahub/core/merge.py

@@ -9,7 +9,7 @@ from infrahub.core.models import SchemaUpdateValidationResult
 from infrahub.core.protocols import CoreRepository
 from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
-from infrahub.exceptions import ValidationError
+from infrahub.exceptions import MergeFailedError, ValidationError
 from infrahub.log import get_logger
 
 from ..git.models import GitRepositoryMerge
@@ -18,6 +18,7 @@ from ..workflows.catalogue import GIT_REPOSITORIES_MERGE
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.diff.coordinator import DiffCoordinator
+    from infrahub.core.diff.diff_locker import DiffLocker
     from infrahub.core.diff.merger.merger import DiffMerger
     from infrahub.core.diff.model.path import EnrichedDiffRoot
     from infrahub.core.diff.repository.repository import DiffRepository
@@ -39,6 +40,7 @@ class BranchMerger:
         diff_coordinator: DiffCoordinator,
         diff_merger: DiffMerger,
         diff_repository: DiffRepository,
+        diff_locker: DiffLocker,
         destination_branch: Branch | None = None,
         service: InfrahubServices | None = None,
     ):
@@ -48,6 +50,7 @@ class BranchMerger:
         self.diff_coordinator = diff_coordinator
         self.diff_merger = diff_merger
         self.diff_repository = diff_repository
+        self.diff_locker = diff_locker
         self.migrations: list[SchemaUpdateMigrationInfo] = []
         self._merge_at = Timestamp()
 
@@ -185,22 +188,34 @@ class BranchMerger:
         )
         log.info("Diff updated for merge")
 
-        errors: list[str] = []
-        async for conflict_path, conflict in self.diff_repository.get_all_conflicts_for_diff(
-            diff_branch_name=self.source_branch.name, tracking_id=BranchTrackingId(name=self.source_branch.name)
+        log.info("Acquiring lock for merge")
+        async with self.diff_locker.acquire_lock(
+            target_branch_name=self.destination_branch.name,
+            source_branch_name=self.source_branch.name,
+            is_incremental=False,
         ):
-            if conflict.selected_branch is None or conflict.resolvable is False:
-                errors.append(conflict_path)
-
-        if errors:
-            raise ValidationError(
-                f"Unable to merge the branch '{self.source_branch.name}', conflict resolution missing: {', '.join(errors)}"
-            )
-
-        # TODO need to find a way to properly communicate back to the user any issue that could come up during the merge
-        # From the Graph or From the repositories
-        self._merge_at = Timestamp(at)
-        branch_diff = await self.diff_merger.merge_graph(at=self._merge_at)
+            log.info("Lock acquired for merge")
+            try:
+                errors: list[str] = []
+                async for conflict_path, conflict in self.diff_repository.get_all_conflicts_for_diff(
+                    diff_branch_name=self.source_branch.name, tracking_id=BranchTrackingId(name=self.source_branch.name)
+                ):
+                    if conflict.selected_branch is None or conflict.resolvable is False:
+                        errors.append(conflict_path)
+
+                if errors:
+                    raise ValidationError(
+                        f"Unable to merge the branch '{self.source_branch.name}', conflict resolution missing: {', '.join(errors)}"
+                    )
+
+                # TODO need to find a way to properly communicate back to the user any issue that could come up during the merge
+                # From the Graph or From the repositories
+                self._merge_at = Timestamp(at)
+                branch_diff = await self.diff_merger.merge_graph(at=self._merge_at)
+            except Exception as exc:
+                log.exception("Merge failed, beginning rollback")
+                await self.rollback()
+                raise MergeFailedError(branch_name=self.source_branch.name) from exc
         await self.merge_repositories()
         return branch_diff
 

infrahub/core/migrations/graph/__init__.py

@@ -33,6 +33,8 @@ from .m028_delete_diffs import Migration028
 from .m029_duplicates_cleanup import Migration029
 from .m030_illegal_edges import Migration030
 from .m031_check_number_attributes import Migration031
+from .m032_cleanup_orphaned_branch_relationships import Migration032
+from .m033_deduplicate_relationship_vertices import Migration033
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -71,6 +73,8 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration029,
     Migration030,
     Migration031,
+    Migration032,
+    Migration033,
 ]
 
 
@@ -85,3 +89,23 @@ async def get_graph_migrations(
         applicable_migrations.append(migration)
 
     return applicable_migrations
+
+
+def get_migration_by_number(
+    migration_number: int | str,
+) -> GraphMigration | InternalSchemaMigration | ArbitraryMigration:
+    # Convert to string and pad with zeros if needed
+    try:
+        num = int(migration_number)
+        migration_str = f"{num:03d}"
+    except (ValueError, TypeError) as exc:
+        raise ValueError(f"Invalid migration number: {migration_number}") from exc
+
+    migration_name = f"Migration{migration_str}"
+
+    # Find the migration in the MIGRATIONS list
+    for migration_class in MIGRATIONS:
+        if migration_class.__name__ == migration_name:
+            return migration_class.init()
+
+    raise ValueError(f"Migration {migration_number} not found")

infrahub/core/migrations/graph/m012_convert_account_generic.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Sequence
 
 from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType, InfrahubKind
 from infrahub.core.migrations.shared import MigrationResult
 from infrahub.core.query import Query, QueryType
@@ -20,7 +21,7 @@ if TYPE_CHECKING:
 
 global_branch = Branch(
     name=GLOBAL_BRANCH_NAME,
-    status="OPEN",
+    status=BranchStatus.OPEN,
     description="Global Branch",
     hierarchy_level=1,
     is_global=True,
@@ -29,7 +30,7 @@ global_branch = Branch(
 
 default_branch = Branch(
     name="main",
-    status="OPEN",
+    status=BranchStatus.OPEN,
     description="Default Branch",
     hierarchy_level=1,
     is_global=False,
@@ -105,7 +106,7 @@ class Migration012AddLabelData(NodeDuplicateQuery):
 
         branch = Branch(
             name=GLOBAL_BRANCH_NAME,
-            status="OPEN",
+            status=BranchStatus.OPEN,
             description="Global Branch",
             hierarchy_level=1,
             is_global=True,

infrahub/core/migrations/graph/m013_convert_git_password_credential.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Sequence
 
 from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
     BranchSupportType,
@@ -23,7 +24,7 @@ if TYPE_CHECKING:
 
 default_branch = Branch(
     name="main",
-    status="OPEN",
+    status=BranchStatus.OPEN,
     description="Default Branch",
     hierarchy_level=1,
     is_global=False,
@@ -42,7 +43,7 @@ class Migration013ConvertCoreRepositoryWithCred(Query):
 
         global_branch = Branch(
             name=GLOBAL_BRANCH_NAME,
-            status="OPEN",
+            status=BranchStatus.OPEN,
             description="Global Branch",
             hierarchy_level=1,
             is_global=True,
@@ -176,7 +177,7 @@ class Migration013ConvertCoreRepositoryWithoutCred(Query):
 
         global_branch = Branch(
             name=GLOBAL_BRANCH_NAME,
-            status="OPEN",
+            status=BranchStatus.OPEN,
             description="Global Branch",
             hierarchy_level=1,
             is_global=True,

infrahub/core/migrations/graph/m032_cleanup_orphaned_branch_relationships.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.query import Query, QueryType
+from infrahub.core.query.branch import DeleteBranchRelationshipsQuery
+from infrahub.log import get_logger
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class DeletedBranchCleanupQuery(Query):
+    """
+    Find all unique edge branch names for which there is no Branch object
+    """
+
+    name = "deleted_branch_cleanup"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (b:Branch)
+WITH collect(DISTINCT b.name) AS branch_names
+MATCH ()-[e]->()
+WHERE e.branch IS NOT NULL
+AND NOT e.branch IN branch_names
+RETURN DISTINCT (e.branch) AS branch_name
+        """
+        self.add_to_query(query)
+        self.return_labels = ["branch_name"]
+
+
+class DeleteOrphanRelationshipsQuery(Query):
+    """
+    Find all Relationship vertices that link to fewer than 2 Node vertices and delete them
+    """
+
+    name = "delete_orphan_relationships"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (r:Relationship)-[:IS_RELATED]-(n:Node)
+WITH DISTINCT r, n
+WITH r, count(*) AS node_count
+WHERE node_count < 2
+DETACH DELETE r
+        """
+        self.add_to_query(query)
+
+
+class Migration032(ArbitraryMigration):
+    """
+    Delete edges for branches that were not completely deleted
+    """
+
+    name: str = "032_cleanup_deleted_branches"
+    minimum_version: int = 31
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        migration_result = MigrationResult()
+
+        try:
+            log.info("Get partially deleted branch names...")
+            orphaned_branches_query = await DeletedBranchCleanupQuery.init(db=db)
+            await orphaned_branches_query.execute(db=db)
+
+            orphaned_branch_names = []
+            for result in orphaned_branches_query.get_results():
+                branch_name = result.get_as_type("branch_name", str)
+                orphaned_branch_names.append(branch_name)
+
+            if not orphaned_branch_names:
+                log.info("No partially deleted branches found. All done.")
+                return migration_result
+
+            log.info(f"Found {len(orphaned_branch_names)} orphaned branch names: {orphaned_branch_names}")
+
+            for branch_name in orphaned_branch_names:
+                log.info(f"Cleaning up branch '{branch_name}'...")
+                delete_query = await DeleteBranchRelationshipsQuery.init(db=db, branch_name=branch_name)
+                await delete_query.execute(db=db)
+                log.info(f"Branch '{branch_name}' cleaned up.")
+
+            log.info("Deleting orphaned relationships...")
+            delete_relationships_query = await DeleteOrphanRelationshipsQuery.init(db=db)
+            await delete_relationships_query.execute(db=db)
+            log.info("Orphaned relationships deleted.")
+
+        except Exception as exc:
+            migration_result.errors.append(str(exc))
+            log.exception("Error during branch cleanup")
+
+        return migration_result

infrahub/core/migrations/graph/m033_deduplicate_relationship_vertices.py

@@ -0,0 +1,97 @@
+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 DeduplicateRelationshipVerticesQuery(Query):
+    """
+    For each group of duplicate Relationships with the same UUID, delete any Relationship that meets the following criteria:
+    - is linked to a deleted node (only if the delete time is before the Relationship's from time)
+    - is linked to a node on an incorrect branch (ie Relationship added on main, but Node is on a branch)
+    """
+
+    name = "deduplicate_relationship_vertices"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (root:Root)
+WITH root.default_branch AS default_branch_name
+// ------------
+// Find all Relationship vertices with duplicate UUIDs
+// ------------
+MATCH (r:Relationship)
+WITH r.uuid AS r_uuid, default_branch_name, count(*) AS num_dups
+WHERE num_dups > 1
+WITH DISTINCT r_uuid, default_branch_name
+// ------------
+// get the branched_from time for each relationship edge and node
+// ------------
+MATCH (rel:Relationship {uuid: r_uuid})
+CALL (rel) {
+    MATCH (rel)-[is_rel_e:IS_RELATED {status: "active"}]-(n:Node)
+    MATCH (rel_branch:Branch {name: is_rel_e.branch})
+    RETURN is_rel_e, rel_branch.branched_from AS rel_branched_from, n
+}
+// ------------
+// for each IS_RELATED edge of the relationship, check the IS_PART_OF edges of the Node vertex
+// to determine if this side of the relationship is legal
+// ------------
+CALL (n, is_rel_e, rel_branched_from, default_branch_name) {
+    OPTIONAL MATCH (n)-[is_part_of_e:IS_PART_OF {status: "active"}]->(:Root)
+    WHERE (
+        // the Node's create time must precede the Relationship's create time
+        is_part_of_e.from <= is_rel_e.from AND (is_part_of_e.to >= is_rel_e.from OR is_part_of_e.to IS NULL)
+        // the Node must have been created on a branch of equal or lesser depth than the Relationship
+        AND is_part_of_e.branch_level <= is_rel_e.branch_level
+        // if the Node and Relationships were created on branch_level = 2, then they must be on the same branch
+        AND (
+            is_part_of_e.branch_level = 1
+            OR is_part_of_e.branch = is_rel_e.branch
+        )
+        // if the Node was created on the default branch, and the Relationship was created on a branch,
+        // then the Node must have been created after the branched_from time of the Relationship's branch
+        AND (
+            is_part_of_e.branch <> default_branch_name
+            OR is_rel_e.branch_level = 1
+            OR is_part_of_e.from <= rel_branched_from
+        )
+    )
+    WITH is_part_of_e IS NOT NULL AS is_legal
+    ORDER BY is_legal DESC
+    RETURN is_legal
+    LIMIT 1
+}
+WITH rel, is_legal
+ORDER BY rel, is_legal ASC
+WITH rel, head(collect(is_legal)) AS is_legal
+WHERE is_legal = false
+DETACH DELETE rel
+        """
+        self.add_to_query(query)
+
+
+class Migration033(GraphMigration):
+    """
+    Identifies duplicate Relationship vertices that have the same UUID property. Deletes any duplicates that
+    are linked to deleted nodes or nodes on in incorrect branch.
+    """
+
+    name: str = "033_deduplicate_relationship_vertices"
+    minimum_version: int = 31
+    queries: Sequence[type[Query]] = [DeduplicateRelationshipVerticesQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/node/__init__.py

@@ -82,6 +82,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     def get_schema(self) -> NonGenericSchemaTypes:
         return self._schema
 
+    def get_branch(self) -> Branch:
+        return self._branch
+
     def get_kind(self) -> str:
         """Return the main Kind of the Object."""
         return self._schema.kind

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -18,6 +18,7 @@ from .. import Node
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.ipam.constants import IPAddressType
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -30,6 +31,7 @@ class CoreIPAddressPool(Node):
         data: dict[str, Any] | None = None,
         address_type: str | None = None,
         prefixlen: int | None = None,
+        at: Timestamp | None = None,
     ) -> Node:
         # Check if there is already a resource allocated with this identifier
         # if not, pull all existing prefixes and allocated the next available
@@ -63,18 +65,18 @@ class CoreIPAddressPool(Node):
         next_address = await self.get_next(db=db, prefixlen=prefixlen)
 
         target_schema = registry.get_node_schema(name=address_type, branch=branch)
-        node = await Node.init(db=db, schema=target_schema, branch=branch)
+        node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
         try:
             await node.new(db=db, address=str(next_address), ip_namespace=ip_namespace, **data)
         except ValidationError as exc:
             raise ValueError(f"IPAddressPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
-        await node.save(db=db)
+        await node.save(db=db, at=at)
         reconciler = IpamReconciler(db=db, branch=branch)
         await reconciler.reconcile(ip_value=next_address, namespace=ip_namespace.id, node_uuid=node.get_id())
 
         if identifier:
             query_set = await IPAddressPoolSetReserved.init(
-                db=db, pool_id=self.id, identifier=identifier, address_id=node.id
+                db=db, pool_id=self.id, identifier=identifier, address_id=node.id, at=at
             )
             await query_set.execute(db=db)
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -20,6 +20,7 @@ from .. import Node
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.ipam.constants import IPNetworkType
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -33,6 +34,7 @@ class CoreIPPrefixPool(Node):
         prefixlen: int | None = None,
         member_type: str | None = None,
         prefix_type: str | None = None,
+        at: Timestamp | None = None,
     ) -> Node:
         # Check if there is already a resource allocated with this identifier
         # if not, pull all existing prefixes and allocated the next available
@@ -68,20 +70,21 @@ class CoreIPPrefixPool(Node):
             )
 
         member_type = member_type or data.get("member_type", None) or self.default_member_type.value.value  # type: ignore[attr-defined]
+        data["member_type"] = member_type
 
         target_schema = registry.get_node_schema(name=prefix_type, branch=branch)
-        node = await Node.init(db=db, schema=target_schema, branch=branch)
+        node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
         try:
-            await node.new(db=db, prefix=str(next_prefix), member_type=member_type, ip_namespace=ip_namespace, **data)
+            await node.new(db=db, prefix=str(next_prefix), ip_namespace=ip_namespace, **data)
         except ValidationError as exc:
             raise ValueError(f"IPPrefixPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
-        await node.save(db=db)
+        await node.save(db=db, at=at)
         reconciler = IpamReconciler(db=db, branch=branch)
         await reconciler.reconcile(ip_value=next_prefix, namespace=ip_namespace.id, node_uuid=node.get_id())
 
         if identifier:
             query_set = await PrefixPoolSetReserved.init(
-                db=db, pool_id=self.id, identifier=identifier, prefix_id=node.id
+                db=db, pool_id=self.id, identifier=identifier, prefix_id=node.id, at=at
             )
             await query_set.execute(db=db)
 

infrahub/core/node/resource_manager/number_pool.py

@@ -12,6 +12,7 @@ from .. import Node
 if TYPE_CHECKING:
     from infrahub.core.attribute import BaseAttribute
     from infrahub.core.branch import Branch
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -41,6 +42,7 @@ class CoreNumberPool(Node):
         node: Node,
         attribute: BaseAttribute,
         identifier: str | None = None,
+        at: Timestamp | None = None,
     ) -> int:
         identifier = identifier or node.get_id()
         # Check if there is already a resource allocated with this identifier
@@ -56,7 +58,7 @@ class CoreNumberPool(Node):
         number = await self.get_next(db=db, branch=branch, attribute=attribute)
 
         query_set = await NumberPoolSetReserved.init(
-            db=db, pool_id=self.get_id(), identifier=identifier, reserved=number
+            db=db, pool_id=self.get_id(), identifier=identifier, reserved=number, at=at
         )
         await query_set.execute(db=db)
         return number

infrahub/core/node/standard.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+from enum import Enum
 from typing import TYPE_CHECKING, Any, Optional, Union, get_args, get_origin
 from uuid import UUID
 
@@ -191,6 +192,9 @@ class StandardNode(BaseModel):
                 continue
 
             attr_value = getattr(self, attr_name)
+            if isinstance(attr_value, Enum):
+                attr_value = attr_value.value
+
             field_type = self.guess_field_type(field)
 
             if attr_value is None:

infrahub/core/query/branch.py

@@ -3,43 +3,12 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub import config
-from infrahub.core.constants import RelationshipStatus
 from infrahub.core.query import Query, QueryType
 
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
-class AddNodeToBranch(Query):
-    name: str = "node_add_to_branch"
-    insert_return: bool = False
-
-    type: QueryType = QueryType.WRITE
-
-    def __init__(self, node_id: int, **kwargs: Any):
-        self.node_id = node_id
-        super().__init__(**kwargs)
-
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        query = """
-        MATCH (root:Root)
-        MATCH (d) WHERE %(id_func)s(d) = $node_id
-        WITH root,d
-        CREATE (d)-[r:IS_PART_OF { branch: $branch, branch_level: $branch_level, from: $now, status: $status }]->(root)
-        RETURN %(id_func)s(r)
-        """ % {
-            "id_func": db.get_id_function_name(),
-        }
-
-        self.params["node_id"] = db.to_database_id(self.node_id)
-        self.params["now"] = self.at.to_string()
-        self.params["branch"] = self.branch.name
-        self.params["branch_level"] = self.branch.hierarchy_level
-        self.params["status"] = RelationshipStatus.ACTIVE.value
-
-        self.add_to_query(query)
-
-
 class DeleteBranchRelationshipsQuery(Query):
     name: str = "delete_branch_relationships"
     insert_return: bool = False
@@ -52,31 +21,31 @@ class DeleteBranchRelationshipsQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         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
+// delete all relationships on this branch
+MATCH (s)-[r1]-(d)
+WHERE r1.branch = $branch_name
+CALL (r1) {
+  DELETE r1
+} IN TRANSACTIONS
+
+// check for any orphaned Node vertices and delete them
+WITH collect(DISTINCT s.uuid) + collect(DISTINCT d.uuid) AS nodes_uuids
+MATCH (s2:Node)-[r2]-(d2)
+WHERE NOT exists((s2)-[:IS_PART_OF]-(:Root))
+AND s2.uuid IN nodes_uuids
+CALL (r2) {
+  DELETE r2
+} IN TRANSACTIONS
+
+// reduce results to a single row
+WITH 1 AS one LIMIT 1
+
+// find any orphaned vertices and delete them
+MATCH (n)
+WHERE NOT exists((n)--())
+CALL (n) {
+  DELETE n
+} IN TRANSACTIONS
         """
         self.params["branch_name"] = self.branch_name
         self.add_to_query(query)