infrahub-server 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

infrahub/core/migrations/graph/m019_restore_rels_to_time.py

@@ -0,0 +1,256 @@
+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 ...constants import GLOBAL_BRANCH_NAME, BranchSupportType
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class FixBranchAwareEdgesQuery(Query):
+    name = "replace_global_edges"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        """
+        Between a Node and a Relationship, if Relationship.branch_support=aware, replace any global edge
+        to the branch of a non-global edge leaving out of the Relationship node. Note that there can't
+        be multiple non-global branches on these edges, as a dedicated Relationship node would exist for that.
+        """
+
+        query = """
+        MATCH (node:Node)-[global_edge:IS_RELATED {branch: $global_branch}]-(rel:Relationship)
+        WHERE rel.branch_support=$branch_aware
+        MATCH (rel)-[non_global_edge:IS_RELATED]-(node_2: Node)
+        WHERE non_global_edge.branch <> $global_branch
+        SET global_edge.branch = non_global_edge.branch
+        """
+
+        params = {
+            "global_branch": GLOBAL_BRANCH_NAME,
+            "branch_aware": BranchSupportType.AWARE.value,
+            "branch_agnostic": BranchSupportType.AGNOSTIC.value,
+        }
+
+        self.params.update(params)
+        self.add_to_query(query)
+
+
+class SetMissingToTimeQuery(Query):
+    name = "set_missing_to_time"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        """
+        If both a deleted edge and an active edge with no time exist between 2 nodes on the same branch,
+        set `to` time of active edge using `from` time of the deleted one. This would typically happen after having
+        replaced a deleted edge on global branch by correct branch with above query.
+        """
+
+        query = """
+        MATCH (node:Node)-[deleted_edge:IS_RELATED {status: "deleted"}]-(rel:Relationship)
+        MATCH (rel)-[active_edge:IS_RELATED {status: "active"}]-(node)
+        WHERE active_edge.to IS NULL AND deleted_edge.branch = active_edge.branch
+        SET active_edge.to = deleted_edge.from
+        """
+
+        self.add_to_query(query)
+
+
+class DeleteNodesRelsQuery(Query):
+    name = "delete_relationships_of_deleted_nodes"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        """
+        Some nodes may have been incorrectly deleted, typically, while these nodes edges connected to Root
+        are correctly deleted, edges connected to other `Node` through a `Relationship` node may still be active.
+        Following query correctly deletes these edges by both setting correct to time and creating corresponding deleted edge.
+        """
+
+        query = """
+        MATCH (deleted_node: Node)-[deleted_edge:IS_PART_OF {status: "deleted"}]->(:Root)
+        MATCH (deleted_node)-[:IS_RELATED]-(rel:Relationship)
+
+        // exclude nodes having been deleted through migration. find those with same uuid and exclude the one with earlier
+        // timestamp on active branch
+        WHERE NOT EXISTS {
+          MATCH (deleted_node)-[e1:IS_RELATED]-(rel)-[e2:IS_RELATED]-(other_node)
+          WITH deleted_node, other_node, MIN(e1.from) AS min_e1_from, MIN(e2.from) AS min_e2_from
+          WHERE deleted_node <> other_node AND deleted_node.uuid = other_node.uuid AND min_e1_from < min_e2_from
+        }
+
+        // Note that if an AWARE node has been deleted on a branch and relationship is AGNOSTIC, we do not "delete" this relationship
+        // right now as this aware node might exist on another branch.
+
+        // Set to time if there is an active edge:
+        // - 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
+            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
+            SET peer_active_edge.to = deleted_edge.from
+        }
+
+        // Get distinct rel nodes linked to a deleted node, with the time at which we should delete rel edges.
+        // Take the MAX time so if it does not take the deleted time of a node deleted through a duplication migration.
+        WITH DISTINCT rel,
+            deleted_edge.branch AS deleted_edge_branch,
+            deleted_edge.branch_level AS branch_level,
+            MAX(deleted_edge.from) as deleted_time,
+            deleted_node.branch_support as deleted_node_branch_support
+
+
+        // No need to check deleted edge branch because
+        // If deleted_node has different branch support type (agnostic/aware) than rel type,
+        // there might already be a deleted edge that we would not match if we filter on deleted_edge_branch.
+        // If both are aware, it still works, as we would have one Relationship node for each branch on which this relationship exists.
+        MATCH (rel)-[]-(peer_2)
+        WHERE NOT exists((rel)-[{status: "deleted"}]-(peer_2))
+
+
+        // If res is agnostic and delete node is agnostic, we should delete on global branch
+        // If rel is aware and deleted node is aware, we should use deleted edge branch
+        // If rel is aware and delete node is agnostic, we need to create deleted edges for every distinct branch on which this relationship exists.
+        WITH DISTINCT
+            CASE
+                // Branch on which `deleted` edge should be created depends on rel.branch_support.
+                WHEN rel.branch_support = $branch_agnostic
+                THEN CASE
+                    WHEN deleted_node_branch_support = $branch_agnostic THEN [$global_branch]
+                    ELSE []
+                END
+                ELSE
+                CASE
+                    WHEN deleted_node_branch_support = $branch_agnostic
+                    THEN COLLECT {
+                        WITH rel
+                        MATCH (rel)-[active_edge {status: "active"}]-(peer_2)
+                        RETURN DISTINCT active_edge.branch
+                    }
+                    ELSE
+                    CASE
+                        // if no active edge on this branch exists it means this relationship node is dedicated for another branch
+                        WHEN exists((rel)-[{status: "active", branch: deleted_edge_branch}]-(peer_2)) THEN [deleted_edge_branch]
+                        ELSE []
+                    END
+                END
+            END AS branches,
+          branch_level,
+          deleted_time,
+          peer_2,
+          rel
+
+        UNWIND branches as branch
+
+        // Then creates `deleted` edge.
+        // 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
+            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
+            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
+            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
+            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
+            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
+            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
+            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
+            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
+            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
+            MATCH (rel)<-[:HAS_SOURCE]-(peer_2)
+            MERGE (rel)<-[:HAS_SOURCE {status: "deleted", branch: branch, branch_level: branch_level, from: deleted_time}]-(peer_2)
+        }
+        """
+
+        params = {
+            "global_branch": GLOBAL_BRANCH_NAME,
+            "branch_aware": BranchSupportType.AWARE.value,
+            "branch_agnostic": BranchSupportType.AGNOSTIC.value,
+        }
+
+        self.params.update(params)
+        self.add_to_query(query)
+
+
+class Migration019(GraphMigration):
+    """
+    Fix corrupted state introduced by Migration012 when duplicating a CoreAccount (branch Aware)
+    being part of a CoreStandardGroup (branch Agnostic). Database is corrupted at multiple points:
+    - Old CoreAccount node <> group_member node `active` edge has no `to` time (possibly because of #5590).
+    - Old CoreAccount node <> group_member node `deleted` edge is on `$global_branch` branch instead of `main`.
+    - New CoreAccount node <> group_member node `active` edge is on `$global_branch` branch instead of `main`.
+
+    Also, users having deleted corresponding CoreStandardGroup will also have the following data corruption,
+    as deletion did not happen correctly due to above issues:
+    - Both CoreAccount <> group_member and CoreStandardGroup <> group_member edges
+      have not been deleted (ie status is `active` without `to` time and no additional `deleted` edge).
+
+    This migration fixes all above issues to have consistent edges, and fixes IFC-1204.
+    """
+
+    name: str = "019_fix_edges_state"
+    minimum_version: int = 18
+    queries: Sequence[type[Query]] = [FixBranchAwareEdgesQuery, SetMissingToTimeQuery, DeleteNodesRelsQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+        return result

infrahub/core/migrations/graph/m020_duplicate_edges.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.constants.database import DatabaseEdgeType
+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 DeleteDuplicateHasValueEdgesQuery(Query):
+    name = "delete_duplicate_has_value_edges"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        query = """
+// -------------------
+// find Attribute nodes with multiple identical edges to AttributeValue nodes with the same value
+// -------------------
+MATCH (a:Attribute)-[e:HAS_VALUE]->(av:AttributeValue)
+WITH a, e.branch AS branch, e.branch_level AS branch_level, e.status AS status, e.from AS from, e.to AS to,
+    av.value AS attr_val, av.is_default AS attr_default, COUNT(*) AS num_duplicate_edges
+WHERE num_duplicate_edges > 1
+// -------------------
+// get the the one AttributeValue we want to use
+// -------------------
+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
+    MATCH (av:AttributeValue {value: attr_val, is_default: attr_default})
+    RETURN av AS the_one_av
+    ORDER by %(id_func)s(av) ASC
+    LIMIT 1
+}
+UNWIND details_list AS details_item
+WITH attr_val, attr_default, the_one_av,
+    details_item[0] AS a, details_item[1] AS branch, details_item[2] AS branch_level,
+    details_item[3] AS status, details_item[4] AS from, details_item[5] AS to
+// -------------------
+// get/create the one edge to keep
+// -------------------
+CREATE (a)-[fresh_e:HAS_VALUE {branch: branch, branch_level: branch_level, status: status, from: from}]->(the_one_av)
+SET fresh_e.to = to
+WITH a, branch, status, from, to, attr_val, attr_default, %(id_func)s(fresh_e) AS e_id_to_keep
+// -------------------
+// get the identical edges for a given set of Attribute node, edge properties, AttributeValue.value
+// -------------------
+CALL {
+    // -------------------
+    // 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
+    AND (e.to = to OR (e.to IS NULL AND to IS NULL))
+    DELETE e
+}
+// -------------------
+// delete any orphaned AttributeValue nodes
+// -------------------
+WITH NULL AS nothing
+LIMIT 1
+MATCH (orphaned_av:AttributeValue)
+WHERE NOT exists((orphaned_av)-[]-())
+DELETE orphaned_av
+        """ % {"id_func": db.get_id_function_name()}
+        self.add_to_query(query)
+
+
+class DeleteDuplicateBooleanEdgesQuery(Query):
+    name = "delete_duplicate_booleans_edges"
+    type = QueryType.WRITE
+    insert_return = False
+    edge_type: DatabaseEdgeType | None = None
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        if not self.edge_type:
+            raise RuntimeError("edge_type is required for this query")
+        query = """
+// -------------------
+// find Attribute nodes with multiple identical edges to Boolean nodes
+// -------------------
+MATCH (a:Attribute)-[e:%(edge_type)s]->(b)
+WITH a, e.branch AS branch, e.branch_level AS branch_level, e.status AS status, e.from AS from, e.to AS to, b, COUNT(*) AS num_duplicate_edges
+WHERE num_duplicate_edges > 1
+// -------------------
+// get the identical edges for a given set of Attribute node, edge properties, Boolean
+// -------------------
+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
+    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
+    AND (e.to = to OR (e.to IS NULL AND to IS NULL))
+    DELETE e
+}
+        """ % {"edge_type": self.edge_type.value, "id_func": db.get_id_function_name()}
+        self.add_to_query(query)
+
+
+class DeleteDuplicateIsVisibleEdgesQuery(DeleteDuplicateBooleanEdgesQuery):
+    name = "delete_duplicate_is_visible_edges"
+    type = QueryType.WRITE
+    insert_return = False
+    edge_type = DatabaseEdgeType.IS_VISIBLE
+
+
+class DeleteDuplicateIsProtectedEdgesQuery(DeleteDuplicateBooleanEdgesQuery):
+    name = "delete_duplicate_is_protected_edges"
+    type = QueryType.WRITE
+    insert_return = False
+    edge_type = DatabaseEdgeType.IS_PROTECTED
+
+
+class Migration020(GraphMigration):
+    """
+    1. Find duplicate edges. These can be duplicated if multiple AttributeValue nodes with the same value exist b/c of concurrent
+        database updates.
+        a. (a:Attribute)-[e:HAS_VALUE]->(av:AttributeValue)
+            grouped by (a, e.branch, e.from, e.to, e.status, av.value, av.is_default) to determine the number of duplicates.
+        b. (a:Attribute)-[e:HAS_VALUE]->(b:Boolean)
+            grouped by (a, e.branch, e.from, e.status, b) to determine the number of duplicates.
+    2. For a given set of duplicate edges
+        a. delete all of the duplicate edges
+        b. merge one edge with the properties of the deleted edges
+    3. If there are any orphaned AttributeValue nodes after these changes, then delete them
+
+    This migration does not account for consolidating duplicated AttributeValue nodes because more might be created
+    in the future due to concurrent database updates. A migration to consolidate duplicated AttributeValue nodes
+    should be run when we find a way to stop duplicate AttributeValue nodes from being created
+    """
+
+    name: str = "020_delete_duplicate_edges"
+    minimum_version: int = 19
+    queries: Sequence[type[Query]] = [
+        DeleteDuplicateHasValueEdgesQuery,
+        DeleteDuplicateIsVisibleEdgesQuery,
+        DeleteDuplicateIsProtectedEdgesQuery,
+    ]
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        # skip the transaction b/c it will run out of memory on a large database
+        return await self.do_execute(db=db)
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+        return result

infrahub/core/migrations/query/node_duplicate.py

@@ -48,19 +48,37 @@ class NodeDuplicateQuery(Query):
 
     @staticmethod
     def _render_sub_query_per_rel_type(
-        rel_name: str, rel_type: str, rel_def: FieldInfo, direction: GraphRelDirection
+        rel_name: str,
+        rel_type: str,
+        rel_def: FieldInfo,
     ) -> str:
         subquery = [
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
-        if rel_def.default.direction in [direction, GraphRelDirection.EITHER]:
-            subquery.append(f"CREATE (new_node)-[:{rel_type} $rel_props_new ]->(peer_node)")
-            subquery.append(f"CREATE (active_node)-[:{rel_type} $rel_props_prev ]->(peer_node)")
-        elif rel_def.default.direction in [direction, GraphRelDirection.EITHER]:
-            subquery.append(f"CREATE (new_node)<-[:{rel_type} $rel_props_new ]-(peer_node)")
-            subquery.append(f"CREATE (active_node)<-[:{rel_type} $rel_props_prev ]-(peer_node)")
+        if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]:
+            subquery.append(f"""
+                CREATE (new_node)-[new_active_edge:{rel_type} $rel_props_new ]->(peer_node)
+                SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                """)
+            subquery.append(f"""
+                CREATE (active_node)-[deleted_edge:{rel_type} $rel_props_prev ]->(peer_node)
+                SET deleted_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET deleted_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                """)
+        elif rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]:
+            subquery.append(f"""
+                CREATE (new_node)<-[new_active_edge:{rel_type} $rel_props_new ]-(peer_node)
+                SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                """)
+            subquery.append(f"""
+                CREATE (active_node)<-[deleted_edge:{rel_type} $rel_props_prev ]-(peer_node)
+                SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                """)
         subquery.append("RETURN peer_node as p2")
         return "\n".join(subquery)
 
