infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/graphql/mutations/main.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Mapping, Optional, Union
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Mapping
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
@@ -9,27 +10,24 @@ from typing_extensions import Self
 
 from infrahub import config, lock
 from infrahub.core import registry
-from infrahub.core.changelog.models import RelationshipChangelogGetter
 from infrahub.core.constants import InfrahubKind, MutationAction, 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.schema import NodeSchema, RelationshipSchema
+from infrahub.core.schema import MainSchemaTypes, NodeSchema, RelationshipSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
 from infrahub.core.schema.template_schema import TemplateSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import retry_db_transaction
 from infrahub.dependencies.registry import get_component_registry
-from infrahub.events import EventMeta, NodeMutatedEvent
-from infrahub.exceptions import ValidationError
+from infrahub.events.generator import generate_node_mutation_events
+from infrahub.exceptions import HFIDViolatedError, InitializationError
+from infrahub.graphql.context import apply_external_context
 from infrahub.lock import InfrahubMultiLock, build_object_lock_name
 from infrahub.log import get_log_data, get_logger
-from infrahub.worker import WORKER_IDENTITY
 
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
-from .node_getter.by_hfid import MutationNodeGetterByHfid
-from .node_getter.by_id import MutationNodeGetterById
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -39,9 +37,9 @@ if TYPE_CHECKING:
     from infrahub.core.relationship.model import RelationshipManager
     from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
+    from infrahub.graphql.types.context import ContextInput
 
     from ..initialization import GraphqlContext
-    from .node_getter.interface import MutationNodeGetterInterface
 
 
 log = get_logger()
@@ -49,44 +47,74 @@ log = get_logger()
 KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED = [InfrahubKind.GENERICGROUP]
 
 
+@dataclass
+class DeleteResult:
+    node: Node
+    mutation: InfrahubMutationMixin
+    deleted_nodes: list[Node] = field(default_factory=list)
+
+
 # ------------------------------------------
 # Infrahub GraphQLType
 # ------------------------------------------
 class InfrahubMutationOptions(MutationOptions):
-    schema: Optional[NodeSchema] = None
+    schema: MainSchemaTypes | None = None
+
+    @property
+    def active_schema(self) -> MainSchemaTypes:
+        if self.schema:
+            return self.schema
+        raise InitializationError("This class is not initialized with a schema")
 
 
 class InfrahubMutationMixin:
+    _meta: InfrahubMutationOptions
+
     @classmethod
-    async def mutate(cls, root: dict, info: GraphQLResolveInfo, data: InputObjectType, *args: Any, **kwargs):  # noqa: ARG003
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        context: ContextInput | None = None,
+        **kwargs: dict[str, Any],
+    ) -> Self:
         graphql_context: GraphqlContext = info.context
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         obj = None
         mutation = None
         action = MutationAction.UNDEFINED
+        deleted_nodes: list[Node] = []
 
         if "Create" in cls.__name__:
-            obj, mutation = await cls.mutate_create(info=info, branch=graphql_context.branch, data=data, **kwargs)
+            obj, mutation = await cls.mutate_create(info=info, branch=graphql_context.branch, data=data)
             action = MutationAction.CREATED
         elif "Update" in cls.__name__:
             obj, mutation = await cls.mutate_update(info=info, branch=graphql_context.branch, data=data, **kwargs)
             action = MutationAction.UPDATED
         elif "Upsert" in cls.__name__:
             node_manager = NodeManager()
