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

infrahub/graphql/manager.py

@@ -780,10 +780,7 @@ class GraphQLSchemaManager:
             attr_kind = get_attr_kind(schema, attr)
             attr_type = get_attribute_type(kind=attr_kind).get_graphql_update()
 
-            # A Field is not required if explicitly indicated or if a default value has been provided
-            required = not attr.optional if not attr.default_value else False
-
-            attrs[attr.name] = graphene.InputField(attr_type, required=required, description=attr.description)
+            attrs[attr.name] = graphene.InputField(attr_type, description=attr.description)
 
         for rel in schema.relationships:
             if rel.internal_peer or rel.read_only:
@@ -791,14 +788,12 @@ class GraphQLSchemaManager:
 
             input_type = self._get_related_input_type(relationship=rel)
 
-            required = not rel.optional
             if rel.cardinality == RelationshipCardinality.ONE:
-                attrs[rel.name] = graphene.InputField(input_type, required=required, description=rel.description)
+                attrs[rel.name] = graphene.InputField(input_type, description=rel.description)
 
             elif rel.cardinality == RelationshipCardinality.MANY:
-                attrs[rel.name] = graphene.InputField(
-                    graphene.List(input_type), required=required, description=rel.description
-                )
+                attrs[rel.name] = graphene.InputField(graphene.List(input_type), description=rel.description)
+
         input_name = f"{schema.kind}UpsertInput"
         md5hash = hashlib.md5(usedforsecurity=False)
         md5hash.update(f"{input_name}{schema.get_hash()}".encode())

infrahub/graphql/mutations/convert_object_type.py

@@ -10,9 +10,11 @@ from infrahub.core.convert_object_type.object_conversion import ConversionFieldI
 from infrahub.core.convert_object_type.repository_conversion import convert_repository_type
 from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
 from infrahub.core.manager import NodeManager
+from infrahub.exceptions import ValidationError
 from infrahub.repositories.create_repository import RepositoryFinalizer
 
 if TYPE_CHECKING:
+    from infrahub.core.attribute import BaseAttribute
     from infrahub.graphql.initialization import GraphqlContext
 
 
@@ -49,7 +51,9 @@ class ConvertObjectType(Mutation):
 
         fields_mapping: dict[str, ConversionFieldInput] = {}
         if not isinstance(data.fields_mapping, dict):
-            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(data.fields_mapping)}")
+            raise ValidationError(
+                input_value=f"Expected `fields_mapping` to be a `dict`, got {type(data.fields_mapping)}"
+            )
 
         for field_name, input_for_dest_field_str in data.fields_mapping.items():
             fields_mapping[field_name] = ConversionFieldInput(**input_for_dest_field_str)
@@ -57,6 +61,12 @@ class ConvertObjectType(Mutation):
         node_to_convert = await NodeManager.get_one(
             id=str(data.node_id), db=graphql_context.db, branch=graphql_context.branch
         )
+        for attribute_name in source_schema.attribute_names:
+            attribute: BaseAttribute = getattr(node_to_convert, attribute_name)
+            if attribute.is_from_profile:
+                raise ValidationError(
+                    input_value=f"The attribute '{attribute_name}' is from a profile, converting objects that use profiles is not yet supported."
+                )
 
         # Complete fields mapping with auto-mapping.
         mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)

