infrahub-server 1.5.0b1__py3-none-any.whl → 1.5.1__py3-none-any.whl

infrahub/core/diff/query/merge.py

@@ -49,11 +49,18 @@ WITH node_diff_map, is_node_kind_migration, CASE
     WHEN is_node_kind_migration THEN $migrated_kinds_id_map[node_diff_map.uuid]
     ELSE NULL
 END AS node_db_id
+
+// ------------------------------
+// find the correct Node if the Node had its kind/inheritance migrated
+// and there are multiple Nodes with the same UUID
+// ------------------------------
 CALL (node_diff_map, node_db_id) {
-    MATCH (n:Node {uuid: node_diff_map.uuid})
-    WHERE node_db_id IS NULL
-    OR %(id_func)s(n) = node_db_id
+    MATCH (n:Node {uuid: node_diff_map.uuid})-[n_is_part_of:IS_PART_OF]->(:Root)
+    WHERE node_db_id IS NULL OR %(id_func)s(n) = node_db_id
+    AND n_is_part_of.branch IN [$source_branch, $target_branch]
     RETURN n
+    ORDER BY n_is_part_of.branch_level DESC, n_is_part_of.from DESC, n_is_part_of.status ASC
+    LIMIT 1
 }
 WITH n, node_diff_map, is_node_kind_migration
 CALL (n, node_diff_map, is_node_kind_migration) {
@@ -224,16 +231,28 @@ CALL (n, node_diff_map, is_node_kind_migration) {
                     ELSE NULL
                 END AS rel_peer_db_id
             // ------------------------------
+            // find the correct relationship peer if the peer had its kind/inheritance migrated
+            // and there are multiple Nodes with the same UUID
+            // ------------------------------
+            CALL (rel_peer_id, rel_peer_db_id) {
+                MATCH (rel_peer:Node {uuid: rel_peer_id})-[target_is_part_of:IS_PART_OF]->(:Root)
+                WHERE (rel_peer_db_id IS NULL OR %(id_func)s(rel_peer) = rel_peer_db_id)
+                AND target_is_part_of.branch IN [$source_branch, $target_branch]
+                RETURN rel_peer
+                ORDER BY target_is_part_of.branch_level DESC, target_is_part_of.from DESC, target_is_part_of.status ASC
+                LIMIT 1
+            }
+            WITH rel_name, related_rel_status, rel_peer
+            // ------------------------------
             // determine the directions of each IS_RELATED
             // ------------------------------
-            CALL (n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status) {
+            CALL (n, rel_name, rel_peer, related_rel_status) {
                 MATCH (n)
                     -[source_r_rel_1:IS_RELATED]
                     -(r:Relationship {name: rel_name})
                     -[source_r_rel_2:IS_RELATED]
-                    -(rel_peer:Node {uuid: rel_peer_id})
-                WHERE (rel_peer_db_id IS NULL OR %(id_func)s(rel_peer) = rel_peer_db_id)
-                AND source_r_rel_1.branch IN [$source_branch, $target_branch]
+                    -(rel_peer)
+                WHERE source_r_rel_1.branch IN [$source_branch, $target_branch]
                 AND source_r_rel_2.branch IN [$source_branch, $target_branch]
                 AND source_r_rel_1.from <= $at AND source_r_rel_1.to IS NULL
                 AND source_r_rel_2.from <= $at AND source_r_rel_2.to IS NULL
@@ -251,37 +270,34 @@ CALL (n, node_diff_map, is_node_kind_migration) {
                 source_r_rel_1.hierarchy AS r1_hierarchy,
                 source_r_rel_2.hierarchy AS r2_hierarchy
             }
-            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
-            CALL (n, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status) {
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer, related_rel_status
+            CALL (n, rel_name, rel_peer, related_rel_status) {
                 OPTIONAL MATCH (n)
                     -[target_r_rel_1:IS_RELATED {branch: $target_branch, status: "active"}]
                     -(:Relationship {name: rel_name})
                     -[target_r_rel_2:IS_RELATED {branch: $target_branch, status: "active"}]
-                    -(rel_peer:Node {uuid: rel_peer_id})
+                    -(rel_peer)
                 WHERE related_rel_status = "deleted"
-                AND (rel_peer_db_id IS NULL OR %(id_func)s(rel_peer) = rel_peer_db_id)
                 AND target_r_rel_1.from <= $at AND target_r_rel_1.to IS NULL
                 AND target_r_rel_2.from <= $at AND target_r_rel_2.to IS NULL
                 SET target_r_rel_1.to = $at
                 SET target_r_rel_2.to = $at
             }
-            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer, related_rel_status
             // ------------------------------
             // conditionally create new IS_RELATED relationships on target_branch, if necessary
             // ------------------------------
-            CALL (n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, rel_peer_db_id, related_rel_status) {
-                MATCH (p:Node {uuid: rel_peer_id})
-                WHERE rel_peer_db_id IS NULL OR %(id_func)s(p) = rel_peer_db_id
+            CALL (n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer, related_rel_status) {
                 OPTIONAL MATCH (n)
                     -[r_rel_1:IS_RELATED {branch: $target_branch, status: related_rel_status}]
                     -(:Relationship {name: rel_name})
                     -[r_rel_2:IS_RELATED {branch: $target_branch, status: related_rel_status}]
-                    -(p)
+                    -(rel_peer)
                 WHERE r_rel_1.from <= $at
                 AND (r_rel_1.to >= $at OR r_rel_1.to IS NULL)
                 AND r_rel_2.from <= $at
                 AND (r_rel_2.to >= $at OR r_rel_2.to IS NULL)
-                WITH p, r_rel_1, r_rel_2
+                WITH rel_peer, r_rel_1, r_rel_2
                 WHERE r_rel_1 IS NULL
                 AND r_rel_2 IS NULL
                 // ------------------------------
@@ -301,19 +317,19 @@ CALL (n, node_diff_map, is_node_kind_migration) {
                         <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         -(r)
                 }
-                CALL (r, p, r2_dir, r2_hierarchy, related_rel_status) {
-                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                CALL (r, rel_peer, r2_dir, r2_hierarchy, related_rel_status) {
+                    WITH r, rel_peer, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "r"
                     CREATE (r)
                         -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
-                        ->(p)
+                        ->(rel_peer)
                 }
-                CALL (r, p, r2_dir, r2_hierarchy, related_rel_status) {
-                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                CALL (r, rel_peer, r2_dir, r2_hierarchy, related_rel_status) {
+                    WITH r, rel_peer, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "l"
                     CREATE (r)
                         <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
-                        -(p)
+                        -(rel_peer)
                 }
             }
         }

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 42
+GRAPH_VERSION = 44

infrahub/core/initialization.py

@@ -50,7 +50,7 @@ async def get_root_node(db: InfrahubDatabase, initialize: bool = False) -> Root:
     roots = await Root.get_list(db=db)
     if len(roots) == 0 and not initialize:
         raise DatabaseError(
-            "The Database hasn't been initialized for Infrahub, please run 'infrahub db init' or 'infrahub server start' to initialize the database."
+            "The Database hasn't been initialized for Infrahub, please 'infrahub server start' to initialize the database."
         )
 
     if len(roots) == 0:
@@ -137,7 +137,8 @@ async def add_indexes(db: InfrahubDatabase) -> None:
     await index_manager.add()
 
 
-async def initialization(db: InfrahubDatabase, add_database_indexes: bool = False) -> None:
+async def initialization(db: InfrahubDatabase, add_database_indexes: bool = False) -> bool:
+    """Run initialization and setup, returns a boolean to indicate if it's the initial setup."""
     if config.SETTINGS.database.db_type == config.DatabaseType.MEMGRAPH:
         session = await db.session()
         await session.run(query="SET DATABASE SETTING 'log.level' TO 'INFO'")
@@ -148,6 +149,7 @@ async def initialization(db: InfrahubDatabase, add_database_indexes: bool = Fals
     # Initialize the database and Load the Root node
     # ---------------------------------------------------
     async with lock.registry.initialization():
+        first_time_initialization = len(await Root.get_list(db=db)) == 0
         log.debug("Checking Root Node")
         await initialize_registry(db=db, initialize=True)
 
@@ -210,6 +212,7 @@ async def initialization(db: InfrahubDatabase, add_database_indexes: bool = Fals
     ip_namespace = await get_default_ipnamespace(db=db)
     if ip_namespace:
         registry.default_ipnamespace = ip_namespace.id
+    return first_time_initialization
 
 
 async def create_root_node(db: InfrahubDatabase) -> Root:

infrahub/core/migrations/__init__.py

@@ -1,5 +1,6 @@
 from .schema.attribute_kind_update import AttributeKindUpdateMigration
 from .schema.attribute_name_update import AttributeNameUpdateMigration
+from .schema.attribute_supports_profile import AttributeSupportsProfileUpdateMigration
 from .schema.node_attribute_add import NodeAttributeAddMigration
 from .schema.node_attribute_remove import NodeAttributeRemoveMigration
 from .schema.node_kind_update import NodeKindUpdateMigration
@@ -19,6 +20,8 @@ MIGRATION_MAP: dict[str, type[SchemaMigration] | None] = {
     "attribute.name.update": AttributeNameUpdateMigration,
     "attribute.branch.update": None,
     "attribute.kind.update": AttributeKindUpdateMigration,
+    "attribute.optional.update": AttributeSupportsProfileUpdateMigration,
+    "attribute.read_only.update": AttributeSupportsProfileUpdateMigration,
     "relationship.branch.update": None,
     "relationship.direction.update": None,
     "relationship.identifier.update": PlaceholderDummyMigration,

infrahub/core/migrations/exceptions.py

@@ -0,0 +1,4 @@
+class MigrationFailureError(Exception):
+    def __init__(self, errors: list[str]) -> None:
+        super().__init__()
+        self.errors = errors

infrahub/core/migrations/graph/__init__.py

@@ -41,16 +41,17 @@ from .m036_drop_attr_value_index import Migration036
 from .m037_index_attr_vals import Migration037
 from .m038_redo_0000_prefix_fix import Migration038
 from .m039_ipam_reconcile import Migration039
-from .m040_profile_attrs_in_db import Migration040
-from .m041_create_hfid_display_label_in_db import Migration041
-from .m042_backfill_hfid_display_label_in_db import Migration042
+from .m040_duplicated_attributes import Migration040
+from .m041_deleted_dup_edges import Migration041
+from .m042_profile_attrs_in_db import Migration042
+from .m043_create_hfid_display_label_in_db import Migration043
+from .m044_backfill_hfid_display_label_in_db import Migration044
 
 if TYPE_CHECKING:
-    from infrahub.core.root import Root
+    from ..shared import MigrationTypes
 
-    from ..shared import ArbitraryMigration, GraphMigration, InternalSchemaMigration
 
-MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigration]] = [
+MIGRATIONS: list[type[MigrationTypes]] = [
     Migration001,
     Migration002,
     Migration003,
@@ -93,25 +94,23 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration040,
     Migration041,
     Migration042,
+    Migration043,
+    Migration044,
 ]
 
 
-async def get_graph_migrations(
-    root: Root,
-) -> Sequence[GraphMigration | InternalSchemaMigration | ArbitraryMigration]:
+async def get_graph_migrations(current_graph_version: int) -> Sequence[MigrationTypes]:
     applicable_migrations = []
     for migration_class in MIGRATIONS:
         migration = migration_class.init()
-        if root.graph_version > migration.minimum_version:
+        if current_graph_version > migration.minimum_version:
             continue
         applicable_migrations.append(migration)
 
     return applicable_migrations
 
 
-def get_migration_by_number(
-    migration_number: int | str,
-) -> GraphMigration | InternalSchemaMigration | ArbitraryMigration:
+def get_migration_by_number(migration_number: int | str) -> MigrationTypes:
     # Convert to string and pad with zeros if needed
     try:
         num = int(migration_number)

infrahub/core/migrations/graph/load_schema_branch.py

@@ -0,0 +1,21 @@
+from infrahub.core import registry
+from infrahub.core.branch import Branch
+from infrahub.core.schema import SchemaRoot, internal_schema
+from infrahub.core.schema.manager import SchemaManager
+from infrahub.core.schema.schema_branch import SchemaBranch
+from infrahub.database import InfrahubDatabase
+from infrahub.exceptions import InitializationError
+
+
+async def get_or_load_schema_branch(db: InfrahubDatabase, branch: Branch) -> SchemaBranch:
+    try:
+        if registry.schema.has_schema_branch(branch.name):
+            return registry.schema.get_schema_branch(branch.name)
+    except InitializationError:
+        schema_manager = SchemaManager()
+        registry.schema = schema_manager
+        internal_schema_root = SchemaRoot(**internal_schema)
+        registry.schema.register_schema(schema=internal_schema_root)
+    schema_branch = await registry.schema.load_schema_from_db(db=db, branch=branch)
+    registry.schema.set_schema_branch(name=branch.name, schema=schema_branch)
+    return schema_branch

infrahub/core/migrations/graph/m013_convert_git_password_credential.py

@@ -286,7 +286,7 @@ class Migration013AddInternalStatusData(AttributeAddQuery):
         kwargs.pop("branch", None)
 
         super().__init__(
-            node_kind="CoreGenericRepository",
+            node_kinds=["CoreGenericRepository"],
             attribute_name="internal_status",
             attribute_kind="Dropdown",
             branch_support=BranchSupportType.LOCAL.value,

infrahub/core/migrations/graph/m037_index_attr_vals.py

@@ -3,13 +3,10 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from rich.console import Console
-
 from infrahub.constants.database import IndexType
 from infrahub.core.attribute import MAX_STRING_LENGTH
-from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.migrations.shared import MigrationResult, get_migration_console
 from infrahub.core.query import Query, QueryType
-from infrahub.core.timestamp import Timestamp
 from infrahub.database.index import IndexItem
 from infrahub.database.neo4j import IndexManagerNeo4j
 from infrahub.log import get_logger
@@ -467,13 +464,11 @@ class Migration037(ArbitraryMigration):
         return result
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: PLR0915
-        console = Console()
+        console = get_migration_console()
         result = MigrationResult()
 
         # find the active schema attributes that have a LARGE_ATTRIBUTE_TYPE kind on all branches
-        console.print(
-            f"{Timestamp().to_string()} Determining schema attribute types and timestamps on all branches...", end=""
-        )
+        console.print("Determining schema attribute types and timestamps on all branches...", end="")
         get_large_attribute_types_query = await GetLargeAttributeTypesQuery.init(db=db)
         await get_large_attribute_types_query.execute(db=db)
         schema_attribute_timeframes = get_large_attribute_types_query.get_large_attribute_type_timeframes()
@@ -481,10 +476,7 @@ class Migration037(ArbitraryMigration):
 
         # find which schema attributes are large_types in the default branch, but updated to non-large_type on other branches
         # {(kind, attr_name): SchemaAttributeTimeframe}
-        console.print(
-            f"{Timestamp().to_string()} Determining which schema attributes have been updated to non-large_type on non-default branches...",
-            end="",
-        )
+        console.print("Determining schema attribute updates on non-default branches...", end="")
         main_schema_attribute_timeframes_map: dict[tuple[str, str], SchemaAttributeTimeframe] = {}
         for schema_attr_time in schema_attribute_timeframes:
             if schema_attr_time.is_default_branch:
@@ -508,7 +500,7 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # drop the index on the AttributeValueNonIndexed vertex, there won't be any at this point anyway
-        console.print(f"{Timestamp().to_string()} Dropping index on AttributeValueIndexed vertices...", end="")
+        console.print("Dropping index on AttributeValueIndexed vertices...", end="")
         index_manager = IndexManagerNeo4j(db=db)
         index_manager.init(nodes=[AV_INDEXED_INDEX], rels=[])
         await index_manager.drop()
@@ -516,7 +508,7 @@ class Migration037(ArbitraryMigration):
 
         # create the temporary non-indexed attribute value vertices for LARGE_ATTRIBUTE_TYPE attributes
         # start with default branch
-        console.print(f"{Timestamp().to_string()} Update non-indexed attribute values with temporary label...", end="")
+        console.print("Creating temporary non-indexed attribute values for large attribute types...", end="")
         large_schema_attribute_timeframes = [
             schema_attr_time for schema_attr_time in schema_attribute_timeframes if schema_attr_time.is_large_type
         ]
@@ -528,10 +520,7 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # re-index attribute values on branches where the type was updated to non-large_type
-        console.print(
-            f"{Timestamp().to_string()} Indexing attribute values on branches where the attribute schema was updated to a non-large_type...",
-            end="",
-        )
+        console.print("Re-indexing attribute values on branches updated to non-large types...", end="")
         for schema_attr_time in large_type_reverts:
             revert_non_index_on_branch_query = await RevertNonIndexOnBranchQuery.init(
                 db=db, schema_attribute_timeframe=schema_attr_time
@@ -540,27 +529,19 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # set the AttributeValue vertices to be AttributeValueIndexed
-        console.print(
-            f"{Timestamp().to_string()} Update all AttributeValue vertices to add the AttributeValueIndexed label...",
-            end="",
-        )
+        console.print("Adding AttributeValueIndexed label to AttributeValue vertices...", end="")
         set_attribute_value_indexed_query = await SetAttributeValueIndexedQuery.init(db=db)
         await set_attribute_value_indexed_query.execute(db=db)
         console.print("done")
 
         # set AttributeValueNonIndexed vertices to just AttributeValue
-        console.print(
-            f"{Timestamp().to_string()} Update all AttributeValueNonIndexed vertices to be AttributeValue (no index)...",
-            end="",
-        )
+        console.print("Restoring AttributeValue label on AttributeValueNonIndexed vertices...", end="")
         finalize_attribute_value_non_indexed_query = await FinalizeAttributeValueNonIndexedQuery.init(db=db)
         await finalize_attribute_value_non_indexed_query.execute(db=db)
         console.print("done")
 
         # de-index all attribute values too large to be indexed
-        console.print(
-            f"{Timestamp().to_string()} De-index any legacy attribute data that is too large to be indexed...", end=""
-        )
+        console.print("De-indexing legacy attribute data exceeding index limits...", end="")
         de_index_large_attribute_values_query = await DeIndexLargeAttributeValuesQuery.init(
             db=db, max_value_size=MAX_STRING_LENGTH
         )
@@ -568,7 +549,7 @@ class Migration037(ArbitraryMigration):
         console.print("done")
 
         # add the index back to the AttributeValueNonIndexed vertex
-        console.print(f"{Timestamp().to_string()} Add the index back to the AttributeValueIndexed label...", end="")
+        console.print("Adding index back to the AttributeValueIndexed label...", end="")
         index_manager = IndexManagerNeo4j(db=db)
         index_manager.init(nodes=[AV_INDEXED_INDEX], rels=[])
         await index_manager.add()

infrahub/core/migrations/graph/m039_ipam_reconcile.py

@@ -4,14 +4,13 @@ import ipaddress
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from rich.console import Console
 from rich.progress import Progress
 
 from infrahub.core.branch.models import Branch
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.initialization import initialization
 from infrahub.core.ipam.reconciler import IpamReconciler
-from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.migrations.shared import MigrationResult, get_migration_console
 from infrahub.core.query import Query, QueryType
 from infrahub.lock import initialize_lock
 from infrahub.log import get_logger
@@ -235,13 +234,13 @@ class Migration039(ArbitraryMigration):
         return MigrationResult()
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
-        console = Console()
+        console = get_migration_console()
         result = MigrationResult()
         # load schemas from database into registry
         initialize_lock()
         await initialization(db=db)
 
-        console.print("Identifying IP prefixes/addresses to reconcile...", end="")
+        console.print("Identifying IP prefixes and addresses to reconcile...", end="")
         find_nodes_query = await FindNodesToReconcileQuery.init(db=db)
         await find_nodes_query.execute(db=db)
         console.print("done")
@@ -250,16 +249,17 @@ class Migration039(ArbitraryMigration):
         # reconciler cannot correctly handle a prefix that is its own parent
         ip_node_details_list = find_nodes_query.get_nodes_to_reconcile()
         uuids_to_check = {ip_node_details.node_uuid for ip_node_details in ip_node_details_list}
-        console.print(f"{len(ip_node_details_list)} IP prefixes/addresses will be reconciled")
+        console.log(f"{len(ip_node_details_list)} IP prefixes or addresses will be reconciled.")
 
-        console.print("Deleting any self-parent relationships...", end="")
+        console.print("Deleting self-parent relationships prior to reconciliation...", end="")
         delete_self_parent_relationships_query = await DeleteSelfParentRelationshipsQuery.init(
             db=db, uuids_to_check=list(uuids_to_check)
         )
         await delete_self_parent_relationships_query.execute(db=db)
         console.print("done")
 
-        with Progress() as progress:
+        console.log("Reconciling IP prefixes and addresses across branches...")
+        with Progress(console=console) as progress:
             reconcile_task = progress.add_task("Reconciling IP prefixes/addresses...", total=len(ip_node_details_list))
 
             for ip_node_details in ip_node_details_list:
@@ -271,4 +271,6 @@ class Migration039(ArbitraryMigration):
                 )
                 progress.update(reconcile_task, advance=1)
 
+        console.log("IP prefix and address reconciliation complete.")
+
         return result

infrahub/core/migrations/graph/m040_duplicated_attributes.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.query import Query, QueryType
+
+from ..shared import GraphMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class DeleteDuplicatedAttributesQuery(Query):
+    name: str = "delete_duplicated_attributes"
+    type: QueryType = QueryType.WRITE
+    insert_return: bool = False
+    insert_limit: bool = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+// -------------
+// get all the Nodes linked to multiple Attributes with the same name to drastically reduce the search space
+// -------------
+MATCH (n:Node)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+WITH DISTINCT n, attr
+WITH n, attr.name AS attr_name, count(*) AS num_attrs
+WHERE num_attrs > 1
+// -------------
+// for each Node-attr_name pair, get the possible duplicate Attributes
+// -------------
+MATCH (n)-[:HAS_ATTRIBUTE]->(dup_attr:Attribute {name: attr_name})
+WITH DISTINCT n, dup_attr
+// -------------
+// get the branch(es) for each possible duplicate Attribute
+// -------------
+CALL (n, dup_attr) {
+    MATCH (n)-[r:HAS_ATTRIBUTE {status: "active"}]->(dup_attr)
+    WHERE r.to IS NULL
+    AND NOT exists((n)-[:HAS_ATTRIBUTE {status: "deleted", branch: r.branch}]->(dup_attr))
+    RETURN r.branch AS branch
+}
+// -------------
+// get the latest update time for each duplicate Attribute on each branch
+// -------------
+CALL (dup_attr, branch) {
+    MATCH (dup_attr)-[r {branch: branch}]-()
+    RETURN max(r.from) AS latest_update
+}
+// -------------
+// order the duplicate Attributes by latest update time
+// -------------
+WITH n, dup_attr, branch, latest_update
+ORDER BY n, branch, dup_attr.name, latest_update DESC
+// -------------
+// for any Node-dup_attr_name pairs with multiple duplicate Attributes, keep the Attribute with the latest update
+// on this branch and delete all the other edges on this branch for this Attribute
+// -------------
+WITH n, branch, dup_attr.name AS dup_attr_name, collect(dup_attr) AS dup_attrs_reverse_chronological
+WHERE size(dup_attrs_reverse_chronological) > 1
+WITH branch, tail(dup_attrs_reverse_chronological) AS dup_attrs_to_delete
+UNWIND dup_attrs_to_delete AS dup_attr_to_delete
+MATCH (dup_attr_to_delete)-[r {branch: branch}]-()
+DELETE r
+// -------------
+// delete any orphaned Attributes
+// -------------
+WITH DISTINCT dup_attr_to_delete
+WHERE NOT exists((dup_attr_to_delete)--())
+DELETE dup_attr_to_delete
+        """
+        self.add_to_query(query)
+
+
+class Migration040(GraphMigration):
+    name: str = "040_duplicated_attributes"
+    queries: Sequence[type[Query]] = [DeleteDuplicatedAttributesQuery]
+    minimum_version: int = 39
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()