-            node_getters = [
-                MutationNodeGetterById(db=graphql_context.db, node_manager=node_manager),
-                MutationNodeGetterByHfid(db=graphql_context.db, node_manager=node_manager),
-                MutationNodeGetterByDefaultFilter(db=graphql_context.db, node_manager=node_manager),
-            ]
+            node_getter_default_filter = MutationNodeGetterByDefaultFilter(
+                db=graphql_context.db, node_manager=node_manager
+            )
             obj, mutation, created = await cls.mutate_upsert(
-                info=info, branch=graphql_context.branch, data=data, node_getters=node_getters, **kwargs
+                info=info,
+                branch=graphql_context.branch,
+                data=data,
+                node_getter_default_filter=node_getter_default_filter,
+                **kwargs,
             )
             if created:
                 action = MutationAction.CREATED
             else:
                 action = MutationAction.UPDATED
         elif "Delete" in cls.__name__:
-            obj, mutation = await cls.mutate_delete(info=info, branch=graphql_context.branch, data=data, **kwargs)
+            delete_result = await cls.mutate_delete(info=info, branch=graphql_context.branch, data=data, **kwargs)
+            obj = delete_result.node
+            mutation = delete_result.mutation
+            deleted_nodes = delete_result.deleted_nodes
+
             action = MutationAction.DELETED
         else:
             raise ValueError(
@@ -100,41 +128,15 @@ class InfrahubMutationMixin:
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")
 
-            account_id: str | None = None
-            if graphql_context.account_session:
-                account_id = graphql_context.account_session.account_id
-
-            meta = EventMeta(
-                account_id=account_id,
-                initiator_id=WORKER_IDENTITY,
-                request_id=request_id,
+            events = await generate_node_mutation_events(
+                node=obj,
+                deleted_nodes=deleted_nodes,
+                db=graphql_context.db,
                 branch=graphql_context.branch,
                 context=graphql_context.get_context(),
-            )
-            main_event = NodeMutatedEvent(
-                kind=obj._schema.kind,
-                node_id=obj.id,
-                data=obj.node_changelog,
+                request_id=request_id,
                 action=action,
-                fields=_get_data_fields(data),
-                meta=meta,
             )
-            relationship_changelogs = RelationshipChangelogGetter(db=graphql_context.db, branch=graphql_context.branch)
-            node_changelogs = await relationship_changelogs.get_changelogs(primary_changelog=obj.node_changelog)
-
-            events = [main_event]
-
-            for node_changelog in node_changelogs:
-                meta = EventMeta.from_parent(parent=main_event)
-                event = NodeMutatedEvent(
-                    kind=node_changelog.node_kind,
-                    node_id=node_changelog.node_id,
-                    data=node_changelog,
-                    action=MutationAction.UPDATED,
-                    fields=node_changelog.updated_fields,
-                    meta=meta,
-                )
-                events.append(event)
 
             for event in events:
                 graphql_context.background.add_task(graphql_context.active_service.event.send, event)
@@ -150,7 +152,7 @@ class InfrahubMutationMixin:
 
     @classmethod
     async def _refresh_for_profile_update(
-        cls, db: InfrahubDatabase, branch: Branch, obj: Node, previous_profile_ids: Optional[set[str]] = None
+        cls, db: InfrahubDatabase, branch: Branch, obj: Node, previous_profile_ids: set[str] | None = None
     ) -> Node:
         if not hasattr(obj, "profiles"):
             return obj
@@ -158,7 +160,7 @@ class InfrahubMutationMixin:
         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=cls._meta.schema.kind,
+                kind=cls._meta.active_schema.kind,
                 id=obj.get_id(),
                 branch=branch,
                 include_owner=True,
@@ -169,13 +171,13 @@ class InfrahubMutationMixin:
         return obj
 
     @classmethod
-    async def _call_mutate_create_object(cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch):
+    async def _call_mutate_create_object(cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch) -> Node:
         """
         Wrapper around mutate_create_object to potentially activate locking.
         """
         schema_branch = db.schema.get_schema_branch(name=branch.name)
         lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.schema.kind, branch=branch, schema_branch=schema_branch
+            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch
         )
         if lock_names:
             async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
@@ -203,7 +205,7 @@ class InfrahubMutationMixin:
         cls,
         db: InfrahubDatabase,
         template_peer: Node,
-        obj_peer_schema,
+        obj_peer_schema: MainSchemaTypes,
         parent_obj: Node,
         current_template: CoreObjectTemplate,
     ) -> Mapping[str, Any]:
