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

infrahub/core/node/__init__.py

@@ -42,10 +42,12 @@ from infrahub.types import ATTRIBUTE_TYPES
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
 from ...graphql.models import OrderModel
 from ...log import get_logger
+from ..attribute import BaseAttribute
 from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
 from .base import BaseNode, BaseNodeMeta, BaseNodeOptions
+from .node_property_attribute import DisplayLabel, HumanFriendlyIdentifier
 
 if TYPE_CHECKING:
     from typing_extensions import Self
@@ -53,8 +55,6 @@ if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.database import InfrahubDatabase
 
-    from ..attribute import BaseAttribute
-
 SchemaProtocol = TypeVar("SchemaProtocol")
 
 # ---------------------------------------------------------------------------------------
@@ -80,6 +80,29 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         _meta.default_filter = default_filter
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
+    def __init__(self, schema: NodeSchema | ProfileSchema | TemplateSchema, branch: Branch, at: Timestamp):
+        self._schema: NodeSchema | ProfileSchema | TemplateSchema = schema
+        self._branch: Branch = branch
+        self._at: Timestamp = at
+        self._existing: bool = False
+
+        self._updated_at: Timestamp | None = None
+        self.id: str = None
+        self.db_id: str = None
+
+        self._source: Node | None = None
+        self._owner: Node | None = None
+        self._is_protected: bool = None
+        self._computed_jinja2_attributes: list[str] = []
+
+        self._display_label: DisplayLabel | None = None
+        self._human_friendly_id: HumanFriendlyIdentifier | None = None
+
+        # Lists of attributes and relationships names
+        self._attributes: list[str] = []
+        self._relationships: list[str] = []
+        self._node_changelog: NodeChangelog | None = None
+
     def get_schema(self) -> NonGenericSchemaTypes:
         return self._schema
 
@@ -100,16 +123,41 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     def get_updated_at(self) -> Timestamp | None:
         return self._updated_at
 
+    def get_attribute(self, name: str) -> BaseAttribute:
+        attribute = getattr(self, name)
+        if not isinstance(attribute, BaseAttribute):
+            raise ValueError(f"{name} is not an attribute of {self.get_kind()}")
+        return attribute
+
+    def get_relationship(self, name: str) -> RelationshipManager:
+        relationship = getattr(self, name)
+        if not isinstance(relationship, RelationshipManager):
+            raise ValueError(f"{name} is not a relationship of {self.get_kind()}")
+        return relationship
+
+    def uses_profiles(self) -> bool:
+        for attr_name in self.get_schema().attribute_names:
+            try:
+                node_attr = self.get_attribute(attr_name)
+            except ValueError:
+                continue
+            if node_attr and node_attr.is_from_profile:
+                return True
+        return False
+
     async def get_hfid(self, db: InfrahubDatabase, include_kind: bool = False) -> list[str] | None:
         """Return the Human friendly id of the node."""
         if not self._schema.human_friendly_id:
             return None
 
-        hfid_values = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+        hfid_values: list[str] | None = None
+        if self._human_friendly_id:
+            hfid_values = self._human_friendly_id.get_value(node=self, at=self._at)
+        if not hfid_values:
+            hfid_values = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+
         hfid = [value for value in hfid_values if value is not None]
-        if include_kind:
-            return [self.get_kind()] + hfid
-        return hfid
+        return [self.get_kind()] + hfid if include_kind else hfid
 
     async def get_hfid_as_string(self, db: InfrahubDatabase, include_kind: bool = False) -> str | None:
         """Return the Human friendly id of the node in string format separated with a dunder (__) ."""
@@ -118,6 +166,37 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             return None
         return "__".join(hfid)
 