@@ -68,7 +86,9 @@ class NodeDuplicateQuery(Query):
     def _render_sub_query_out(cls) -> str:
         sub_queries_out = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, rel_def=rel_def, direction=GraphRelDirection.OUTBOUND
+                rel_name="rel_outband",
+                rel_type=rel_type,
+                rel_def=rel_def,
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
         ]
@@ -79,7 +99,9 @@ class NodeDuplicateQuery(Query):
     def _render_sub_query_in(cls) -> str:
         sub_queries_in = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, rel_def=rel_def, direction=GraphRelDirection.INBOUND
+                rel_name="rel_inband",
+                rel_type=rel_type,
+                rel_def=rel_def,
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
         ]
@@ -94,19 +116,16 @@ class NodeDuplicateQuery(Query):
         self.params["previous_node"] = self.previous_node.model_dump()
 
         self.params["current_time"] = self.at.to_string()
-        self.params["branch_name"] = self.branch.name
+        self.params["branch"] = self.branch.name
+        self.params["branch_level"] = self.branch.hierarchy_level
         self.params["branch_support"] = self.new_node.branch_support
 
         self.params["rel_props_new"] = {
-            "branch": self.branch.name,
-            "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.ACTIVE.value,
             "from": self.at.to_string(),
         }
 
         self.params["rel_props_prev"] = {
-            "branch": self.branch.name,
-            "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.DELETED.value,
             "from": self.at.to_string(),
         }