@@ -212,7 +214,7 @@ class InfrahubMutationMixin:
         for attr in template_peer.get_schema().attribute_names:
             if attr not in obj_peer_schema.attribute_names:
                 continue
-            obj_peer_data[attr] = {"value": getattr(template_peer, attr).value}
+            obj_peer_data[attr] = {"value": getattr(template_peer, attr).value, "source": template_peer.id}
 
         for rel in template_peer.get_schema().relationship_names:
             rel_manager: RelationshipManager = getattr(template_peer, rel)
@@ -248,8 +250,13 @@ class InfrahubMutationMixin:
             if not template_relationship_peers:
                 continue
 
-            obj_peer_schema = relationship.get_peer_schema(db=db, branch=branch)
             for template_relationship_peer in template_relationship_peers.values():
+                # We retrieve peer schema for each peer in case we are processing a relationship which is based on a generic
+                obj_peer_schema = registry.schema.get_node_schema(
+                    name=template_relationship_peer.get_schema().kind.removeprefix("Template"),
+                    branch=branch,
+                    duplicate=False,
+                )
                 obj_peer_data = await cls._extract_peer_data(
                     db=db,
                     template_peer=template_relationship_peer,
@@ -258,7 +265,7 @@ class InfrahubMutationMixin:
                     current_template=template,
                 )
 
-                obj_peer = await Node.init(schema=obj_peer_schema, db=db)
+                obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch)
                 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)
@@ -278,7 +285,7 @@ class InfrahubMutationMixin:
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
+        database: InfrahubDatabase | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
         db = database or graphql_context.db
@@ -299,44 +306,41 @@ class InfrahubMutationMixin:
             NodeConstraintRunner, db=db.start_session(), branch=branch
         )
         node_class = Node
-        if cls._meta.schema.kind in registry.node:
-            node_class = registry.node[cls._meta.schema.kind]
+        if cls._meta.active_schema.kind in registry.node:
+            node_class = registry.node[cls._meta.active_schema.kind]
 
         fields_to_validate = list(data)
-        try:
-            if db.is_transaction:
-                obj = await node_class.init(db=db, schema=cls._meta.schema, branch=branch)
-                await obj.new(db=db, **data)
+        if db.is_transaction:
+            obj = await node_class.init(db=db, schema=cls._meta.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)
+
+            object_template = await obj.get_object_template(db=db)
+            if object_template:
+                await cls._handle_template_relationships(
+                    db=db,
+                    branch=branch,
+                    template=object_template,
+                    obj=obj,
+                    data=data,
+                )
+        else:
+            async with db.start_transaction() as dbt:
+                obj = await node_class.init(db=dbt, schema=cls._meta.schema, branch=branch)
+                await obj.new(db=dbt, **data)
                 await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-                await obj.save(db=db)
+                await obj.save(db=dbt)
 
-                object_template = await obj.get_object_template(db=db)
+                object_template = await obj.get_object_template(db=dbt)
                 if object_template:
                     await cls._handle_template_relationships(
-                        db=db,
+                        db=dbt,
                         branch=branch,
                         template=object_template,
                         obj=obj,
                         data=data,
                     )
-            else:
-                async with db.start_transaction() as dbt:
-                    obj = await node_class.init(db=dbt, schema=cls._meta.schema, branch=branch)
-                    await obj.new(db=dbt, **data)
-                    await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-                    await obj.save(db=dbt)
-
-                    object_template = await obj.get_object_template(db=dbt)
-                    if object_template:
-                        await cls._handle_template_relationships(
-                            db=dbt,
-                            branch=branch,
-                            template=object_template,
-                            obj=obj,
-                            data=data,
-                        )
-        except ValidationError as exc:
-            raise ValueError(str(exc)) from exc
 
         if await cls._get_profile_ids(db=db, obj=obj):
             obj = await cls._refresh_for_profile_update(db=db, branch=branch, obj=obj)