+    def has_human_friendly_id(self) -> bool:
+        return self._human_friendly_id is not None
+
+    async def add_human_friendly_id(self, db: InfrahubDatabase) -> None:
+        if not self._schema.human_friendly_id or self._human_friendly_id:
+            return
+
+        self._human_friendly_id = HumanFriendlyIdentifier(
+            node_schema=self._schema, template=self._schema.human_friendly_id
+        )
+        await self._human_friendly_id.compute(db=db, node=self)
+
+    async def get_display_label(self, db: InfrahubDatabase) -> str:
+        if self._display_label:
+            if isinstance(self._display_label._value, str):
+                return self._display_label._value
+            if self._display_label._value:
+                return self._display_label._value.value
+
+        return await self.render_display_label(db=db)
+
+    def has_display_label(self) -> bool:
+        return self._display_label is not None
+
+    async def add_display_label(self, db: InfrahubDatabase) -> None:
+        if not self._schema.display_label or self._display_label:
+            return
+
+        self._display_label = DisplayLabel(node_schema=self._schema, template=self._schema.display_label)
+        await self._display_label.compute(db=db, node=self)
+
     async def get_path_value(self, db: InfrahubDatabase, path: str) -> str:
         schema_path = self._schema.parse_schema_path(
             path=path, schema=db.schema.get_schema_branch(name=self._branch.name)
@@ -176,30 +255,8 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return self._branch
 
     def __repr__(self) -> str:
-        if not self._existing:
-            return f"{self.get_kind()}(ID: {str(self.id)})[NEW]"
-
-        return f"{self.get_kind()}(ID: {str(self.id)})"
-
-    def __init__(self, schema: NodeSchema | ProfileSchema | TemplateSchema, branch: Branch, at: Timestamp):
-        self._schema: NodeSchema | ProfileSchema | TemplateSchema = schema
-        self._branch: Branch = branch
-        self._at: Timestamp = at
-        self._existing: bool = False
-
-        self._updated_at: Timestamp | None = None
-        self.id: str = None
-        self.db_id: str = None
-
-        self._source: Node | None = None
-        self._owner: Node | None = None
-        self._is_protected: bool = None
-        self._computed_jinja2_attributes: list[str] = []
-
-        # Lists of attributes and relationships names
-        self._attributes: list[str] = []
-        self._relationships: list[str] = []
-        self._node_changelog: NodeChangelog | None = None
+        v = f"{self.get_kind()}(ID: {str(self.id)})"
+        return v if self._existing else f"{v}[NEW]"
 
     @property
     def node_changelog(self) -> NodeChangelog:
@@ -712,12 +769,26 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             )
             self._updated_at = Timestamp(updated_at)
 
+        if not self._schema.is_schema_node:
+            if hfid := kwargs.pop("human_friendly_id", None):
+                self._human_friendly_id = HumanFriendlyIdentifier(
+                    node_schema=self._schema, template=self._schema.human_friendly_id, value=hfid
+                )
+            if display_label := kwargs.pop("display_label", None):
+                self._display_label = DisplayLabel(
+                    node_schema=self._schema, template=self._schema.display_label, value=display_label
+                )
+
         await self._process_fields(db=db, fields=kwargs)
         return self
 
     async def _create(self, db: InfrahubDatabase, at: Timestamp | None = None) -> NodeChangelog:
         create_at = Timestamp(at)
 
+        if not self._schema.is_schema_node:
+            await self.add_human_friendly_id(db=db)
+            await self.add_display_label(db=db)
+
         query = await NodeCreateAllQuery.init(db=db, node=self, at=create_at)
         await query.execute(db=db)
 
@@ -729,6 +800,13 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         new_ids = query.get_ids()
         node_changelog = NodeChangelog(node_id=self.get_id(), node_kind=self.get_kind(), display_label="")
 
+        if self._human_friendly_id:
+            node_changelog.create_attribute(
+                attribute=self._human_friendly_id.get_node_attribute(node=self, at=create_at)
+            )
+        if self._display_label:
+            node_changelog.create_attribute(attribute=self._display_label.get_node_attribute(node=self, at=create_at))
+
         # Go over the list of Attribute and assign the new IDs one by one
         for name in self._attributes:
             attr: BaseAttribute = getattr(self, name)