@@ -141,12 +160,12 @@ class NodeDuplicateQuery(Query):
             LIMIT 1
         }
         WITH n1 as active_node, rel_outband1 as rel_outband, p1 as peer_node, new_node
-        WHERE rel_outband.status = "active"
+        WHERE rel_outband.status = "active" AND rel_outband.to IS NULL
         CALL {
             %(sub_query_out)s
         }
         WITH p2 as peer_node, rel_outband, active_node, new_node
-        FOREACH (i in CASE WHEN rel_outband.branch = $branch_name THEN [1] ELSE [] END |
+        FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_outband.to = $current_time
         )
         WITH active_node, new_node
@@ -160,14 +179,15 @@ class NodeDuplicateQuery(Query):
             LIMIT 1
         }
         WITH n1 as active_node, rel_inband1 as rel_inband, p1 as peer_node, new_node
-        WHERE rel_inband.status = "active"
+        WHERE rel_inband.status = "active" AND rel_inband.to IS NULL
         CALL {
             %(sub_query_in)s
         }
         WITH p2 as peer_node, rel_inband, active_node, new_node
-        FOREACH (i in CASE WHEN rel_inband.branch = $branch_name THEN [1] ELSE [] END |
+        FOREACH (i in CASE WHEN rel_inband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_inband.to = $current_time
         )
+
         RETURN DISTINCT new_node
         """ % {
             "branch_filter": branch_filter,

infrahub/core/migrations/schema/node_remove.py

@@ -15,17 +15,28 @@ if TYPE_CHECKING:
 
 class NodeRemoveMigrationBaseQuery(MigrationQuery):
     def render_sub_query_per_rel_type(
-        self, rel_name: str, rel_type: str, rel_def: FieldInfo, direction: GraphRelDirection
+        self,
+        rel_name: str,
+        rel_type: str,
+        rel_def: FieldInfo,
     ) -> str:
         subquery = [
             f"WITH peer_node, {rel_name}, active_node",
             f"WITH peer_node, {rel_name}, active_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
-        if rel_def.default.direction in [direction, GraphRelDirection.EITHER]:
-            subquery.append(f"CREATE (active_node)-[:{rel_type} $rel_props ]->(peer_node)")
-        elif rel_def.default.direction in [direction, GraphRelDirection.EITHER]:
-            subquery.append(f"CREATE (active_node)<-[:{rel_type} $rel_props ]-(peer_node)")
+        if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]:
+            subquery.append(f"""
+                CREATE (active_node)-[edge:{rel_type} $rel_props ]->(peer_node)
+                SET edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                """)
+        elif rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]:
+            subquery.append(f"""
+                CREATE (active_node)<-[edge:{rel_type} $rel_props ]-(peer_node)
+                SET edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                """)
         subquery.append("RETURN peer_node as p2")
         return "\n".join(subquery)
 
@@ -38,10 +49,10 @@ class NodeRemoveMigrationBaseQuery(MigrationQuery):
 
         self.params["current_time"] = self.at.to_string()
         self.params["branch_name"] = self.branch.name
+        self.params["branch"] = self.branch.name
+        self.params["branch_level"] = self.branch.hierarchy_level
 
         self.params["rel_props"] = {
-            "branch": self.branch.name,
-            "branch_level": self.branch.hierarchy_level,
             "status": RelationshipStatus.DELETED.value,
             "from": self.at.to_string(),
         }
@@ -99,7 +110,7 @@ class NodeRemoveMigrationQueryIn(NodeRemoveMigrationBaseQuery):
             %(sub_query)s
         }
         WITH p2 as peer_node, rel_inband, active_node
-        FOREACH (i in CASE WHEN rel_inband.branch = $branch_name THEN [1] ELSE [] END |
+        FOREACH (i in CASE WHEN rel_inband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_inband.to = $current_time
         )
         """ % {"sub_query": sub_query, "branch_filter": branch_filter}
@@ -108,7 +119,9 @@ class NodeRemoveMigrationQueryIn(NodeRemoveMigrationBaseQuery):
     def render_sub_query_in(self) -> str:
         sub_queries_in = [
             self.render_sub_query_per_rel_type(
-                rel_name="rel_inband", rel_type=rel_type, rel_def=rel_def, direction=GraphRelDirection.INBOUND
+                rel_name="rel_inband",
+                rel_type=rel_type,
+                rel_def=rel_def,
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
         ]
@@ -142,8 +155,7 @@ class NodeRemoveMigrationQueryOut(NodeRemoveMigrationBaseQuery):
         CALL {
             %(sub_query)s
         }
-        WITH p2 as peer_node, rel_outband, active_node
-        FOREACH (i in CASE WHEN rel_outband.branch = $branch_name THEN [1] ELSE [] END |
+        FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_outband.to = $current_time
         )
         """ % {"sub_query": sub_query, "branch_filter": branch_filter}
@@ -153,7 +165,9 @@ class NodeRemoveMigrationQueryOut(NodeRemoveMigrationBaseQuery):
     def render_sub_query_out(self) -> str:
         sub_queries_out = [
             self.render_sub_query_per_rel_type(
-                rel_name="rel_outband", rel_type=rel_type, rel_def=rel_def, direction=GraphRelDirection.OUTBOUND
+                rel_name="rel_outband",
+                rel_type=rel_type,
+                rel_def=rel_def,
             )
             for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
         ]

infrahub/core/migrations/shared.py

@@ -120,15 +120,17 @@ class GraphMigration(BaseModel):
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
         async with db.start_transaction() as ts:
-            result = MigrationResult()
+            return await self.do_execute(db=ts)
 
-            for migration_query in self.queries:
-                try:
-                    query = await migration_query.init(db=ts)
-                    await query.execute(db=ts)
-                except Exception as exc:  # pylint: disable=broad-exception-caught
-                    result.errors.append(str(exc))
-                    return result
+    async def do_execute(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+        for migration_query in self.queries:
+            try:
+                query = await migration_query.init(db=db)
+                await query.execute(db=db)
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                result.errors.append(str(exc))
+                return result
 
         return result