@@ -346,7 +350,7 @@ class InfrahubMutationMixin:
     @classmethod
     async def mutate_create_to_graphql(cls, info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> Self:
         fields = await extract_fields(info.field_nodes[0].selection_set)
-        result = {"ok": True}
+        result: dict[str, Any] = {"ok": True}
         if "object" in fields:
             result["object"] = await obj.to_graphql(db=db, fields=fields.get("object", {}))
         return cls(**result)
@@ -359,6 +363,7 @@ class InfrahubMutationMixin:
         branch: Branch,
         db: InfrahubDatabase,
         obj: Node,
+        run_constraint_checks: bool = True,
     ) -> tuple[Node, Self]:
         """
         Wrapper around mutate_update to potentially activate locking and call it within a database transaction.
@@ -366,24 +371,37 @@ class InfrahubMutationMixin:
 
         schema_branch = db.schema.get_schema_branch(name=branch.name)
         lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.schema.kind, branch=branch, schema_branch=schema_branch
+            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch
         )
 
         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)
+                    obj = await cls.mutate_update_object(
+                        db=db, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                    )
             else:
-                obj = await cls.mutate_update_object(db=db, info=info, data=data, branch=branch, obj=obj)
+                obj = await cls.mutate_update_object(
+                    db=db, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                )
             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)
+                    obj = await cls.mutate_update_object(
+                        db=dbt,
+                        info=info,
+                        data=data,
+                        branch=branch,
+                        obj=obj,
+                        run_constraint_checks=run_constraint_checks,
+                    )
             else:
-                obj = await cls.mutate_update_object(db=dbt, info=info, data=data, branch=branch, obj=obj)
+                obj = await cls.mutate_update_object(
+                    db=dbt, info=info, data=data, branch=branch, obj=obj, run_constraint_checks=run_constraint_checks
+                )
             result = await cls.mutate_update_to_graphql(db=dbt, info=info, obj=obj)
             return obj, result
 
@@ -394,20 +412,17 @@ class InfrahubMutationMixin:
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
-        node: Optional[Node] = None,
+        database: InfrahubDatabase | None = None,
+        node: Node | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
         db = database or graphql_context.db
 
         obj = node or await NodeManager.find_object(
-            db=db, kind=cls._meta.schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
+            db=db, kind=cls._meta.active_schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
         )
 
-        try:
-            obj, result = await cls._call_mutate_update(info=info, data=data, db=db, branch=branch, obj=obj)
-        except ValidationError as exc:
-            raise ValueError(str(exc)) from exc
+        obj, result = await cls._call_mutate_update(info=info, data=data, db=db, branch=branch, obj=obj)
 
         return obj, result
 
@@ -419,6 +434,7 @@ class InfrahubMutationMixin:
         data: InputObjectType,
         branch: Branch,
         obj: Node,
+        run_constraint_checks: bool = True,
     ) -> Node:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
@@ -426,12 +442,13 @@ class InfrahubMutationMixin:
         before_mutate_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
         await obj.from_graphql(db=db, data=data)
         fields_to_validate = list(data)
-        await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
+        if run_constraint_checks:
+            await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
 
         fields = list(data.keys())
-        for field in ("id", "hfid"):
-            if field in fields:
-                fields.remove(field)
+        for field_to_remove in ("id", "hfid"):
+            if field_to_remove in fields:
+                fields.remove(field_to_remove)
 
         await obj.save(db=db, fields=fields)
 
@@ -449,7 +466,7 @@ class InfrahubMutationMixin:
     ) -> Self:
         fields_object = await extract_fields(info.field_nodes[0].selection_set)
         fields_object = fields_object.get("object", {})
-        result = {"ok": True}
+        result: dict[str, Any] = {"ok": True}
         if fields_object:
             result["object"] = await obj.to_graphql(db=db, fields=fields_object)
         return cls(**result)
@@ -461,31 +478,76 @@ class InfrahubMutationMixin:
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        node_getters: list[MutationNodeGetterInterface],
-        database: Optional[InfrahubDatabase] = None,
+        node_getter_default_filter: MutationNodeGetterByDefaultFilter,
+        database: InfrahubDatabase | None = None,
     ) -> tuple[Node, Self, bool]:
-        schema_name = cls._meta.schema.kind
+        """
+        First, check whether payload contains data identifying the node, such as id, hfid, or relevant fields for
+        default_filter. If not, we will try to create the node, but this creation might fail if payload contains
+        hfid fields (not `hfid` field itself) that would match an existing node in the database. In that case,
+        we would update the node without rerunning uniqueness constraint.
+        """
+
+        schema_name = cls._meta.active_schema.kind
 
         graphql_context: GraphqlContext = info.context
         db = database or graphql_context.db
-
-        node_schema = db.schema.get(name=schema_name, branch=branch)
-
+        dict_data = dict(data)
         node = None
-        for getter in node_getters:
-            node = await getter.get_node(node_schema=node_schema, data=data, branch=branch)
-            if node:
-                break
+        run_constraint_checks = True
 
-        if node:
-            updated_obj, mutation = await cls.mutate_update(info=info, data=data, branch=branch, database=db, node=node)
+        if "id" in dict_data:
+            node = await NodeManager.get_one(
+                db=db, id=dict_data["id"], kind=schema_name, branch=branch, raise_on_error=True
+            )
+            updated_obj, mutation = await cls._call_mutate_update(
+                info=info,
+                data=data,
+                db=db,
+                branch=branch,
+                obj=node,
+                run_constraint_checks=run_constraint_checks,
+            )
             return updated_obj, mutation, False
-        # We need to convert the InputObjectType into a dict in order to remove hfid that isn't a valid input when creating the object
-        data_dict = dict(data)
+
+        if cls._meta.active_schema.default_filter is not None:
+            node = await node_getter_default_filter.get_node(
+                node_schema=cls._meta.active_schema, data=data, branch=branch
+            )
+
         if "hfid" in data:
-            del data_dict["hfid"]
-        created_obj, mutation = await cls.mutate_create(info=info, data=data_dict, branch=branch)
-        return created_obj, mutation, True
+            node = await NodeManager.get_one_by_hfid(db=db, hfid=dict_data["hfid"], kind=schema_name, branch=branch)
+
+        if node is not None:
+            updated_obj, mutation = await cls._call_mutate_update(
+                info=info,
+                data=data,
+                db=db,
+                branch=branch,
+                obj=node,
+                run_constraint_checks=run_constraint_checks,
+            )
+            return updated_obj, mutation, False
+
+        try:
+            dict_data.pop("hfid", "unused")  # `hfid` is invalid for creation.
+            created_obj, mutation = await cls.mutate_create(info=info, data=dict_data, branch=branch)
+            return created_obj, mutation, True
+        except HFIDViolatedError as exc:
+            # Only the HFID constraint has been violated, it means the node exists and we can update without rerunning constraints
+            if len(exc.matching_nodes_ids) > 1:
+                raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid (database corrupted)") from exc
+            node_id = list(exc.matching_nodes_ids)[0]
+            node = await NodeManager.get_one(db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True)
+            updated_obj, mutation = await cls._call_mutate_update(
+                info=info,
+                data=data,
+                db=db,
+                branch=branch,
+                obj=node,
+                run_constraint_checks=run_constraint_checks,
+            )
+            return updated_obj, mutation, False
 
     @classmethod
     @retry_db_transaction(name="object_delete")
@@ -494,34 +556,35 @@ class InfrahubMutationMixin:
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-    ) -> tuple[Node, Self]:
+    ) -> DeleteResult:
         graphql_context: GraphqlContext = info.context
 
         obj = await NodeManager.find_object(
-            db=graphql_context.db, kind=cls._meta.schema.kind, id=data.get("id"), hfid=data.get("hfid"), branch=branch
+            db=graphql_context.db,
+            kind=cls._meta.active_schema.kind,
+            id=data.get("id"),
+            hfid=data.get("hfid"),
+            branch=branch,
         )
 
-        try:
-            async with graphql_context.db.start_transaction() as db:
-                deleted = await NodeManager.delete(db=db, branch=branch, nodes=[obj])
-        except ValidationError as exc:
-            raise ValueError(str(exc)) from exc
+        async with graphql_context.db.start_transaction() as db:
+            deleted = await NodeManager.delete(db=db, branch=branch, nodes=[obj])
 
         deleted_str = ", ".join([f"{d.get_kind()}({d.get_id()})" for d in deleted])
         log.info(f"nodes deleted: {deleted_str}")
 
         ok = True
 
-        return obj, cls(ok=ok)
+        return DeleteResult(node=obj, mutation=cls(ok=ok), deleted_nodes=deleted)
 
 
 class InfrahubMutation(InfrahubMutationMixin, Mutation):
     @classmethod
     def __init_subclass_with_meta__(
         cls,
-        schema: Optional[Union[NodeSchema, GenericSchema, ProfileSchema, TemplateSchema]] = None,
-        _meta=None,
-        **options,
+        schema: NodeSchema | GenericSchema | ProfileSchema | TemplateSchema | None = None,
+        _meta: InfrahubMutationOptions | None = None,
+        **options: dict[str, Any],
     ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
         if not isinstance(schema, NodeSchema | GenericSchema | ProfileSchema | TemplateSchema):

infrahub/graphql/mutations/menu.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from graphene import InputObjectType, Mutation
 from graphql import GraphQLResolveInfo
@@ -14,7 +14,7 @@ from infrahub.database import InfrahubDatabase
 from infrahub.exceptions import ValidationError
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 
-from .main import InfrahubMutationOptions
+from .main import DeleteResult, InfrahubMutationOptions
 
 if TYPE_CHECKING:
     from infrahub.graphql.initialization import GraphqlContext
@@ -35,7 +35,7 @@ def validate_namespace(data: InputObjectType) -> None:
 class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
     @classmethod
     def __init_subclass_with_meta__(
-        cls, schema: NodeSchema, _meta: Optional[Any] = None, **options: dict[str, Any]
+        cls, schema: NodeSchema, _meta: Any | None = None, **options: dict[str, Any]
     ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
         if not isinstance(schema, NodeSchema):
@@ -53,7 +53,7 @@ class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> tuple[Node, Self]:
         validate_namespace(data=data)
 
@@ -67,8 +67,8 @@ class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
-        node: Optional[Node] = None,  # noqa: ARG003
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
+        node: Node | None = None,  # noqa: ARG003
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
 
@@ -89,7 +89,7 @@ class InfrahubCoreMenuMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-    ) -> tuple[Node, Self]:
+    ) -> DeleteResult:
         graphql_context: GraphqlContext = info.context
         obj = await NodeManager.find_object(
             db=graphql_context.db, kind=CoreMenuItem, id=data.get("id"), hfid=data.get("hfid"), branch=branch

infrahub/graphql/mutations/models.py

@@ -1,13 +1,11 @@
-from typing import Optional
-
 from pydantic import BaseModel
 
 
 class BranchCreateModel(BaseModel):
     name: str
-    id: Optional[str] = None
+    id: str | None = None
     description: str = ""
     origin_branch: str = "main"
-    branched_from: Optional[str] = None
+    branched_from: str | None = None
     sync_with_git: bool = True
     is_isolated: bool = True