infrahub-server 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/core/branch/tasks.py

@@ -12,6 +12,7 @@ from infrahub import lock
 from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
 from infrahub.core import registry
 from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.changelog.diff import DiffChangelogCollector, MigrationTracker
 from infrahub.core.constants import MutationAction
 from infrahub.core.diff.coordinator import DiffCoordinator
@@ -21,7 +22,10 @@ from infrahub.core.diff.merger.merger import DiffMerger
 from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRoot, EnrichedDiffRootMetadata
 from infrahub.core.diff.models import RequestDiffUpdate
 from infrahub.core.diff.repository.repository import DiffRepository
+from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.merge import BranchMerger
+from infrahub.core.migrations.exceptions import MigrationFailureError
+from infrahub.core.migrations.runner import MigrationRunner
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
 from infrahub.core.timestamp import Timestamp
@@ -29,10 +33,17 @@ from infrahub.core.validators.determiner import ConstraintValidatorDeterminer
 from infrahub.core.validators.models.validate_migration import SchemaValidateMigrationData
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.dependencies.registry import get_component_registry
-from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
+from infrahub.events.branch_action import (
+    BranchCreatedEvent,
+    BranchDeletedEvent,
+    BranchMergedEvent,
+    BranchMigratedEvent,
+    BranchRebasedEvent,
+)
 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 (
@@ -48,8 +59,57 @@ from infrahub.workflows.catalogue import (
 from infrahub.workflows.utils import add_tags
 
 
+@flow(name="branch-migrate", flow_run_name="Apply migrations to branch {branch}")
+async def migrate_branch(branch: str, context: InfrahubContext, send_events: bool = True) -> None:
+    await add_tags(branches=[branch])
+
+    database = await get_database()
+    async with database.start_session() as db:
+        log = get_run_logger()
+
+        obj = await Branch.get_by_name(db=db, name=branch)
+
+        if obj.graph_version == GRAPH_VERSION:
+            log.info(f"Branch '{obj.name}' has graph version {obj.graph_version}, no migrations to apply")
+            return
+
+        migration_runner = MigrationRunner(branch=obj)
+        if not migration_runner.has_migrations():
+            log.info(f"No migrations detected for branch '{obj.name}'")
+            obj.graph_version = GRAPH_VERSION
+            await obj.save(db=db)
+            return
+
+        # Branch status will remain as so if the migration process fails
+        # This will help user to know that a branch is in an invalid state to be used properly and that actions need to be taken
+        if obj.status != BranchStatus.NEED_UPGRADE_REBASE:
+            obj.status = BranchStatus.NEED_UPGRADE_REBASE
+            await obj.save(db=db)
+
+        try:
+            log.info(f"Running migrations for branch '{obj.name}'")
+            await migration_runner.run(db=db)
+        except MigrationFailureError as exc:
+            log.error(f"Failed to run migrations for branch '{obj.name}': {exc.errors}")
+            raise
+
+        if obj.status == BranchStatus.NEED_UPGRADE_REBASE:
+            obj.status = BranchStatus.OPEN
+        obj.graph_version = GRAPH_VERSION
+        await obj.save(db=db)
+
+    if send_events:
+        event_service = await get_event_service()
+        await event_service.send(
+            BranchMigratedEvent(
+                branch_name=obj.name, branch_id=str(obj.uuid), meta=EventMeta(branch=obj, context=context)
+            )
+        )
+
+
 @flow(name="branch-rebase", flow_run_name="Rebase branch {branch}")
-async def rebase_branch(branch: str, context: InfrahubContext) -> None:  # noqa: PLR0915
+async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool = True) -> None:  # noqa: PLR0915
+    workflow = get_workflow()
     database = await get_database()
     async with database.start_session() as db:
         log = get_run_logger()
@@ -68,7 +128,7 @@ async def rebase_branch(branch: str, context: InfrahubContext) -> None:  # noqa:
             diff_repository=diff_repository,
             source_branch=obj,
             diff_locker=DiffLocker(),
-            workflow=get_workflow(),
+            workflow=workflow,
         )
 
         enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