infrahub/graphql/mutations/display_label.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from graphene import Boolean, InputObjectType, Mutation, String
+
+from infrahub.core.account import ObjectPermission
+from infrahub.core.constants import GlobalPermissions, PermissionAction, PermissionDecision
+from infrahub.core.manager import NodeManager
+from infrahub.core.registry import registry
+from infrahub.database import retry_db_transaction
+from infrahub.events import EventMeta
+from infrahub.events.node_action import NodeUpdatedEvent
+from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
+from infrahub.log import get_log_data
+from infrahub.permissions import define_global_permission_from_branch
+from infrahub.worker import WORKER_IDENTITY
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class InfrahubDisplayLabelUpdateInput(InputObjectType):
+    id = String(required=True)
+    kind = String(required=True)
+    value = String(required=True)
+
+
+class UpdateDisplayLabel(Mutation):
+    class Arguments:
+        data = InfrahubDisplayLabelUpdateInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_display_label")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubDisplayLabelUpdateInput,
+        context: ContextInput | None = None,
+    ) -> UpdateDisplayLabel:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+        if not node_schema.display_label:
+            raise ValidationError(input_value=f"{node_schema.kind}.display_label has not been defined for this kind.")
+
+        graphql_context.active_permissions.raise_for_permissions(
+            permissions=[
+                define_global_permission_from_branch(
+                    permission=GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL,
+                    branch_name=graphql_context.branch.name,
+                ),
+                ObjectPermission(
+                    namespace=node_schema.namespace,
+                    name=node_schema.name,
+                    action=PermissionAction.UPDATE.value,
+                    decision=PermissionDecision.ALLOW_DEFAULT.value
+                    if graphql_context.branch.name == registry.default_branch
+                    else PermissionDecision.ALLOW_OTHER.value,
+                ),
+            ]
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        if not (
+            target_node := await NodeManager.get_one(
+                db=graphql_context.db,
+                kind=node_schema.kind,
+                id=str(data.id),
+                branch=graphql_context.branch,
+                fields={"display_label": None},
+            )
+        ):
+            raise NodeNotFoundError(
+                node_type=node_schema.kind,
+                identifier=str(data.id),
+                message="The targeted node was not found in the database",
+            )
+
+        existing_label = (
+            await target_node.get_display_label(db=graphql_context.db) if target_node.has_display_label() else None
+        )
+        if str(data.value) != existing_label:
+            await target_node.set_display_label(value=str(data.value))
+
+            async with graphql_context.db.start_transaction() as dbt:
+                await target_node.save(db=dbt, fields=["display_label"])
+
+            log_data = get_log_data()
+            request_id = log_data.get("request_id", "")
+
+            event = NodeUpdatedEvent(
+                kind=node_schema.kind,
+                node_id=target_node.get_id(),
+                changelog=target_node.node_changelog.model_dump(),
+                fields=["display_label"],
+                meta=EventMeta(
+                    context=graphql_context.get_context(),
+                    initiator_id=WORKER_IDENTITY,
+                    request_id=request_id,
+                    account_id=graphql_context.active_account_session.account_id,
+                    branch=graphql_context.branch,
+                ),
+            )
+            await graphql_context.active_service.event.send(event=event)
+
+        result: dict[str, Any] = {"ok": True}
+
+        return cls(**result)

infrahub/graphql/mutations/generator.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING
 from graphene import Boolean, Field, InputField, InputObjectType, List, Mutation, NonNull, String
 
 from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreGeneratorDefinition, CoreGenericRepository, CoreGraphQLQuery, CoreStandardGroup
 from infrahub.generators.models import ProposedChangeGeneratorDefinition, RequestGeneratorDefinitionRun
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.types.context import ContextInput
@@ -44,11 +45,18 @@ class GeneratorDefinitionRequestRun(Mutation):
         db = graphql_context.db
         await apply_external_context(graphql_context=graphql_context, context_input=context)
         generator_definition = await NodeManager.get_one(
-            id=str(data.id), db=db, branch=graphql_context.branch, prefetch_relationships=True, raise_on_error=True
+            id=str(data.id),
+            kind=CoreGeneratorDefinition,
+            db=db,
+            branch=graphql_context.branch,
+            prefetch_relationships=True,
+            raise_on_error=True,
         )
-        query = await generator_definition.query.get_peer(db=db)
-        repository = await generator_definition.repository.get_peer(db=db)
-        group = await generator_definition.targets.get_peer(db=db)
+        query = await generator_definition.query.get_peer(db=db, peer_type=CoreGraphQLQuery, raise_on_error=True)
+        repository = await generator_definition.repository.get_peer(
+            db=db, peer_type=CoreGenericRepository, raise_on_error=True
+        )
+        group = await generator_definition.targets.get_peer(db=db, peer_type=CoreStandardGroup, raise_on_error=True)
 
         request_model = RequestGeneratorDefinitionRun(
             generator_definition=ProposedChangeGeneratorDefinition(
@@ -57,11 +65,21 @@ class GeneratorDefinitionRequestRun(Mutation):
                 class_name=generator_definition.class_name.value,
                 file_path=generator_definition.file_path.value,
                 query_name=query.name.value,
-                query_models=query.models.value,
+                query_models=query.models.value or [],
                 repository_id=repository.id,
-                parameters=generator_definition.parameters.value,
+                parameters=generator_definition.parameters.value
+                if isinstance(generator_definition.parameters.value, dict)
+                else {},
                 group_id=group.id,
-                convert_query_response=generator_definition.convert_query_response.value or False,
+                convert_query_response=generator_definition.convert_query_response.value
+                if generator_definition.convert_query_response.value is not None
+                else False,
+                execute_in_proposed_change=generator_definition.execute_in_proposed_change.value
+                if generator_definition.execute_in_proposed_change.value is not None
+                else True,
+                execute_after_merge=generator_definition.execute_after_merge.value
+                if generator_definition.execute_after_merge.value is not None
+                else True,
             ),
             branch=graphql_context.branch.name,
             target_members=data.get("nodes", []),

infrahub/graphql/mutations/hfid.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from graphene import Boolean, InputObjectType, List, Mutation, NonNull, String
+
+from infrahub.core.account import ObjectPermission
+from infrahub.core.constants import GlobalPermissions, PermissionAction, PermissionDecision
+from infrahub.core.manager import NodeManager
+from infrahub.core.registry import registry
+from infrahub.database import retry_db_transaction
+from infrahub.events import EventMeta
+from infrahub.events.node_action import NodeUpdatedEvent
+from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
+from infrahub.log import get_log_data
+from infrahub.permissions import define_global_permission_from_branch
+from infrahub.worker import WORKER_IDENTITY
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class InfrahubHFIDUpdateInput(InputObjectType):
+    id = String(required=True)
+    kind = String(required=True)
+    value = List(NonNull(String), required=True)
+
+
+class UpdateHFID(Mutation):
+    class Arguments:
+        data = InfrahubHFIDUpdateInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_hfid")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubHFIDUpdateInput,
+        context: ContextInput | None = None,
+    ) -> UpdateHFID:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+        if node_schema.human_friendly_id is None:
+            raise ValidationError(
+                input_value=f"{node_schema.kind}.human_friendly_id has not been defined for this kind."
+            )
+
+        updated_hfid = cast(list[str], data.value)
+
+        if len(node_schema.human_friendly_id) != len(updated_hfid):
+            raise ValidationError(
+                input_value=f"{node_schema.kind}.human_friendly_id requires {len(node_schema.human_friendly_id)} parts data has {len(updated_hfid)}"
+            )
+
+        graphql_context.active_permissions.raise_for_permissions(
+            permissions=[
+                define_global_permission_from_branch(
+                    permission=GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL,
+                    branch_name=graphql_context.branch.name,
+                ),
+                ObjectPermission(
+                    namespace=node_schema.namespace,
+                    name=node_schema.name,
+                    action=PermissionAction.UPDATE.value,
+                    decision=PermissionDecision.ALLOW_DEFAULT.value
+                    if graphql_context.branch.name == registry.default_branch
+                    else PermissionDecision.ALLOW_OTHER.value,
+                ),
+            ]
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        if not (
+            target_node := await NodeManager.get_one(
+                db=graphql_context.db,
+                kind=node_schema.kind,
+                id=str(data.id),
+                branch=graphql_context.branch,
+                fields={"human_friendly_id": None},
+            )
+        ):
+            raise NodeNotFoundError(
+                node_type=node_schema.kind,
+                identifier=str(data.id),
+                message="The targeted node was not found in the database",
+            )
+
+        existing = await target_node.get_hfid(db=graphql_context.db) if target_node.has_human_friendly_id() else None
+        if updated_hfid != existing:
+            await target_node.set_human_friendly_id(value=updated_hfid)
+
+            async with graphql_context.db.start_transaction() as dbt:
+                await target_node.save(db=dbt, fields=["human_friendly_id"])
+
+            log_data = get_log_data()
+            request_id = log_data.get("request_id", "")
+
+            event = NodeUpdatedEvent(
+                kind=node_schema.kind,
+                node_id=target_node.get_id(),
+                changelog=target_node.node_changelog.model_dump(),
+                fields=["human_friendly_id"],
+                meta=EventMeta(
+                    context=graphql_context.get_context(),
+                    initiator_id=WORKER_IDENTITY,
+                    request_id=request_id,
+                    account_id=graphql_context.active_account_session.account_id,
+                    branch=graphql_context.branch,
+                ),
+            )
+            await graphql_context.active_service.event.send(event=event)
+
+        result: dict[str, Any] = {"ok": True}
+
+        return cls(**result)

infrahub/graphql/mutations/ipam.py

@@ -20,7 +20,7 @@ from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_logger
 
 from ...core.node.create import create_node
-from ...core.node.lock_utils import build_object_lock_name
+from ...core.node.lock_utils import build_object_lock_name, get_lock_names_on_object_mutation
 from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions, build_graphql_response
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
@@ -108,11 +108,11 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
     @staticmethod
-    def _get_lock_name(namespace_id: str, branch: Branch) -> str | None:
+    def _get_lock_names(namespace_id: str, branch: Branch) -> list[str]:
         if not branch.is_default:
             # Do not lock on other branches as reconciliation will be performed at least when merging in main branch.
-            return None
-        return build_object_lock_name(InfrahubKind.IPADDRESS + "_" + namespace_id)
+            return []
+        return [build_object_lock_name(InfrahubKind.IPADDRESS + "_" + namespace_id)]
 
     @classmethod
     async def _mutate_create_object_and_reconcile(
@@ -150,17 +150,13 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         ip_address = ipaddress.ip_interface(data["address"]["value"])
         namespace_id = await validate_namespace(db=db, branch=branch, data=data)
 
-        async with db.start_transaction() as dbt:
-            if lock_name := cls._get_lock_name(namespace_id, branch):
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
-                    reconciled_address = await cls._mutate_create_object_and_reconcile(
-                        data=data, branch=branch, db=dbt, ip_address=ip_address, namespace_id=namespace_id
-                    )
-            else:
+        lock_names = cls._get_lock_names(namespace_id, branch)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            async with db.start_transaction() as dbt:
                 reconciled_address = await cls._mutate_create_object_and_reconcile(
                     data=data, branch=branch, db=dbt, ip_address=ip_address, namespace_id=namespace_id
                 )
-            graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_address)
+                graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_address)
 
         return reconciled_address, cls(**graphql_response)
 
@@ -206,18 +202,28 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         namespace = await address.ip_namespace.get_peer(db)
         namespace_id = await validate_namespace(db=db, branch=branch, data=data, existing_namespace_id=namespace.id)
 
-        async with db.start_transaction() as dbt:
-            if lock_name := cls._get_lock_name(namespace_id, branch):
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
+        # Prepare a clone to compute locks without triggering pool allocations
+        preview_obj = await NodeManager.get_one_by_id_or_default_filter(
+            db=db,
+            kind=address.get_kind(),
+            id=address.get_id(),
+            branch=branch,
+        )
+        await preview_obj.from_graphql(db=db, data=data, process_pools=False)
+
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+        lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+        namespace_lock_names = cls._get_lock_names(namespace_id, branch)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=namespace_lock_names):
+            # FIXME: do not lock when data does not contain uniqueness constraint fields or resource pool allocations
+            async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+                async with db.start_transaction() as dbt:
                     reconciled_address = await cls._mutate_update_object_and_reconcile(
                         info=info, data=data, branch=branch, address=address, namespace_id=namespace_id, db=dbt
                     )