@@ -741,12 +819,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             relm: RelationshipManager = getattr(self, name)
             for rel in relm._relationships:
                 identifier = f"{rel.schema.identifier}::{rel.peer_id}"
-
                 rel.id, rel.db_id = new_ids[identifier]
-
                 node_changelog.create_relationship(relationship=rel)
 
-        node_changelog.display_label = await self.render_display_label(db=db)
+        node_changelog.display_label = await self.get_display_label(db=db)
         return node_changelog
 
     async def _update(
@@ -782,19 +858,41 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     if parent := await rel.get_parent(db=db):
                         node_changelog.add_parent_from_relationship(parent=parent)
 
-        node_changelog.display_label = await self.render_display_label(db=db)
+        # Update the HFID if one of its variables is being updated
+        if self._human_friendly_id and (
+            (fields and "human_friendly_id" in fields) or self._human_friendly_id.needs_update(fields=fields)
+        ):
+            await self._human_friendly_id.compute(db=db, node=self)
+            updated_attribute = await self._human_friendly_id.get_node_attribute(node=self, at=update_at).save(
+                at=update_at, db=db
+            )
+            if updated_attribute:
+                node_changelog.add_attribute(attribute=updated_attribute)
+
+        # Update the display label if one of its variables is being updated
+        if self._display_label and (
+            (fields and "display_label" in fields) or self._display_label.needs_update(fields=fields)
+        ):
+            await self._display_label.compute(db=db, node=self)
+            self._display_label.get_node_attribute(node=self, at=update_at).get_create_data(node_schema=self._schema)
+            updated_attribute = await self._display_label.get_node_attribute(node=self, at=update_at).save(
+                at=update_at, db=db
+            )
+            if updated_attribute:
+                node_changelog.add_attribute(attribute=updated_attribute)
+
+        node_changelog.display_label = await self.get_display_label(db=db)
         return node_changelog
 
     async def save(self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None) -> Self:
         """Create or Update the Node in the database."""
-
         save_at = Timestamp(at)
 
         if self._existing:
             self._node_changelog = await self._update(at=save_at, db=db, fields=fields)
-            return self
+        else:
+            self._node_changelog = await self._create(at=save_at, db=db)
 
-        self._node_changelog = await self._create(at=save_at, db=db)
         return self
 
     async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
@@ -803,13 +901,24 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         delete_at = Timestamp(at)
 
         node_changelog = NodeChangelog(
-            node_id=self.get_id(), node_kind=self.get_kind(), display_label=await self.render_display_label(db=db)
+            node_id=self.get_id(), node_kind=self.get_kind(), display_label=await self.get_display_label(db=db)
         )
         # Go over the list of Attribute and update them one by one
         for name in self._attributes:
             attr: BaseAttribute = getattr(self, name)
-            deleted_attribute = await attr.delete(at=delete_at, db=db)
-            if deleted_attribute:
+            if deleted_attribute := await attr.delete(at=delete_at, db=db):
+                node_changelog.add_attribute(attribute=deleted_attribute)
+
+        if self._human_friendly_id:
+            if deleted_attribute := await self._human_friendly_id.get_node_attribute(node=self, at=delete_at).delete(
+                at=delete_at, db=db
+            ):
+                node_changelog.add_attribute(attribute=deleted_attribute)
+
+        if self._display_label:
+            if deleted_attribute := await self._display_label.get_node_attribute(node=self, at=delete_at).delete(
+                at=delete_at, db=db
+            ):
                 node_changelog.add_attribute(attribute=deleted_attribute)
 
         branch = self.get_branch_based_on_support_type()
@@ -877,7 +986,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 continue
 
             if field_name == "display_label":
-                response[field_name] = await self.render_display_label(db=db)
+                response[field_name] = await self.get_display_label(db=db)
                 continue
 
             if field_name == "hfid":
@@ -980,6 +1089,20 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             return repr(self)
         return display_label.strip()
 
+    async def set_human_friendly_id(self, value: list[str] | None) -> None:
+        """Set the human friendly ID of this node if one is set. `save()` must be called to commit the change in the database."""
+        if self._human_friendly_id is None:
+            return
+
+        self._human_friendly_id.set_value(value=value, manually_assigned=True)
+
+    async def set_display_label(self, value: str | None) -> None:
+        """Set the display label of this node if one is set. `save()` must be called to commit the change in the database."""
+        if self._display_label is None:
+            return
+
+        self._display_label.set_value(value=value, manually_assigned=True)
+
     def _get_parent_relationship_name(self) -> str | None:
         """Return the name of the parent relationship is one is present"""
         for relationship in self._schema.relationships:
@@ -989,7 +1112,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return None
 
     async def get_object_template(self, db: InfrahubDatabase) -> CoreObjectTemplate | None:
-        object_template: RelationshipManager = getattr(self, OBJECT_TEMPLATE_RELATIONSHIP_NAME, None)
+        object_template: RelationshipManager | None = getattr(self, OBJECT_TEMPLATE_RELATIONSHIP_NAME, None)
         return (
             await object_template.get_peer(db=db, peer_type=CoreObjectTemplate) if object_template is not None else None
         )

infrahub/core/node/constraints/attribute_uniqueness.py

@@ -29,7 +29,9 @@ class NodeAttributeUniquenessConstraint(NodeConstraintInterface):
             attr = getattr(node, unique_attr.name)
             if unique_attr.inherited:
                 for generic_parent_schema_name in node_schema.inherit_from:
-                    generic_parent_schema = self.db.schema.get(generic_parent_schema_name, branch=self.branch)
+                    generic_parent_schema = self.db.schema.get(
+                        generic_parent_schema_name, branch=self.branch, duplicate=False
+                    )
                     parent_attr = generic_parent_schema.get_attribute_or_none(unique_attr.name)
                     if parent_attr is None:
                         continue

infrahub/core/node/create.py

@@ -2,18 +2,23 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Mapping
 
+from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
-from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
+from infrahub.core.node.lock_utils import get_kind_lock_names_on_object_mutation
 from infrahub.core.protocols import CoreObjectTemplate
+from infrahub.core.schema import GenericSchema
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.lock import InfrahubMultiLock
+from infrahub.profiles.node_applier import NodeProfilesApplier
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.relationship.model import RelationshipManager
     from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes, RelationshipSchema
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -76,6 +81,7 @@ async def handle_template_relationships(
     template: CoreObjectTemplate,
     fields: list,
     constraint_runner: NodeConstraintRunner | None = None,
+    at: Timestamp | None = None,
 ) -> None:
     if constraint_runner is None:
         component_registry = get_component_registry()
@@ -103,7 +109,7 @@ async def handle_template_relationships(
                 current_template=template,
             )
 
-            obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch)
+            obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch, at=at)
             await obj_peer.new(db=db, **obj_peer_data)
             await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
             await obj_peer.save(db=db)