@@ -155,15 +215,17 @@ async def rebase_branch(branch: str, context: InfrahubContext) -> None:  # noqa:
             target_branch_name=registry.default_branch,
         )
         if ipam_node_details:
-            await get_workflow().submit_workflow(
+            await workflow.submit_workflow(
                 workflow=IPAM_RECONCILIATION,
                 context=context,
                 parameters={"branch": obj.name, "ipam_node_details": ipam_node_details},
             )
 
-    await get_workflow().submit_workflow(
-        workflow=DIFF_REFRESH_ALL, context=context, parameters={"branch_name": obj.name}
-    )
+    await migrate_branch(branch=branch, context=context, send_events=send_events)
+    await workflow.submit_workflow(workflow=DIFF_REFRESH_ALL, context=context, parameters={"branch_name": obj.name})
+
+    if not send_events:
+        return
 
     # -------------------------------------------------------------
     # Generate an event to indicate that a branch has been rebased
@@ -345,7 +407,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
     async with database.start_session() as db:
         try:
             await Branch.get_by_name(db=db, name=model.name)
-            raise ValueError(f"The branch {model.name}, already exist")
+            raise ValidationError(f"The branch {model.name} already exists")
         except BranchNotFoundError:
             pass
 
@@ -356,7 +418,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
             obj = Branch(**data_dict)
         except pydantic.ValidationError as exc:
             error_msgs = [f"invalid field {error['loc'][0]}: {error['msg']}" for error in exc.errors()]
-            raise ValueError("\n".join(error_msgs)) from exc
+            raise ValidationError("\n".join(error_msgs)) from exc
 
         async with lock.registry.local_schema_lock():
             # Copy the schema from the origin branch and set the hash and the schema_changed_at value
@@ -437,7 +499,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

@@ -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/__init__.py

@@ -37,6 +37,7 @@ RESERVED_ATTR_REL_NAMES = [
     "rels",
     "save",
     "hfid",
+    "process_pools",
 ]
 
 RESERVED_ATTR_GEN_NAMES = ["type"]
@@ -50,6 +51,7 @@ class EventType(InfrahubStringEnum):
     BRANCH_CREATED = f"{EVENT_NAMESPACE}.branch.created"
     BRANCH_DELETED = f"{EVENT_NAMESPACE}.branch.deleted"
     BRANCH_MERGED = f"{EVENT_NAMESPACE}.branch.merged"
+    BRANCH_MIGRATED = f"{EVENT_NAMESPACE}.branch.migrated"
     BRANCH_REBASED = f"{EVENT_NAMESPACE}.branch.rebased"
 
     SCHEMA_UPDATED = f"{EVENT_NAMESPACE}.schema.updated"
@@ -99,6 +101,7 @@ class GlobalPermissions(InfrahubStringEnum):
     MANAGE_PERMISSIONS = "manage_permissions"
     MANAGE_REPOSITORIES = "manage_repositories"
     OVERRIDE_CONTEXT = "override_context"
+    UPDATE_OBJECT_HFID_DISPLAY_LABEL = "update_object_hfid_display_label"
 
 
 class PermissionAction(InfrahubStringEnum):
@@ -387,3 +390,4 @@ DEFAULT_REL_IDENTIFIER_LENGTH = 128
 
 OBJECT_TEMPLATE_RELATIONSHIP_NAME = "object_template"
 OBJECT_TEMPLATE_NAME_ATTR = "template_name"
+PROFILE_NODE_RELATIONSHIP_IDENTIFIER = "node__profile"

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/convert_object_type/object_conversion.py

@@ -0,0 +1,201 @@
+from typing import Any, assert_never
+
+from infrahub_sdk.convert_object_type import ConversionFieldInput, ConversionFieldValue
+
+from infrahub.core.attribute import BaseAttribute
+from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
+from infrahub.core.constants import BranchSupportType, RelationshipCardinality
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.node.create import create_node
+from infrahub.core.query.relationship import GetAllPeersIds
+from infrahub.core.query.resource_manager import PoolChangeReserved
+from infrahub.core.relationship import RelationshipManager
+from infrahub.core.schema import NodeSchema
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+from infrahub.message_bus.messages import RefreshRegistryBranches
+from infrahub.tasks.registry import update_branch_registry
+from infrahub.workers.dependencies import get_message_bus
+
+
+def _get_conversion_field_raw_value(conv_field_value: ConversionFieldValue) -> Any:
+    if conv_field_value.attribute_value is not None:
+        return conv_field_value.attribute_value
+    if conv_field_value.peer_id is not None:
+        return conv_field_value.peer_id
+    if conv_field_value.peers_ids is not None:
+        return conv_field_value.peers_ids
+    raise ValueError("ConversionFieldValue has not been validated correctly.")
+
+
+async def get_out_rels_peers_ids(node: Node, db: InfrahubDatabase, at: Timestamp) -> list[str]:
+    all_peers_ids: list[str] = []
+    for name in node._relationships:
+        relm: RelationshipManager = getattr(node, name)
+        peers = await relm.get_db_peers(db=db, at=at)
+        all_peers_ids.extend([str(peer.peer_id) for peer in peers])
+    return all_peers_ids
+
+
+async def build_data_new_node(db: InfrahubDatabase, mapping: dict[str, ConversionFieldInput], node: Node) -> dict:
+    """Value of a given field on the target kind to convert is either an input source attribute/relationship of the source node,
+    or a raw value."""
+
+    data = {}
+    for dest_field_name, conv_field_input in mapping.items():
+        if conv_field_input.source_field is not None:
+            # Fetch the value of the corresponding field from the node being converted.
+            item = getattr(node, conv_field_input.source_field)
+            if isinstance(item, BaseAttribute):
+                data[dest_field_name] = item.value
+            elif isinstance(item, RelationshipManager):
+                if item.schema.cardinality == RelationshipCardinality.ONE:
+                    peer = await item.get_peer(db=db)
+                    if peer is not None:
+                        data[dest_field_name] = {"id": peer.id}
+                    # else, relationship is optional, and if the target relationship is mandatory an error will be raised during creation
+                elif item.schema.cardinality == RelationshipCardinality.MANY:
+                    data[dest_field_name] = [{"id": peer.id} for _, peer in (await item.get_peers(db=db)).items()]
+                else:
+                    assert_never(item.schema.cardinality)
+        elif conv_field_input.data is not None:
+            data[dest_field_name] = _get_conversion_field_raw_value(conv_field_input.data)
+        elif conv_field_input.use_default_value is True:
+            pass  # default value will be used automatically when creating the node
+        else:
+            raise ValueError("ConversionFieldInput has not been validated correctly.")
+    return data
+
+
+async def get_unidirectional_rels_peers_ids(
+    node: Node, branch: Branch, db: InfrahubDatabase, at: Timestamp
+) -> list[str]:
+    """
+    Returns peers ids of nodes connected to input `node` through an incoming unidirectional relationship.
+    """
+
+    out_rels_identifier = [rel.identifier for rel in node.get_schema().relationships]
+    branch_agnostic = node.get_schema().branch == BranchSupportType.AGNOSTIC
+    query = await GetAllPeersIds.init(
+        db=db,
+        node_id=node.id,
+        branch=branch,
+        exclude_identifiers=out_rels_identifier,
+        branch_agnostic=branch_agnostic,
+        at=at,
+    )
+    await query.execute(db=db)
+    return query.get_peers_uuids()
+
+
+async def _get_other_active_branches(db: InfrahubDatabase) -> list[Branch]:
+    branches = await Branch.get_list(db=db)
+    return [branch for branch in branches if not (branch.is_global or branch.is_default)]
+
+
+def _has_pass_thru_aware_attributes(node_schema: NodeSchema, mapping: dict[str, ConversionFieldInput]) -> bool:
+    aware_attributes = [attr for attr in node_schema.attributes if attr.branch != BranchSupportType.AGNOSTIC]
+    aware_attributes_pass_thru = [
+        attr.name for attr in aware_attributes if attr.name in mapping and mapping[attr.name].source_field is not None
+    ]
+    return len(aware_attributes_pass_thru) > 0
+
+
+async def validate_conversion(
+    deleted_node: Node, branch: Branch, db: InfrahubDatabase, timestamp_before_conversion: Timestamp
+) -> None:
+    deleted_node_out_rels_peer_ids = await get_out_rels_peers_ids(
+        node=deleted_node, db=db, at=timestamp_before_conversion
+    )
+    deleted_node_unidir_rels_peer_ids = await get_unidirectional_rels_peers_ids(
+        node=deleted_node, db=db, branch=branch, at=timestamp_before_conversion
+    )
+
+    # Make sure relationships with constraints are not broken by retrieving them
+    peers_ids = deleted_node_out_rels_peer_ids + deleted_node_unidir_rels_peer_ids
+    peers = await NodeManager.get_many(ids=peers_ids, db=db, prefetch_relationships=True, branch=branch)
+    for peer in peers.values():
+        peer.validate_relationships()
+
+
+async def convert_and_validate_object_type(
+    node: Node,
+    target_schema: NodeSchema,
+    mapping: dict[str, ConversionFieldInput],
+    branch: Branch,
+    db: InfrahubDatabase,
+) -> Node:
+    async with db.start_transaction() as dbt:
+        timestamp_before_conversion = Timestamp()
+        new_node = await convert_object_type(
+            node=node, target_schema=target_schema, mapping=mapping, branch=branch, db=dbt
+        )
+        await validate_conversion(
+            deleted_node=node, branch=branch, db=dbt, timestamp_before_conversion=timestamp_before_conversion
+        )
+
+    # Refresh outside the transaction otherwise other workers would pull outdated branch objects.
+    message_bus = await get_message_bus()
+    await message_bus.send(RefreshRegistryBranches())
+
+    return new_node
+
+
+async def convert_object_type(
+    node: Node,
+    target_schema: NodeSchema,
+    mapping: dict[str, ConversionFieldInput],
+    branch: Branch,
+    db: InfrahubDatabase,
+) -> Node:
+    """Delete the node and return the new created one. If creation fails, the node is not deleted, and raise an error.
+    An extra check is performed on input node peers relationships to make sure they are still valid."""
+
+    node_schema = node.get_schema()
+    if not isinstance(node_schema, NodeSchema):
+        raise ValueError(f"Only a node with a NodeSchema can be converted, got {type(node_schema)}")
+
+    # Delete the node, so we delete relationships with peers as well, which might temporarily break cardinality constraints
+    # but they should be restored when creating the new node.
+    deleted_nodes = await NodeManager.delete(db=db, branch=branch, nodes=[node], cascade_delete=False)
+    if len(deleted_nodes) != 1:
+        raise ValueError(f"Deleted {len(deleted_nodes)} nodes instead of 1")
+
+    data_new_node = await build_data_new_node(db, mapping, node)
+
+    if node_schema.branch == BranchSupportType.AGNOSTIC and _has_pass_thru_aware_attributes(
+        node_schema=node_schema, mapping=mapping
+    ):
+        if not branch.is_default:
+            raise ValueError(
+                f"Conversion of {node_schema.kind} is not allowed on branch {branch.name} because it is agnostic and has aware attributes"
+            )
+
+        # When converting an agnostic node with aware attributes, we need to put other branches in NEED_REBASE state
+        # as aware attributes do not exist in other branches after conversion
+        other_branches = await _get_other_active_branches(db=db)
+        for br in other_branches:
+            br.status = BranchStatus.NEED_REBASE
+            await br.save(db=db)
+            # Registry of other API workers are updated outside the transaction
+            await update_branch_registry(db=db, branch=br)
+
+    node_created = await create_node(
+        data=data_new_node,
+        db=db,
+        branch=branch,
+        schema=target_schema,
+    )
+
+    # If the node had some value reserved in any Pools / Resource Manager, we need to change the identifier of the reservation(s)
+    query = await PoolChangeReserved.init(
+        db=db,
+        existing_identifier=node.get_id(),
+        new_identifier=node_created.get_id(),
+        branch=branch,
+    )
+    await query.execute(db=db)
+
+    return node_created

infrahub/core/convert_object_type/repository_conversion.py

@@ -0,0 +1,89 @@
+from infrahub import lock
+from infrahub.core.branch import Branch
+from infrahub.core.constants.infrahubkind import REPOSITORYVALIDATOR, USERVALIDATOR
+from infrahub.core.convert_object_type.object_conversion import (
+    ConversionFieldInput,
+    convert_object_type,
+    validate_conversion,
+)
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.protocols import CoreReadOnlyRepository, CoreRepository
+from infrahub.core.schema import NodeSchema
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+from infrahub.message_bus.messages import RefreshRegistryBranches
+from infrahub.repositories.create_repository import RepositoryFinalizer
+from infrahub.workers.dependencies import get_message_bus
+
+
+async def convert_repository_type(
+    repository: CoreRepository | CoreReadOnlyRepository,
+    target_schema: NodeSchema,
+    mapping: dict[str, ConversionFieldInput],
+    branch: Branch,
+    db: InfrahubDatabase,
+    repository_post_creator: RepositoryFinalizer,
+) -> Node:
+    """Delete the node and return the new created one. If creation fails, the node is not deleted, and raise an error.
+    An extra check is performed on input node peers relationships to make sure they are still valid."""
+
+    repo_name = repository.name.value
+    async with lock.registry.get(name=repo_name, namespace="repository"):
+        async with db.start_transaction() as dbt:
+            timestamp_before_conversion = Timestamp()
+
+            # Fetch validators before deleting the repository otherwise validator-repository would no longer exist
+            user_validators = await NodeManager.query(
+                db=dbt, schema=USERVALIDATOR, prefetch_relationships=True, filters={"repository__id": repository.id}
+            )
+            repository_validators = await NodeManager.query(
+                db=dbt,
+                schema=REPOSITORYVALIDATOR,
+                prefetch_relationships=True,
+                filters={"repository__id": repository.id},
+            )
+            new_repository = await convert_object_type(
+                node=repository,  # type: ignore[arg-type]
+                target_schema=target_schema,
+                mapping=mapping,
+                branch=branch,
+                db=dbt,
+            )
+
+            for user_validator in user_validators:
+                await user_validator.repository.update(db=dbt, data=new_repository)
+                await user_validator.repository.save(db=dbt)
+
+            for repository_validator in repository_validators:
+                await repository_validator.repository.update(db=dbt, data=new_repository)
+                await repository_validator.repository.save(db=dbt)
+
+            await validate_conversion(
+                deleted_node=repository,  # type: ignore[arg-type]
+                branch=branch,
+                db=dbt,
+                timestamp_before_conversion=timestamp_before_conversion,
+            )
+
+        # Refresh outside the transaction otherwise other workers would pull outdated branch objects.
+        message_bus = await get_message_bus()
+        await message_bus.send(RefreshRegistryBranches())
+
+        # Following call involve a potential update of `commit` value of the newly created repository
+        # that would be done from another database connection so it can't be performed within above transaction.
+        # Also note since the conversion can only be performed on main branch here, it is fine that we do it
+        # after having updating other branches status to NEEDS_REBASE.
+        await repository_post_creator.post_create(
+            branch=branch,
+            obj=new_repository,  # type: ignore
+            db=db,
+            delete_on_connectivity_failure=False,
+        )
+
+        # Delete the RepositoryGroup associated with the old repository, as a new one was created for the new repository.
+        repository_groups = (await repository.groups_objects.get_peers(db=db)).values()
+        for repository_group in repository_groups:
+            await NodeManager.delete(db=db, branch=branch, nodes=[repository_group], cascade_delete=False)
+
+    return new_repository

infrahub/core/convert_object_type/schema_mapping.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel
 
-from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.constants import BranchSupportType, RelationshipCardinality
 from infrahub.core.schema import NodeSchema
 
 
@@ -13,6 +13,21 @@ class SchemaMappingValue(BaseModel):
 SchemaMapping = dict[str, SchemaMappingValue]
 
 
+def _are_branch_support_matching(
+    left_branch_support: BranchSupportType | None,
+    right_branch_support: BranchSupportType | None,
+) -> bool:
+    if left_branch_support == right_branch_support:
+        return True
+
+    local_aware = [BranchSupportType.AWARE, BranchSupportType.LOCAL]
+
+    if left_branch_support in local_aware and right_branch_support in local_aware:
+        return True
+
+    return False
+
+
 def get_schema_mapping(source_schema: NodeSchema, target_schema: NodeSchema) -> SchemaMapping:
     """
     Return fields mapping meant to be used for converting a node from `source_kind` to `target_kind`.
@@ -31,7 +46,11 @@ def get_schema_mapping(source_schema: NodeSchema, target_schema: NodeSchema) ->
     # Process attributes
     for target_attr in target_schema.attributes:
         source_attr = source_attrs.get(target_attr.name)
-        if source_attr and source_attr.kind == target_attr.kind:
+        if (
+            source_attr
+            and source_attr.kind == target_attr.kind
+            and _are_branch_support_matching(source_attr.branch, target_attr.branch)
+        ):
             target_field_to_source_field[target_attr.name] = SchemaMappingValue(
                 source_field_name=source_attr.name, is_mandatory=not target_attr.optional
             )
@@ -41,7 +60,12 @@ def get_schema_mapping(source_schema: NodeSchema, target_schema: NodeSchema) ->
     # Process relationships
     for target_rel in target_schema.relationships:
         source_rel = source_rels.get(target_rel.name)
-        if source_rel and source_rel.peer == target_rel.peer and source_rel.cardinality == target_rel.cardinality:
+        if (
+            source_rel
+            and source_rel.peer == target_rel.peer
+            and source_rel.cardinality == target_rel.cardinality
+            and _are_branch_support_matching(source_rel.branch, target_rel.branch)
+        ):
             target_field_to_source_field[target_rel.name] = SchemaMappingValue(
                 source_field_name=source_rel.name,
                 is_mandatory=not target_rel.optional,

infrahub/core/diff/calculator.py

@@ -141,8 +141,8 @@ class DiffCalculator:
             to_time=to_time,
             previous_node_field_specifiers=previous_node_specifiers,
         )
-        node_limit = int(config.SETTINGS.database.query_size_limit / 10)
-        fields_limit = int(config.SETTINGS.database.query_size_limit / 3)
+        node_limit = max(int(config.SETTINGS.database.query_size_limit / 10), 1)
+        fields_limit = max(int(config.SETTINGS.database.query_size_limit / 3), 1)
         properties_limit = config.SETTINGS.database.query_size_limit
 
         calculation_request = DiffCalculationRequest(

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/diff/query/artifact.py

@@ -201,4 +201,5 @@ CALL (target_node, definition_node){
             "target_checksum",
             "target_storage_id",
         ]
+        self.order_by = ["source_artifact.uuid", "target_node.uuid", "definition_node.uuid"]
         self.add_to_query(query=query)

infrahub/core/diff/query/delete_query.py

@@ -20,10 +20,14 @@ class EnrichedDiffDeleteQuery(Query):
             diff_filter = "WHERE d_root.uuid IN $diff_root_uuids"
 
         query = """
-        MATCH (d_root:DiffRoot)
-        %(diff_filter)s
-        OPTIONAL MATCH (d_root)-[*]->(diff_thing)
-        DETACH DELETE diff_thing
-        DETACH DELETE d_root
+MATCH (d_root:DiffRoot)
+%(diff_filter)s
+OPTIONAL MATCH (d_root)-[*]->(diff_thing)
+WITH DISTINCT d_root, diff_thing
+ORDER BY elementId(diff_thing)
+CALL (diff_thing) {
+    DETACH DELETE diff_thing
+} IN TRANSACTIONS
+DETACH DELETE d_root
         """ % {"diff_filter": diff_filter}
         self.add_to_query(query=query)

infrahub/core/diff/query/field_summary.py

@@ -62,6 +62,7 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
         }
         """
         self.add_to_query(query=query)
+        self.order_by = ["kind"]
         self.return_labels = ["kind", "attr_names", "rel_names"]
 
     async def get_field_summaries(self) -> list[NodeDiffFieldSummary]: