infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import reduce
-from typing import TYPE_CHECKING, Any, Iterable, Literal, Optional, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Iterable, Literal, TypeVar, overload
 
 from infrahub_sdk.utils import deep_merge_dict, is_valid_uuid
 
@@ -93,7 +93,7 @@ class ProfileAttributeIndex:
             self._profile_attributes_id_map[p_id] for p_id in profile_ids if p_id in self._profile_attributes_id_map
         ]
 
-        def get_profile_priority(nafd: NodeAttributesFromDB) -> tuple[Union[int, float], str]:
+        def get_profile_priority(nafd: NodeAttributesFromDB) -> tuple[int | float, str]:
             try:
                 return (int(nafd.attrs.get("profile_priority").value), nafd.node.get("uuid"))
             except (TypeError, AttributeError):
@@ -134,13 +134,13 @@ class NodeManager:
     async def query(
         cls,
         db: InfrahubDatabase,
-        schema: Union[NodeSchema, GenericSchema, ProfileSchema, TemplateSchema, str],
+        schema: NodeSchema | GenericSchema | ProfileSchema | TemplateSchema | str,
         filters: dict | None = ...,
         fields: dict | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
-        at: Union[Timestamp, str] | None = ...,
-        branch: Union[Branch, str] | None = ...,
+        at: Timestamp | str | None = ...,
+        branch: Branch | str | None = ...,
         include_source: bool = ...,
         include_owner: bool = ...,
         prefetch_relationships: bool = ...,
@@ -160,8 +160,8 @@ class NodeManager:
         fields: dict | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
-        at: Union[Timestamp, str] | None = ...,
-        branch: Union[Branch, str] | None = ...,
+        at: Timestamp | str | None = ...,
+        branch: Branch | str | None = ...,
         include_source: bool = ...,
         include_owner: bool = ...,
         prefetch_relationships: bool = ...,
@@ -180,8 +180,8 @@ class NodeManager:
         fields: dict | None = None,
         offset: int | None = None,
         limit: int | None = None,
-        at: Union[Timestamp, str] | None = None,
-        branch: Union[Branch, str] | None = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
         include_source: bool = False,
         include_owner: bool = False,
         prefetch_relationships: bool = False,
@@ -272,10 +272,10 @@ class NodeManager:
     async def count(
         cls,
         db: InfrahubDatabase,
-        schema: Union[type[SchemaProtocol], NodeSchema, GenericSchema, ProfileSchema, TemplateSchema, str],
-        filters: Optional[dict] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Union[Branch, str]] = None,
+        schema: type[SchemaProtocol] | NodeSchema | GenericSchema | ProfileSchema | TemplateSchema | str,
+        filters: dict | None = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
         account=None,  # noqa: ARG003
         partial_match: bool = False,
         branch_agnostic: bool = False,
@@ -317,8 +317,8 @@ class NodeManager:
         schema: RelationshipSchema,
         filters: dict,
         db: InfrahubDatabase,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Union[Branch, str]] = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
         branch_agnostic: bool = False,
     ) -> int:
         branch = await registry.get_branch(branch=branch, db=db)
@@ -346,11 +346,11 @@ class NodeManager:
         source_kind: str,
         schema: RelationshipSchema,
         filters: dict,
-        fields: Optional[dict] = None,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Union[Branch, str]] = None,
+        fields: dict | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
         branch_agnostic: bool = False,
         fetch_peers: bool = False,
     ) -> list[Relationship]:
@@ -420,8 +420,8 @@ class NodeManager:
         node_schema: NodeSchema,
         filters: dict,
         db: InfrahubDatabase,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Union[Branch, str]] = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
     ) -> int:
         branch = await registry.get_branch(branch=branch, db=db)
         at = Timestamp(at)
@@ -446,12 +446,12 @@ class NodeManager:
         direction: RelationshipHierarchyDirection,
         node_schema: NodeSchema,
         filters: dict,
-        fields: Optional[dict] = None,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Union[Branch, str]] = None,
-    ) -> dict[str, Any]:
+        fields: dict | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
+    ) -> dict[str, Node]:
         branch = await registry.get_branch(branch=branch, db=db)
         at = Timestamp(at)
 