@@ -115,6 +121,7 @@ async def handle_template_relationships(
                 obj=obj_peer,
                 template=template_relationship_peer,
                 fields=fields,
+                at=at,
             )
 
 
@@ -125,43 +132,20 @@ async def get_profile_ids(db: InfrahubDatabase, obj: Node) -> set[str]:
     return {pr.peer_id for pr in profile_rels}
 
 
-async def refresh_for_profile_update(
-    db: InfrahubDatabase,
-    branch: Branch,
-    obj: Node,
-    schema: NonGenericSchemaTypes,
-    previous_profile_ids: set[str] | None = None,
-) -> Node:
-    if not hasattr(obj, "profiles"):
-        return obj
-    current_profile_ids = await get_profile_ids(db=db, obj=obj)
-    if previous_profile_ids is None or previous_profile_ids != current_profile_ids:
-        refreshed_node = await NodeManager.get_one_by_id_or_default_filter(
-            db=db,
-            kind=schema.kind,
-            id=obj.get_id(),
-            branch=branch,
-            include_owner=True,
-            include_source=True,
-        )
-        refreshed_node._node_changelog = obj.node_changelog
-        return refreshed_node
-    return obj
-
-
 async def _do_create_node(
     node_class: type[Node],
+    node_constraint_runner: NodeConstraintRunner,
     db: InfrahubDatabase,
-    data: dict,
     schema: NonGenericSchemaTypes,
-    fields_to_validate: list,
     branch: Branch,
-    node_constraint_runner: NodeConstraintRunner,
+    fields_to_validate: list[str],
+    data: dict[str, Any],
+    at: Timestamp | None = None,
 ) -> Node:
     obj = await node_class.init(db=db, schema=schema, branch=branch)
     await obj.new(db=db, **data)
     await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-    await obj.save(db=db)