-            else:
-                reconciled_address = await cls._mutate_update_object_and_reconcile(
-                    info=info, data=data, branch=branch, address=address, namespace_id=namespace_id, db=dbt
-                )
 
-            result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_address)
+                    result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_address)
 
         return address, result
 
@@ -269,11 +275,11 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
     @staticmethod
-    def _get_lock_name(namespace_id: str) -> str | None:
+    def _get_lock_names(namespace_id: str) -> list[str]:
         # IPPrefix has some cardinality-one relationships involved (parent/child/ip_address),
         # so we need to lock on any branch to avoid creating multiple peers for these relationships
         # during concurrent ipam reconciliations.
-        return build_object_lock_name(InfrahubKind.IPPREFIX + "_" + namespace_id)
+        return [build_object_lock_name(InfrahubKind.IPPREFIX + "_" + namespace_id)]
 
     @classmethod
     async def _mutate_create_object_and_reconcile(
@@ -306,9 +312,9 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         db = database or graphql_context.db
         namespace_id = await validate_namespace(db=db, branch=branch, data=data)
 
-        async with db.start_transaction() as dbt:
-            lock_name = cls._get_lock_name(namespace_id)
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
+        lock_names = cls._get_lock_names(namespace_id)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            async with db.start_transaction() as dbt:
                 reconciled_prefix = await cls._mutate_create_object_and_reconcile(
                     data=data, branch=branch, db=dbt, namespace_id=namespace_id
                 )
@@ -356,13 +362,26 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         namespace = await prefix.ip_namespace.get_peer(db)
         namespace_id = await validate_namespace(db=db, branch=branch, data=data, existing_namespace_id=namespace.id)
 
-        async with db.start_transaction() as dbt:
-            lock_name = cls._get_lock_name(namespace_id)
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
-                reconciled_prefix = await cls._mutate_update_object_and_reconcile(
-                    info=info, data=data, prefix=prefix, db=dbt, namespace_id=namespace_id, branch=branch
-                )
-            result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_prefix)
+        # Prepare a clone to compute locks without triggering pool allocations
+        preview_obj = await NodeManager.get_one_by_id_or_default_filter(
+            db=db,
+            kind=prefix.get_kind(),
+            id=prefix.get_id(),
+            branch=branch,
+        )
+        await preview_obj.from_graphql(db=db, data=data, process_pools=False)
+
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+        lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+        namespace_lock_names = cls._get_lock_names(namespace_id)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=namespace_lock_names):
+            async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+                async with db.start_transaction() as dbt:
+                    reconciled_prefix = await cls._mutate_update_object_and_reconcile(
+                        info=info, data=data, prefix=prefix, db=dbt, namespace_id=namespace_id, branch=branch
+                    )
+                    result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=reconciled_prefix)
 
         return prefix, result
 