@@ -1039,7 +1039,7 @@ class NodeManager:
         prefetch_relationships: bool = False,
         account=None,
         branch_agnostic: bool = False,
-    ) -> Optional[Any]:
+    ) -> Any | None:
         """Return one node based on its ID."""
         branch = await registry.get_branch(branch=branch, db=db)
 
@@ -1095,9 +1095,9 @@ class NodeManager:
         cls,
         db: InfrahubDatabase,
         ids: list[str],
-        fields: Optional[dict] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-        branch: Optional[Union[Branch, str]] = None,
+        fields: dict | None = None,
+        at: Timestamp | str | None = None,
+        branch: Branch | str | None = None,
         include_source: bool = False,
         include_owner: bool = False,
         prefetch_relationships: bool = False,
@@ -1158,7 +1158,7 @@ class NodeManager:
                 continue
 
             node = nodes_info_by_id[node_id]
-            new_node_data: dict[str, Union[str, AttributeFromDB]] = {
+            new_node_data: dict[str, str | AttributeFromDB] = {
                 "db_id": node.node_id,
                 "id": node_id,
                 "updated_at": node.updated_at,
@@ -1313,9 +1313,9 @@ class NodeManager:
         cls,
         db: InfrahubDatabase,
         nodes: list[Node],
-        branch: Optional[Union[Branch, str]] = None,
-        at: Optional[Union[Timestamp, str]] = None,
-    ) -> list[Any]:
+        branch: Branch | str | None = None,
+        at: Timestamp | str | None = None,
+    ) -> 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)

infrahub/core/merge.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from infrahub.core.constants import RepositoryInternalStatus
 from infrahub.core.diff.model.path import BranchTrackingId
@@ -39,8 +39,8 @@ class BranchMerger:
         diff_coordinator: DiffCoordinator,
         diff_merger: DiffMerger,
         diff_repository: DiffRepository,
-        destination_branch: Optional[Branch] = None,
-        service: Optional[InfrahubServices] = None,
+        destination_branch: Branch | None = None,
+        service: InfrahubServices | None = None,
     ):
         self.source_branch = source_branch
         self.destination_branch: Branch = destination_branch or registry.get_branch_from_registry()
@@ -51,9 +51,9 @@ class BranchMerger:
         self.migrations: list[SchemaUpdateMigrationInfo] = []
         self._merge_at = Timestamp()
 
-        self._source_schema: Optional[SchemaBranch] = None
-        self._destination_schema: Optional[SchemaBranch] = None
-        self._initial_source_schema: Optional[SchemaBranch] = None
+        self._source_schema: SchemaBranch | None = None
+        self._destination_schema: SchemaBranch | None = None
+        self._initial_source_schema: SchemaBranch | None = None
 
         self._service = service
 
@@ -173,7 +173,7 @@ class BranchMerger:
 
     async def merge(
         self,
-        at: Optional[Union[str, Timestamp]] = None,
+        at: str | Timestamp | None = None,
     ) -> EnrichedDiffRoot:
         """Merge the current branch into main."""
         if self.source_branch.name == registry.default_branch:

infrahub/core/migrations/__init__.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from .schema.attribute_name_update import AttributeNameUpdateMigration
 from .schema.node_attribute_add import NodeAttributeAddMigration
 from .schema.node_attribute_remove import NodeAttributeRemoveMigration
@@ -8,11 +6,12 @@ from .schema.node_remove import NodeRemoveMigration
 from .schema.placeholder_dummy import PlaceholderDummyMigration
 from .shared import SchemaMigration
 
-MIGRATION_MAP: dict[str, Optional[type[SchemaMigration]]] = {
+MIGRATION_MAP: dict[str, type[SchemaMigration] | None] = {
     "node.remove": NodeRemoveMigration,
     "node.branch.update": None,
     "node.attribute.add": NodeAttributeAddMigration,
     "node.attribute.remove": NodeAttributeRemoveMigration,
+    "node.inherit_from.update": NodeKindUpdateMigration,
     "node.name.update": NodeKindUpdateMigration,
     "node.namespace.update": NodeKindUpdateMigration,
     "node.relationship.remove": PlaceholderDummyMigration,

infrahub/core/migrations/graph/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Sequence, Union
+from typing import TYPE_CHECKING, Sequence
 
 from .m001_add_version_to_graph import Migration001
 from .m002_attribute_is_default import Migration002
@@ -20,13 +20,17 @@ from .m015_diff_format_update import Migration015
 from .m016_diff_delete_bug_fix import Migration016
 from .m017_add_core_profile import Migration017
 from .m018_uniqueness_nulls import Migration018
+from .m019_restore_rels_to_time import Migration019
+from .m020_duplicate_edges import Migration020
+from .m021_missing_hierarchy_merge import Migration021
+from .m022_add_generate_template_attr import Migration022
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
 
     from ..shared import ArbitraryMigration, GraphMigration, InternalSchemaMigration
 
-MIGRATIONS: list[type[Union[GraphMigration, InternalSchemaMigration, ArbitraryMigration]]] = [
+MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigration]] = [
     Migration001,
     Migration002,
     Migration003,
@@ -45,12 +49,17 @@ MIGRATIONS: list[type[Union[GraphMigration, InternalSchemaMigration, ArbitraryMi
     Migration016,
     Migration017,
     Migration018,
+    Migration019,
+    Migration020,
+    Migration021,
+    Migration022,
+    # Migration023,  Enable this migration once it has been tested on bigger databases
 ]
 
 
 async def get_graph_migrations(
     root: Root,
-) -> Sequence[Union[GraphMigration, InternalSchemaMigration, ArbitraryMigration]]:
+) -> Sequence[GraphMigration | InternalSchemaMigration | ArbitraryMigration]:
     applicable_migrations = []
     for migration_class in MIGRATIONS:
         migration = migration_class.init()

infrahub/core/migrations/graph/m017_add_core_profile.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Sequence
 
 from infrahub.core import registry
 from infrahub.core.migrations.shared import MigrationResult
-from infrahub.core.schema import GenericSchema
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.schema.manager import SchemaManager
 from infrahub.log import get_logger
@@ -31,14 +30,11 @@ class Migration017(InternalSchemaMigration):
         """
         Load CoreProfile schema node in db.
         """
-
-        core_profile = GenericSchema(**core_profile_schema_definition)
-
         default_branch = registry.get_branch_from_registry()
         manager = SchemaManager()
         manager.set_schema_branch(name=default_branch.name, schema=self.get_internal_schema())
 
         db.add_schema(manager.get_schema_branch(default_branch.name))
-        await manager.load_node_to_db(node=core_profile, db=db, branch=default_branch)
+        await manager.load_node_to_db(node=core_profile_schema_definition, db=db, branch=default_branch)
 
         return MigrationResult()

infrahub/core/migrations/graph/m018_uniqueness_nulls.py

@@ -50,18 +50,18 @@ class Migration018(InternalSchemaMigration):
         schema_branch = await manager.load_schema_from_db(db=db, branch=default_branch)
         manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
 
-        for schema_kind in schema_branch.node_names + schema_branch.generic_names:
+        for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
             schema = schema_branch.get(name=schema_kind, duplicate=False)
             if not isinstance(schema, NodeSchema | GenericSchema):
                 continue
 
-            schema_constraint_path_groups = schema.get_unique_constraint_schema_attribute_paths(
+            uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(
                 schema_branch=schema_branch
             )
             includes_optional_attr: bool = False
 
-            for constraint_group in schema_constraint_path_groups:
-                for schema_attribute_path in constraint_group:
+            for uniqueness_constraint_path in uniqueness_constraint_paths:
+                for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
                     if (
                         schema_attribute_path.attribute_schema
                         and schema_attribute_path.attribute_schema.optional is True

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:  # noqa: ARG002
+        """
+        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:  # noqa: ARG002
+        """
+        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:  # noqa: ARG002
+        """
+        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:  # noqa: ARG002
+        result = MigrationResult()
+        return result