+    await obj.save(db=db, at=at)
 
     object_template = await obj.get_object_template(db=db)
     if object_template:
@@ -171,18 +155,62 @@ async def _do_create_node(
             template=object_template,
             obj=obj,
             fields=fields_to_validate,
+            at=at,
         )
     return obj
 
 
+async def _do_create_node_with_lock(
+    node_class: type[Node],
+    node_constraint_runner: NodeConstraintRunner,
+    db: InfrahubDatabase,
+    schema: NonGenericSchemaTypes,
+    branch: Branch,
+    fields_to_validate: list[str],
+    data: dict[str, Any],
+    at: Timestamp | None = None,
+) -> Node:
+    schema_branch = registry.schema.get_schema_branch(name=branch.name)
+    lock_names = get_kind_lock_names_on_object_mutation(
+        kind=schema.kind, branch=branch, schema_branch=schema_branch, data=dict(data)
+    )
+
+    if lock_names:
+        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
+            return await _do_create_node(
+                node_class=node_class,
+                node_constraint_runner=node_constraint_runner,
+                db=db,
+                schema=schema,
+                branch=branch,
+                fields_to_validate=fields_to_validate,
+                data=data,
+                at=at,
+            )
+    return await _do_create_node(
+        node_class=node_class,
+        node_constraint_runner=node_constraint_runner,
+        db=db,
+        schema=schema,
+        branch=branch,
+        fields_to_validate=fields_to_validate,
+        data=data,
+        at=at,
+    )
+
+
 async def create_node(
-    data: dict,
+    data: dict[str, Any],
     db: InfrahubDatabase,
     branch: Branch,
-    schema: NonGenericSchemaTypes,
+    schema: MainSchemaTypes,
+    at: Timestamp | None = None,
 ) -> Node:
     """Create a node in the database if constraint checks succeed."""
 