@@ -421,9 +440,9 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         namespace_rels = await prefix.ip_namespace.get_relationships(db=db)
         namespace_id = namespace_rels[0].peer_id
 
-        async with graphql_context.db.start_transaction() as dbt:
-            lock_name = cls._get_lock_name(namespace_id)
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
+        lock_names = cls._get_lock_names(namespace_id)
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            async with graphql_context.db.start_transaction() as dbt:
                 reconciled_prefix = await cls._reconcile_prefix(
                     branch=branch, db=dbt, prefix=prefix, namespace_id=namespace_id, is_delete=True
                 )

infrahub/graphql/mutations/main.py

@@ -28,7 +28,7 @@ from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_log_data, get_logger
 from infrahub.profiles.node_applier import NodeProfilesApplier
 
-from ...core.node.lock_utils import get_kind_lock_names_on_object_mutation
+from ...core.node.lock_utils import get_lock_names_on_object_mutation
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
 if TYPE_CHECKING:
@@ -180,41 +180,40 @@ class InfrahubMutationMixin:
         Wrapper around mutate_update to potentially activate locking and call it within a database transaction.
         """
 
-        schema_branch = db.schema.get_schema_branch(name=branch.name)
-        lock_names = get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=dict(data)
+        # Prepare a clone to compute locks without triggering pool allocations
+        preview_obj = await NodeManager.get_one_by_id_or_default_filter(
+            db=db,
+            kind=obj.get_kind(),
+            id=obj.get_id(),
+            branch=branch,
         )
+        await preview_obj.from_graphql(db=db, data=data, process_pools=False)
 
-        if db.is_transaction:
-            if lock_names:
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-                    obj = await cls.mutate_update_object(
-                        db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
-                    )
-            else:
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+        lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+        # FIXME: do not lock when data does not contain uniqueness constraint fields or resource pool allocations
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+            if db.is_transaction:
                 obj = await cls.mutate_update_object(
                     db=db, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
                 )
-            result = await cls.mutate_update_to_graphql(db=db, info=info, obj=obj)
-            return obj, result
 
-        async with db.start_transaction() as dbt:
-            if lock_names:
-                async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-                    obj = await cls.mutate_update_object(
-                        db=dbt,
-                        info=info,
-                        data=data,
-                        branch=branch,
-                        obj=obj,
-                        skip_uniqueness_check=skip_uniqueness_check,
-                    )
-            else:
+                result = await cls.mutate_update_to_graphql(db=db, info=info, obj=obj)
+                return obj, result
+
+            async with db.start_transaction() as dbt:
                 obj = await cls.mutate_update_object(
-                    db=dbt, info=info, data=data, branch=branch, obj=obj, skip_uniqueness_check=skip_uniqueness_check
+                    db=dbt,
+                    info=info,
+                    data=data,
+                    branch=branch,
+                    obj=obj,
+                    skip_uniqueness_check=skip_uniqueness_check,
                 )
-            result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
-            return obj, result
+
+                result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
+                return obj, result
 
     @classmethod
     @retry_db_transaction(name="object_update")

infrahub/graphql/mutations/relationship.py

@@ -91,7 +91,7 @@ class RelationshipAdd(Mutation):
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         rel_schema = source.get_schema().get_relationship(name=relationship_name)
-        display_label: str = await source.render_display_label(db=graphql_context.db)
+        display_label: str = await source.get_display_label(db=graphql_context.db) or ""
         node_changelog = NodeChangelog(
             node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
         )
@@ -214,7 +214,7 @@ class RelationshipRemove(Mutation):
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         rel_schema = source.get_schema().get_relationship(name=relationship_name)
-        display_label: str = await source.render_display_label(db=graphql_context.db)
+        display_label: str = await source.get_display_label(db=graphql_context.db) or ""
         node_changelog = NodeChangelog(
             node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
         )

infrahub/graphql/mutations/resource_manager.py

@@ -98,7 +98,7 @@ class IPPrefixPoolGetResource(Mutation):
                 "id": resource.id,
                 "kind": resource.get_kind(),
                 "identifier": data.get("identifier", None),
-                "display_label": await resource.render_display_label(db=graphql_context.db),
+                "display_label": await resource.get_display_label(db=graphql_context.db),
                 "branch": graphql_context.branch.name,
             },
         }
@@ -144,7 +144,7 @@ class IPAddressPoolGetResource(Mutation):
                 "id": resource.id,
                 "kind": resource.get_kind(),
                 "identifier": data.get("identifier"),
-                "display_label": await resource.render_display_label(db=graphql_context.db),
+                "display_label": await resource.get_display_label(db=graphql_context.db),
                 "branch": graphql_context.branch.name,
             },
         }