infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/actions/tasks.py

@@ -61,6 +61,12 @@ def get_generator_run_query(definition_id: str, target_ids: list[str]) -> Query:
                         "parameters": {
                             "value": None,
                         },
+                        "execute_in_proposed_change": {
+                            "value": None,
+                        },
+                        "execute_after_merge": {
+                            "value": None,
+                        },
                         "targets": {
                             "node": {
                                 "id": None,
@@ -287,6 +293,8 @@ async def _run_generators(
                 convert_query_response=data["convert_query_response"]["value"],
                 group_id=data["targets"]["node"]["id"],
                 parameters=data["parameters"]["value"],
+                execute_in_proposed_change=data["execute_in_proposed_change"]["value"],
+                execute_after_merge=data["execute_after_merge"]["value"],
             ),
             commit=data["repository"]["node"]["commit"]["value"],
             repository_id=data["repository"]["node"]["id"],

infrahub/api/diff/diff.py

@@ -52,7 +52,7 @@ async def get_diff_files(
     for branch_name, items in diff_files.items():
         for item in items:
             repository_id = item.repository.get_id()
-            display_label = await item.repository.render_display_label(db=db)
+            display_label = await item.repository.get_display_label(db=db)
             if repository_id not in response[branch_name]:
                 response[branch_name][repository_id] = BranchDiffRepository(
                     id=repository_id,

infrahub/cli/db.py

@@ -54,6 +54,7 @@ from infrahub.log import get_logger
 
 from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
 from .db_commands.check_inheritance import check_inheritance
+from .db_commands.clean_duplicate_schema_fields import clean_duplicate_schema_fields
 from .patch import patch_app
 
 
@@ -200,6 +201,29 @@ async def check_inheritance_cmd(
     await dbdriver.close()
 
 
+@app.command(name="check-duplicate-schema-fields")
+async def check_duplicate_schema_fields_cmd(
+    ctx: typer.Context,
+    fix: bool = typer.Option(False, help="Fix the duplicate schema fields on the default branch."),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Check for any duplicate schema attributes or relationships on the default branch"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    success = await clean_duplicate_schema_fields(db=dbdriver, fix=fix)
+    if not success:
+        raise typer.Exit(code=1)
+
+    await dbdriver.close()
+
+
 @app.command(name="update-core-schema")
 async def update_core_schema_cmd(
     ctx: typer.Context,

infrahub/cli/db_commands/clean_duplicate_schema_fields.py

@@ -0,0 +1,212 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+
+from infrahub.cli.constants import FAILED_BADGE, SUCCESS_BADGE
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+
+class SchemaFieldType(str, Enum):
+    ATTRIBUTE = "attribute"
+    RELATIONSHIP = "relationship"
+
+
+@dataclass
+class SchemaFieldDetails:
+    schema_kind: str
+    schema_uuid: str
+    field_type: SchemaFieldType
+    field_name: str
+
+
+class DuplicateSchemaFields(Query):
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (root:Root)
+LIMIT 1
+WITH root.default_branch AS default_branch
+MATCH (field:SchemaAttribute|SchemaRelationship)
+CALL (default_branch, field) {
+    MATCH (field)-[is_part_of:IS_PART_OF]->(:Root)
+    WHERE is_part_of.branch = default_branch
+    ORDER BY is_part_of.from DESC
+    RETURN is_part_of
+    LIMIT 1
+}
+WITH default_branch, field, CASE
+    WHEN is_part_of.status = "active" AND is_part_of.to IS NULL THEN is_part_of.from
+    ELSE NULL
+END AS active_from
+WHERE active_from IS NOT NULL
+WITH default_branch, field, active_from, "SchemaAttribute" IN labels(field) AS is_attribute
+CALL (field, default_branch) {
+    MATCH (field)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "name"})-[r2:HAS_VALUE]->(name_value:AttributeValue)
+    WHERE r1.branch = default_branch AND r2.branch = default_branch
+    AND r1.status = "active" AND r2.status = "active"
+    AND r1.to IS NULL AND r2.to IS NULL
+    ORDER BY r1.from DESC, r1.status ASC, r2.from DESC, r2.status ASC
+    LIMIT 1
+    RETURN name_value.value AS field_name
+}
+CALL (field, default_branch) {
+    MATCH (field)-[r1:IS_RELATED]-(rel:Relationship)-[r2:IS_RELATED]-(peer:SchemaNode|SchemaGeneric)
+    WHERE rel.name IN ["schema__node__relationships", "schema__node__attributes"]
+    AND r1.branch = default_branch AND r2.branch = default_branch
+    AND r1.status = "active" AND r2.status = "active"
+    AND r1.to IS NULL AND r2.to IS NULL
+    ORDER BY r1.from DESC, r1.status ASC, r2.from DESC, r2.status ASC
+    LIMIT 1
+    RETURN peer AS schema_vertex
+}
+WITH default_branch, field, field_name, is_attribute, active_from, schema_vertex
+ORDER BY active_from DESC
+WITH default_branch, field_name, is_attribute, schema_vertex, collect(field) AS fields_reverse_chron
+WHERE size(fields_reverse_chron) > 1
+        """
+        self.add_to_query(query)
+
+
+class GetDuplicateSchemaFields(DuplicateSchemaFields):
+    """
+    Get the kind, field type, and field name for any duplicated attributes or relationships on a given schema
+    on the default branch
+    """
+
+    name = "get_duplicate_schema_fields"
+    type = QueryType.READ
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        await super().query_init(db=db, **kwargs)
+        query = """
+CALL (schema_vertex, default_branch) {
+    MATCH (schema_vertex)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "namespace"})-[r2:HAS_VALUE]->(name_value:AttributeValue)
+    WHERE r1.branch = default_branch AND r2.branch = default_branch
+    ORDER BY r1.from DESC, r1.status ASC, r2.from DESC, r2.status ASC
+    LIMIT 1
+    RETURN name_value.value AS schema_namespace
+}
+CALL (schema_vertex, default_branch) {
+    MATCH (schema_vertex)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "name"})-[r2:HAS_VALUE]->(name_value:AttributeValue)
+    WHERE r1.branch = default_branch AND r2.branch = default_branch
+    ORDER BY r1.from DESC, r1.status ASC, r2.from DESC, r2.status ASC
+    LIMIT 1
+    RETURN name_value.value AS schema_name
+}
+RETURN schema_namespace + schema_name AS schema_kind, schema_vertex.uuid AS schema_uuid, field_name, is_attribute
+ORDER BY schema_kind ASC, is_attribute DESC, field_name ASC
+        """
+        self.return_labels = ["schema_kind", "schema_uuid", "field_name", "is_attribute"]
+        self.add_to_query(query)
+
+    def get_schema_field_details(self) -> list[SchemaFieldDetails]:
+        schema_field_details: list[SchemaFieldDetails] = []
+        for result in self.results:
+            schema_kind = result.get_as_type(label="schema_kind", return_type=str)
+            schema_uuid = result.get_as_type(label="schema_uuid", return_type=str)
+            field_name = result.get_as_type(label="field_name", return_type=str)
+            is_attribute = result.get_as_type(label="is_attribute", return_type=bool)
+            schema_field_details.append(
+                SchemaFieldDetails(
+                    schema_kind=schema_kind,
+                    schema_uuid=schema_uuid,
+                    field_name=field_name,
+                    field_type=SchemaFieldType.ATTRIBUTE if is_attribute else SchemaFieldType.RELATIONSHIP,
+                )
+            )
+        return schema_field_details
+
+
+class FixDuplicateSchemaFields(DuplicateSchemaFields):
+    """
+    Fix the duplicate schema fields by hard deleting the earlier duplicate(s)
+    """
+
+    name = "fix_duplicate_schema_fields"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        await super().query_init(db=db, **kwargs)
+        query = """
+WITH default_branch, tail(fields_reverse_chron) AS fields_to_delete
+UNWIND fields_to_delete AS field_to_delete
+CALL (field_to_delete, default_branch) {
+    MATCH (field_to_delete)-[r:IS_PART_OF {branch: default_branch}]-()
+    DELETE r
+    WITH field_to_delete
+    MATCH (field_to_delete)-[:IS_RELATED {branch: default_branch}]-(rel:Relationship)
+    WITH DISTINCT field_to_delete, rel
+    MATCH (rel)-[r {branch: default_branch}]-()
+    DELETE r
+    WITH field_to_delete, rel
+    OPTIONAL MATCH (rel)
+    WHERE NOT exists((rel)--())
+    DELETE rel
+    WITH DISTINCT field_to_delete
+    MATCH (field_to_delete)-[:HAS_ATTRIBUTE {branch: default_branch}]->(attr:Attribute)
+    MATCH (attr)-[r {branch: default_branch}]-()
+    DELETE r
+    WITH field_to_delete, attr
+    OPTIONAL MATCH (attr)
+    WHERE NOT exists((attr)--())
+    DELETE attr
+    WITH DISTINCT field_to_delete
+    OPTIONAL MATCH (field_to_delete)
+    WHERE NOT exists((field_to_delete)--())
+    DELETE field_to_delete
+}
+        """
+        self.add_to_query(query)
+
+
+def display_duplicate_schema_fields(duplicate_schema_fields: list[SchemaFieldDetails]) -> None:
+    console = Console()
+
+    table = Table(title="Duplicate Schema Fields on Default Branch")
+
+    table.add_column("Schema Kind")
+    table.add_column("Schema UUID")
+    table.add_column("Field Name")
+    table.add_column("Field Type")
+
+    for duplicate_schema_field in duplicate_schema_fields:
+        table.add_row(
+            duplicate_schema_field.schema_kind,
+            duplicate_schema_field.schema_uuid,
+            duplicate_schema_field.field_name,
+            duplicate_schema_field.field_type.value,
+        )
+
+    console.print(table)
+
+
+async def clean_duplicate_schema_fields(db: InfrahubDatabase, fix: bool = False) -> bool:
+    """
+    Identify any attributes or relationships that are duplicated in a schema on the default branch
+    If fix is True, runs cypher queries to hard delete the earlier duplicate
+    """
+
+    duplicate_schema_fields_query = await GetDuplicateSchemaFields.init(db=db)
+    await duplicate_schema_fields_query.execute(db=db)
+    duplicate_schema_fields = duplicate_schema_fields_query.get_schema_field_details()
+
+    if not duplicate_schema_fields:
+        rprint(f"{SUCCESS_BADGE} No duplicate schema fields found")
+        return True
+
+    display_duplicate_schema_fields(duplicate_schema_fields)
+
+    if not fix:
+        rprint(f"{FAILED_BADGE} Use the --fix flag to fix the duplicate schema fields")
+        return False
+
+    fix_duplicate_schema_fields_query = await FixDuplicateSchemaFields.init(db=db)
+    await fix_duplicate_schema_fields_query.execute(db=db)
+    rprint(f"{SUCCESS_BADGE} Duplicate schema fields deleted from the default branch")
+    return True

infrahub/core/attribute.py

@@ -36,7 +36,7 @@ from .schema.attribute_parameters import NumberAttributeParameters
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.node import Node
-    from infrahub.core.schema import AttributeSchema
+    from infrahub.core.schema import AttributeSchema, MainSchemaTypes
     from infrahub.database import InfrahubDatabase
 
 
@@ -630,7 +630,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             return AttributeDBNodeType.DEFAULT
         return AttributeDBNodeType.INDEXED
 
-    def get_create_data(self) -> AttributeCreateData:
+    def get_create_data(self, node_schema: MainSchemaTypes) -> AttributeCreateData:
         branch = self.branch
         hierarchy_level = branch.hierarchy_level
         if self.schema.branch == BranchSupportType.AGNOSTIC:
@@ -645,7 +645,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             branch=branch.name,
             status="active",
             branch_level=hierarchy_level,
-            branch_support=self.schema.branch.value,
+            branch_support=self.schema.branch.value if self.schema.branch is not None else node_schema.branch,
             content=self.to_db(),
             is_default=self.is_default,
             is_protected=self.is_protected,

infrahub/core/branch/tasks.py

@@ -33,6 +33,7 @@ from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent
 from infrahub.events.models import EventMeta, InfrahubEvent
 from infrahub.events.node_action import get_node_event
 from infrahub.exceptions import BranchNotFoundError, ValidationError
+from infrahub.generators.constants import GeneratorDefinitionRunSource
 from infrahub.graphql.mutations.models import BranchCreateModel  # noqa: TC001
 from infrahub.workers.dependencies import get_component, get_database, get_event_service, get_workflow
 from infrahub.workflows.catalogue import (
@@ -437,7 +438,7 @@ async def post_process_branch_merge(source_branch: str, target_branch: str, cont
         await get_workflow().submit_workflow(
             workflow=TRIGGER_GENERATOR_DEFINITION_RUN,
             context=context,
-            parameters={"branch": target_branch},
+            parameters={"branch": target_branch, "source": GeneratorDefinitionRunSource.MERGE},
         )
 
         for diff_root in branch_diff_roots:

infrahub/core/changelog/models.py

@@ -560,7 +560,7 @@ class RelationshipChangelogGetter:
 
         for peer in relationship.peers:
             if peer.peer_status == DiffAction.ADDED:
-                peer_schema = schema_branch.get(name=peer.peer_kind)
+                peer_schema = schema_branch.get(name=peer.peer_kind, duplicate=False)
                 secondaries.extend(
                     self._process_added_peers(
                         peer_id=peer.peer_id,
@@ -572,7 +572,7 @@ class RelationshipChangelogGetter:
                 )
 
             elif peer.peer_status == DiffAction.REMOVED:
-                peer_schema = schema_branch.get(name=peer.peer_kind)
+                peer_schema = schema_branch.get(name=peer.peer_kind, duplicate=False)
                 secondaries.extend(
                     self._process_removed_peers(
                         peer_id=peer.peer_id,
@@ -596,11 +596,7 @@ class RelationshipChangelogGetter:
         secondaries: list[NodeChangelog] = []
         peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
         if peer_relation:
-            node_changelog = NodeChangelog(
-                node_id=peer_id,
-                node_kind=peer_kind,
-                display_label="n/a",
-            )
+            node_changelog = NodeChangelog(node_id=peer_id, node_kind=peer_kind, display_label="n/a")
             if peer_relation.cardinality == RelationshipCardinality.ONE:
                 node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
                     name=peer_relation.name,
@@ -634,11 +630,7 @@ class RelationshipChangelogGetter:
         secondaries: list[NodeChangelog] = []
         peer_relation = peer_schema.get_relationship_by_identifier(id=str(rel_schema.identifier), raise_on_error=False)
         if peer_relation:
-            node_changelog = NodeChangelog(
-                node_id=peer_id,
-                node_kind=peer_kind,
-                display_label="n/a",
-            )
+            node_changelog = NodeChangelog(node_id=peer_id, node_kind=peer_kind, display_label="n/a")
             if peer_relation.cardinality == RelationshipCardinality.ONE:
                 node_changelog.relationships[peer_relation.name] = RelationshipCardinalityOneChangelog(
                     name=peer_relation.name,

infrahub/core/constants/infrahubkind.py

@@ -28,6 +28,7 @@ GENERATORDEFINITION = "CoreGeneratorDefinition"
 GENERATORINSTANCE = "CoreGeneratorInstance"
 GENERATORVALIDATOR = "CoreGeneratorValidator"
 GENERATORGROUP = "CoreGeneratorGroup"
+GENERATORAWAREGROUP = "CoreGeneratorAwareGroup"
 GENERICGROUP = "CoreGroup"
 GLOBALPERMISSION = "CoreGlobalPermission"
 GRAPHQLQUERY = "CoreGraphQLQuery"

infrahub/core/diff/model/path.py

@@ -335,6 +335,10 @@ class EnrichedDiffNode(BaseSummary):
     def kind(self) -> str:
         return self.identifier.kind
 
+    @property
+    def is_schema_node(self) -> bool:
+        return self.identifier.kind.startswith("Schema")
+
     @property
     def num_properties(self) -> int:
         return sum(a.num_properties for a in self.attributes) + sum(r.num_properties for r in self.relationships)

infrahub/core/diff/payload_builder.py

@@ -36,7 +36,7 @@ async def get_display_labels_per_kind(
             break
         node_map = await NodeManager.get_many(ids=limited_ids, fields=fields, db=db, branch=branch)
         for node_id, node in node_map.items():
-            display_label_map[node_id] = await node.render_display_label(db=db)
+            display_label_map[node_id] = await node.get_display_label(db=db)
         offset += limit
     return display_label_map
 

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 40
+GRAPH_VERSION = 42

infrahub/core/ipam/utilization.py

@@ -152,4 +152,4 @@ class PrefixUtilizationGetter:
             grand_total_space += prefix_total_space
         if grand_total_space == 0:
             return 0.0
-        return (grand_total_used / grand_total_space) * 100
+        return min((grand_total_used / grand_total_space) * 100, 100)

infrahub/core/manager.py

@@ -60,12 +60,15 @@ def identify_node_class(node: NodeToProcess) -> type[Node]:
 
 
 def get_schema(
-    db: InfrahubDatabase, branch: Branch, node_schema: type[SchemaProtocol] | MainSchemaTypes | str
+    db: InfrahubDatabase,
+    branch: Branch,
+    node_schema: type[SchemaProtocol] | MainSchemaTypes | str,
+    duplicate: bool = False,
 ) -> MainSchemaTypes:
     if isinstance(node_schema, str):
-        return db.schema.get(name=node_schema, branch=branch.name)
+        return db.schema.get(name=node_schema, branch=branch.name, duplicate=duplicate)
     if hasattr(node_schema, "_is_runtime_protocol") and node_schema._is_runtime_protocol:
-        return db.schema.get(name=node_schema.__name__, branch=branch.name)
+        return db.schema.get(name=node_schema.__name__, branch=branch.name, duplicate=duplicate)
     if not isinstance(node_schema, (MainSchemaTypes)):
         raise ValueError(f"Invalid schema provided {node_schema}")
 

infrahub/core/migrations/graph/__init__.py

@@ -42,6 +42,8 @@ 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
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -89,6 +91,8 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration038,
     Migration039,
     Migration040,
+    Migration041,
+    Migration042,
 ]
 
 

infrahub/core/migrations/graph/m041_create_hfid_display_label_in_db.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from rich.progress import Progress
+from typing_extensions import Self
+
+from infrahub.core import registry
+from infrahub.core.constants import SchemaPathType
+from infrahub.core.initialization import initialization
+from infrahub.core.migrations.schema.node_attribute_add import NodeAttributeAddMigration
+from infrahub.core.migrations.shared import InternalSchemaMigration, MigrationResult
+from infrahub.core.path import SchemaPath
+from infrahub.lock import initialize_lock
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class Migration041(InternalSchemaMigration):
+    name: str = "041_create_hfid_display_label_in_db"
+    minimum_version: int = 40
+
+    @classmethod
+    def init(cls, **kwargs: Any) -> Self:
+        internal_schema = cls.get_internal_schema()
+        schema_node = internal_schema.get_node(name="SchemaNode")
+        schema_generic = internal_schema.get_node(name="SchemaGeneric")
+
+        cls.migrations = [
+            # HFID is not needed, it was introduced at graph v8
+            NodeAttributeAddMigration(
+                new_node_schema=schema_node,
+                previous_node_schema=schema_node,
+                schema_path=SchemaPath(
+                    schema_kind="SchemaNode", path_type=SchemaPathType.ATTRIBUTE, field_name="display_label"
+                ),
+            ),
+            NodeAttributeAddMigration(
+                new_node_schema=schema_generic,
+                previous_node_schema=schema_generic,
+                schema_path=SchemaPath(
+                    schema_kind="SchemaGeneric", path_type=SchemaPathType.ATTRIBUTE, field_name="display_label"
+                ),
+            ),
+        ]
+        return cls(migrations=cls.migrations, **kwargs)  # type: ignore[arg-type]
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+
+        default_branch = registry.get_branch_from_registry()
+        schema_branch = await registry.schema.load_schema_from_db(db=db, branch=default_branch)
+
+        migrations = list(self.migrations)
+
+        for node_schema_kind in schema_branch.node_names:
+            schema = schema_branch.get(name=node_schema_kind, duplicate=False)
+            migrations.extend(
+                [
+                    NodeAttributeAddMigration(
+                        new_node_schema=schema,
+                        previous_node_schema=schema,
+                        schema_path=SchemaPath(
+                            schema_kind=schema.kind, path_type=SchemaPathType.ATTRIBUTE, field_name="human_friendly_id"
+                        ),
+                    ),
+                    NodeAttributeAddMigration(
+                        new_node_schema=schema,
+                        previous_node_schema=schema,
+                        schema_path=SchemaPath(
+                            schema_kind=schema.kind, path_type=SchemaPathType.ATTRIBUTE, field_name="display_label"
+                        ),
+                    ),
+                ]
+            )
+
+        with Progress() as progress:
+            update_task = progress.add_task("Adding HFID and display label to nodes", total=len(migrations))
+
+            for migration in migrations:
+                try:
+                    execution_result = await migration.execute(db=db, branch=default_branch)
+                    result.errors.extend(execution_result.errors)
+                    progress.update(update_task, advance=1)
+                except Exception as exc:
+                    result.errors.append(str(exc))
+                    return result
+
+        return result
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()

infrahub/core/migrations/graph/m042_backfill_hfid_display_label_in_db.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from rich.progress import Progress, TaskID
+
+from infrahub.core import registry
+from infrahub.core.initialization import initialization
+from infrahub.core.manager import NodeManager
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.lock import initialize_lock
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.core.node import Node
+    from infrahub.core.schema import MainSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+
+class Migration042(ArbitraryMigration):
+    """
+    Backfill `human_friendly_id` and `display_label` attributes for nodes with schemas that define them.
+    """
+
+    name: str = "042_backfill_hfid_display_label_in_db"
+    minimum_version: int = 41
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def _update_batch(
+        self,
+        db: InfrahubDatabase,
+        node_schema: MainSchemaTypes,
+        nodes: Sequence[Node],
+        progress: Progress,
+        update_task: TaskID,
+    ) -> None:
+        for node in nodes:
+            fields = []
+            if node_schema.human_friendly_id:
+                await node.add_human_friendly_id(db=db)
+                fields.append("human_friendly_id")
+            if node_schema.display_label:
+                await node.add_display_label(db=db)
+                fields.append("display_label")
+
+            if fields:
+                await node.save(db=db, fields=fields)
+
+            progress.update(task_id=update_task, advance=1)
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+
+        schemas_to_update: dict[MainSchemaTypes, int] = {}
+        for node_schema in registry.get_full_schema(duplicate=False).values():
+            if node_schema.is_generic_schema or (not node_schema.human_friendly_id and not node_schema.display_label):
+                continue
+
+            node_count = await NodeManager.count(db=db, schema=node_schema)
+            if node_count:
+                schemas_to_update[node_schema] = node_count
+
+        with Progress() as progress:
+            batch_size = 1000
+            update_task = progress.add_task(
+                "Backfill HFID and display_label for nodes in database", total=sum(schemas_to_update.values())
+            )
+
+            for schema, count in schemas_to_update.items():
+                for offset in range(0, count, batch_size):
+                    limit = min(batch_size, count - offset)
+                    nodes: list[Node] = await NodeManager.query(db=db, schema=schema, offset=offset, limit=limit)
+                    await self._update_batch(
+                        db=db, node_schema=schema, nodes=nodes, progress=progress, update_task=update_task
+                    )
+
+        return result

infrahub/core/migrations/schema/node_attribute_add.py

@@ -52,8 +52,11 @@ class NodeAttributeAddMigration(AttributeSchemaMigration):
         if self.new_attribute_schema.kind != "NumberPool":
             return result
 
-        number_pool: CoreNumberPool = await Node.fetch_or_create_number_pool(  # type: ignore[assignment]
-            db=db, branch=branch, schema_node=self.new_schema, schema_attribute=self.new_attribute_schema
+        number_pool: CoreNumberPool = await Node.fetch_or_create_number_pool(
+            db=db,
+            branch=branch,
+            schema_node=self.new_schema,  # type: ignore
+            schema_attribute=self.new_attribute_schema,
         )
 
         await update_branch_registry(db=db, branch=branch)