+    if isinstance(schema, GenericSchema):
+        raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+
     component_registry = get_component_registry()
     node_constraint_runner = await component_registry.get_component(
         NodeConstraintRunner, db=db.start_session() if not db.is_transaction else db, branch=branch
@@ -193,7 +221,7 @@ async def create_node(
 
     fields_to_validate = list(data)
     if db.is_transaction:
-        obj = await _do_create_node(
+        obj = await _do_create_node_with_lock(
             node_class=node_class,
             node_constraint_runner=node_constraint_runner,
             db=db,
@@ -201,10 +229,11 @@ async def create_node(
             branch=branch,
             fields_to_validate=fields_to_validate,
             data=data,
+            at=at,
         )
     else:
         async with db.start_transaction() as dbt:
-            obj = await _do_create_node(
+            obj = await _do_create_node_with_lock(
                 node_class=node_class,
                 node_constraint_runner=node_constraint_runner,
                 db=dbt,
@@ -212,9 +241,12 @@ async def create_node(
                 branch=branch,
                 fields_to_validate=fields_to_validate,
                 data=data,
+                at=at,
             )
 
     if await get_profile_ids(db=db, obj=obj):
-        obj = await refresh_for_profile_update(db=db, branch=branch, schema=schema, obj=obj)
+        node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+        await node_profiles_applier.apply_profiles(node=obj)
+        await obj.save(db=db)
 
     return obj

infrahub/core/node/lock_utils.py

@@ -0,0 +1,98 @@
+import hashlib
+from typing import Any
+
+from infrahub.core.branch import Branch
+from infrahub.core.constants.infrahubkind import GENERICGROUP, GRAPHQLQUERYGROUP
+from infrahub.core.schema import GenericSchema
+from infrahub.core.schema.schema_branch import SchemaBranch
+
+KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED = [GENERICGROUP]
+
+
+def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch) -> list[str]:
+    """
+    Return kinds for which we want to lock during creating / updating an object of a given schema node.
+    Lock should be performed on schema kind and its generics having a uniqueness_constraint defined.
+    If a generic uniqueness constraint is the same as the node schema one,
+    it means node schema overrided this constraint, in which case we only need to lock on the generic.
+    """
+
+    node_schema = schema_branch.get(name=kind, duplicate=False)
+
+    schema_uc = None
+    kinds = []
+    if node_schema.uniqueness_constraints:
+        kinds.append(node_schema.kind)
+        schema_uc = node_schema.uniqueness_constraints
+
+    if isinstance(node_schema, GenericSchema):
+        return kinds
+
+    generics_kinds = node_schema.inherit_from
+
+    node_schema_kind_removed = False
+    for generic_kind in generics_kinds:
+        generic_uc = schema_branch.get(name=generic_kind, duplicate=False).uniqueness_constraints
+        if generic_uc:
+            kinds.append(generic_kind)
+            if not node_schema_kind_removed and generic_uc == schema_uc:
+                # Check whether we should remove original schema kind as it simply overrides uniqueness_constraint
+                # of a generic
+                kinds.pop(0)
+                node_schema_kind_removed = True
+    return kinds
+
+
+def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch) -> bool:
+    """
+    Check whether kind or any kind generic is in KINDS_TO_LOCK_ON_ANY_BRANCH.
+    """
+
+    if kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
+        return True
+
+    node_schema = schema_branch.get(name=kind, duplicate=False)
+    if isinstance(node_schema, GenericSchema):
+        return False
+
+    for generic_kind in node_schema.inherit_from:
+        if generic_kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
+            return True
+    return False
+
+
+def _hash(value: str) -> str:
+    # Do not use builtin `hash` for lock names as due to randomization results would differ between
+    # different processes.
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def get_kind_lock_names_on_object_mutation(
+    kind: str, branch: Branch, schema_branch: SchemaBranch, data: dict[str, Any]
+) -> list[str]:
+    """
+    Return objects kind for which we want to avoid concurrent mutation (create/update). Except for some specific kinds,
+    concurrent mutations are only allowed on non-main branch as objects validations will be performed at least when merging in main branch.
+    """
+
+    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind=kind, schema_branch=schema_branch):
+        return []
+
+    if kind == GRAPHQLQUERYGROUP:
+        # Lock on name as well to improve performances
+        try:
+            name = data["name"].value
+            return [build_object_lock_name(kind + "." + _hash(name))]
+        except KeyError:
+            # We might reach here if we are updating a CoreGraphQLQueryGroup without updating the name,
+            # in which case we would not need to lock. This is not supposed to happen as current `update`
+            # logic first fetches the node with its name.
+            return []
+
+    lock_kinds = _get_kinds_to_lock_on_object_mutation(kind, schema_branch)
+    lock_names = [build_object_lock_name(kind) for kind in lock_kinds]
+    return lock_names
+
+
+def build_object_lock_name(name: str) -> str:
+    return f"global.object.{name}"