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

infrahub/lock.py

@@ -5,7 +5,7 @@ import time
 import uuid
 from asyncio import Lock as LocalLock
 from asyncio import sleep
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
 from prometheus_client import Histogram
@@ -47,7 +47,7 @@ GLOBAL_GRAPH_LOCK = "global.graph"
 class InfrahubMultiLock:
     """Context manager to allow multiple locks to be reserved together"""
 
-    def __init__(self, lock_registry: InfrahubLockRegistry, locks: Optional[list[str]] = None) -> None:
+    def __init__(self, lock_registry: InfrahubLockRegistry, locks: list[str] | None = None) -> None:
         self.registry = lock_registry
         self.locks = locks or []
 
@@ -56,9 +56,9 @@ class InfrahubMultiLock:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ):
         await self.release()
 
@@ -84,9 +84,9 @@ class NATSLock:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ):
         await self.release()
 
@@ -117,18 +117,18 @@ class InfrahubLock:
     def __init__(
         self,
         name: str,
-        connection: Optional[Union[redis.Redis, InfrahubServices]] = None,
-        local: Optional[bool] = None,
+        connection: redis.Redis | InfrahubServices | None = None,
+        local: bool | None = None,
         in_multi: bool = False,
     ) -> None:
         self.use_local: bool = local
         self.local: LocalLock = None
         self.remote: GlobalLock = None
         self.name: str = name
-        self.connection: Optional[redis.Redis] = connection
+        self.connection: redis.Redis | None = connection
         self.in_multi: bool = in_multi
         self.lock_type: str = "multi" if self.in_multi else "individual"
-        self.acquire_time: Optional[int] = None
+        self.acquire_time: int | None = None
         self.event = asyncio.Event()
 
         if not self.connection or (self.use_local is None and name.startswith("local.")):
@@ -146,9 +146,9 @@ class InfrahubLock:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ):
         await self.release()
 
@@ -179,7 +179,7 @@ class InfrahubLock:
 
 class InfrahubLockRegistry:
     def __init__(
-        self, token: Optional[str] = None, local_only: bool = False, service: Optional[InfrahubServices] = None
+        self, token: str | None = None, local_only: bool = False, service: InfrahubServices | None = None
     ) -> None:
         if config.SETTINGS.cache.enable and not local_only:
             if config.SETTINGS.cache.driver == config.CacheDriver.Redis:
@@ -201,7 +201,7 @@ class InfrahubLockRegistry:
         self.locks: dict[str, InfrahubLock] = {}
 
     @classmethod
-    def _generate_name(cls, name: str, namespace: Optional[str] = None, local: Optional[bool] = None) -> str:
+    def _generate_name(cls, name: str, namespace: str | None = None, local: bool | None = None) -> str:
         if namespace is None and local is None:
             return name
 
@@ -221,7 +221,7 @@ class InfrahubLockRegistry:
         self,
         name: str,
         namespace: str | None,
-        local: Optional[bool] = None,
+        local: bool | None = None,
     ) -> InfrahubLock | None:
         lock_name = self._generate_name(name=name, namespace=namespace, local=local)
         if lock_name not in self.locks:
@@ -229,7 +229,7 @@ class InfrahubLockRegistry:
         return self.locks[lock_name]
 
     def get(
-        self, name: str, namespace: Optional[str] = None, local: Optional[bool] = None, in_multi: bool = False
+        self, name: str, namespace: str | None = None, local: bool | None = None, in_multi: bool = False
     ) -> InfrahubLock:
         lock_name = self._generate_name(name=name, namespace=namespace, local=local)
         if lock_name not in self.locks:
@@ -252,7 +252,7 @@ class InfrahubLockRegistry:
         return InfrahubMultiLock(lock_registry=self, locks=[LOCAL_SCHEMA_LOCK, GLOBAL_GRAPH_LOCK, GLOBAL_SCHEMA_LOCK])
 
 
-def initialize_lock(local_only: bool = False, service: Optional[InfrahubServices] = None) -> None:
+def initialize_lock(local_only: bool = False, service: InfrahubServices | None = None) -> None:
     global registry
     registry = InfrahubLockRegistry(local_only=local_only, service=service)
 

infrahub/menu/constants.py

@@ -8,4 +8,3 @@ class MenuSection(InfrahubStringEnum):
 
 DEFAULT_MENU = "Other"
 FULL_DEFAULT_MENU = "BuiltinOther"
-TEMPLATE_MENU = "Object templates"

infrahub/menu/generator.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind
 from infrahub.core.protocols import CoreMenuItem
 from infrahub.log import get_logger
 
-from .constants import FULL_DEFAULT_MENU, TEMPLATE_MENU
+from .constants import FULL_DEFAULT_MENU
 from .models import MenuDict, MenuItemDict
 
 if TYPE_CHECKING:
@@ -71,7 +70,7 @@ async def generate_menu(db: InfrahubDatabase, branch: Branch, menu_items: list[C
         menu_item = structure.find_item(name=parent_full_name)
         if menu_item:
             child_item = MenuItemDict.from_node(obj=item)
-            menu_item.children[child_item.identifier] = child_item
+            menu_item.children[str(child_item.identifier)] = child_item
         else:
             log.warning(
                 "new_menu_request: unable to find the parent menu item",
@@ -82,11 +81,6 @@ async def generate_menu(db: InfrahubDatabase, branch: Branch, menu_items: list[C
 
     items_to_add = {schema.kind: False for schema in full_schema.values() if schema.include_in_menu is True}
 
-    # Object templates should go into a dedicated menu item
-    object_templates_menu = MenuItemDict(
-        identifier=InfrahubKind.OBJECTTEMPLATE, label=TEMPLATE_MENU.title(), icon="mdi:pencil-ruler", order_weight=20000
-    )
-
     nbr_remaining_items_last_round = len(items_to_add.values())
     nbr_remaining_items = len([value for value in items_to_add.values() if value is False])
     while not all(items_to_add.values()):
@@ -96,23 +90,20 @@ async def generate_menu(db: InfrahubDatabase, branch: Branch, menu_items: list[C
 
             schema = full_schema[item_name]
             menu_item = MenuItemDict.from_schema(model=schema)
-            already_in_schema = bool(structure.find_item(name=menu_item.identifier))
+            already_in_schema = bool(structure.find_item(name=str(menu_item.identifier)))
             if already_in_schema:
                 items_to_add[item_name] = True
                 continue
 
-            if schema.namespace == "Template":
-                object_templates_menu.children[menu_item.identifier] = menu_item
-                items_to_add[item_name] = True
-            elif not schema.menu_placement:
+            if not schema.menu_placement:
                 first_element = MenuItemDict.from_schema(model=schema)
-                first_element.identifier = f"{first_element.identifier}Sub"
+                first_element.name = f"{first_element.name}Sub"
                 first_element.order_weight = 1
-                menu_item.children[first_element.identifier] = first_element
-                structure.data[menu_item.identifier] = menu_item
+                menu_item.children[str(first_element.identifier)] = first_element
+                structure.data[str(menu_item.identifier)] = menu_item
                 items_to_add[item_name] = True
             elif menu_placement := structure.find_item(name=schema.menu_placement):
-                menu_placement.children[menu_item.identifier] = menu_item
+                menu_placement.children[str(menu_item.identifier)] = menu_item
                 items_to_add[item_name] = True
                 continue
 
@@ -121,9 +112,6 @@ async def generate_menu(db: InfrahubDatabase, branch: Branch, menu_items: list[C
             break
         nbr_remaining_items_last_round = nbr_remaining_items
 
-    if object_templates_menu.children:
-        structure.data[object_templates_menu.identifier] = object_templates_menu
-
     # ----------------------------------------------------------------------------
     # Assign the remaining items for which we couldn't find the menu_placement to the default menu
     # ----------------------------------------------------------------------------
@@ -142,7 +130,7 @@ async def generate_menu(db: InfrahubDatabase, branch: Branch, menu_items: list[C
             item=schema.kind,
             menu_placement=schema.menu_placement,
         )
-        default_menu.children[menu_item.identifier] = menu_item
+        default_menu.children[str(menu_item.identifier)] = menu_item
         items_to_add[item_name] = True
 
     return structure

infrahub/menu/menu.py

@@ -135,6 +135,16 @@ default_menu = [
                 section=MenuSection.INTERNAL,
                 order_weight=1500,
             ),
+            MenuItemDefinition(
+                namespace="Builtin",
+                name="Templates",
+                label="Templates",
+                kind=InfrahubKind.OBJECTTEMPLATE,
+                icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.OBJECTTEMPLATE)),
+                protected=True,
+                section=MenuSection.INTERNAL,
+                order_weight=2000,
+            ),
             MenuItemDefinition(
                 namespace="Builtin",
                 name="ResourceManager",
@@ -143,7 +153,7 @@ default_menu = [
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.RESOURCEPOOL)),
                 protected=True,
                 section=MenuSection.INTERNAL,
-                order_weight=2000,
+                order_weight=2500,
             ),
             MenuItemDefinition(
                 namespace="Builtin",
@@ -153,7 +163,7 @@ default_menu = [
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.ARTIFACT)),
                 protected=True,
                 section=MenuSection.INTERNAL,
-                order_weight=2500,
+                order_weight=3000,
             ),
             MenuItemDefinition(
                 namespace="Builtin",
@@ -175,16 +185,6 @@ default_menu = [
                 section=MenuSection.INTERNAL,
                 order_weight=3500,
             ),
-            MenuItemDefinition(
-                namespace="Builtin",
-                name="ActivityLogs",
-                label="Activity Logs",
-                path="/activities",
-                icon="mdi:format-list-bulleted",
-                protected=True,
-                section=MenuSection.INTERNAL,
-                order_weight=4000,
-            ),
         ],
     ),
     MenuItemDefinition(
@@ -261,32 +261,11 @@ default_menu = [
                 namespace="Builtin",
                 name="Webhooks",
                 label="Webhooks",
-                icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.CUSTOMWEBHOOK)),
+                icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.WEBHOOK)),
+                kind=InfrahubKind.WEBHOOK,
                 protected=True,
                 section=MenuSection.INTERNAL,
                 order_weight=3000,
-                children=[
-                    MenuItemDefinition(
-                        namespace="Builtin",
-                        name="WebhookStandard",
-                        label="Webhooks",
-                        kind=InfrahubKind.STANDARDWEBHOOK,
-                        icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.STANDARDWEBHOOK)),
-                        protected=True,
-                        section=MenuSection.INTERNAL,
-                        order_weight=1000,
-                    ),
-                    MenuItemDefinition(
-                        namespace="Builtin",
-                        name="WebhookCustom",
-                        label="Custom Webhooks",
-                        kind=InfrahubKind.CUSTOMWEBHOOK,
-                        icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.CUSTOMWEBHOOK)),
-                        protected=True,
-                        section=MenuSection.INTERNAL,
-                        order_weight=2000,
-                    ),
-                ],
             ),
             MenuItemDefinition(
                 namespace="Builtin",
@@ -331,9 +310,9 @@ default_menu = [
             ),
             MenuItemDefinition(
                 namespace="Builtin",
-                name="ActivityLog",
-                label="Activity Log",
-                path="/activity-log",
+                name="Activities",
+                label="Activities",
+                path="/activities",
                 icon="mdi:timeline-text",
                 protected=True,
                 section=MenuSection.INTERNAL,

infrahub/menu/models.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, computed_field
 from typing_extensions import Self
 
 from infrahub.core.account import GlobalPermission
@@ -35,21 +35,26 @@ def _get_full_name_schema(node: MainSchemaTypes) -> str:
 class MenuDict:
     data: dict[str, MenuItemDict] = field(default_factory=dict)
 
+    def get_item_location(self, name: str) -> list[str]:
+        location, _ = self._find_child_item(name=name, children=self.data)
+        return location
+
     def find_item(self, name: str) -> MenuItemDict | None:
-        return self._find_child_item(name=name, children=self.data)
+        _, item = self._find_child_item(name=name, children=self.data)
+        return item
 
     @classmethod
-    def _find_child_item(cls, name: str, children: dict[str, MenuItemDict]) -> MenuItemDict | None:
+    def _find_child_item(cls, name: str, children: dict[str, MenuItemDict]) -> tuple[list[str], MenuItemDict | None]:
         if name in children.keys():
-            return children[name]
+            return [], children[name]
 
         for child in children.values():
             if not child.children:
                 continue
-            found = cls._find_child_item(name=name, children=child.children)
+            position, found = cls._find_child_item(name=name, children=child.children)
             if found:
-                return found
-        return None
+                return [str(child.identifier)] + position, found
+        return [], None
 
     def to_rest(self) -> Menu:
         data: dict[str, list[MenuItemList]] = {}
@@ -62,10 +67,15 @@ class MenuDict:
 
         return Menu(sections=data)
 
-    # @staticmethod
-    # def _sort_menu_items(items: dict[str, MenuItem]) -> dict[str, MenuItem]:
-    #     sorted_dict = dict(sorted(items.items(), key=lambda x: (x[1].order_weight, x[0]), reverse=False))
-    #     return sorted_dict
+    @classmethod
+    def from_definition_list(cls, definitions: list[MenuItemDefinition]) -> Self:
+        menu = cls()
+        for definition in definitions:
+            menu.data[definition.full_name] = MenuItemDict.from_definition(definition=definition)
+        return menu
+
+    def get_all_identifiers(self) -> set[str]:
+        return {identifier for item in self.data.values() for identifier in item.get_all_identifiers()}
 
 
 @dataclass
@@ -74,7 +84,11 @@ class Menu:
 
 
 class MenuItem(BaseModel):
-    identifier: str = Field(..., description="Unique identifier for this menu item")
+    id: str | None = None
+    namespace: str = Field(..., description="Namespace of the menu item")
+    name: str = Field(..., description="Name of the menu item")
+    description: str = Field(default="", description="Description of the menu item")
+    protected: bool = Field(default=False, description="Whether the menu item is protected")
     label: str = Field(..., description="Title of the menu item")
     path: str = Field(default="", description="URL endpoint if applicable")
     icon: str = Field(default="", description="The icon to show for the current view")
@@ -83,10 +97,27 @@ class MenuItem(BaseModel):
     section: MenuSection = MenuSection.OBJECT
     permissions: list[str] = Field(default_factory=list)
 
+    @computed_field
+    def identifier(self) -> str:
+        return f"{self.namespace}{self.name}"
+
+    def get_path(self) -> str | None:
+        if self.path:
+            return self.path
+
+        if self.kind:
+            return f"/objects/{self.kind}"
+
+        return None
+
     @classmethod
     def from_node(cls, obj: CoreMenuItem) -> Self:
         return cls(
-            identifier=get_full_name(obj),
+            id=obj.get_id(),
+            name=obj.name.value,
+            namespace=obj.namespace.value,
+            protected=obj.protected.value,
+            description=obj.description.value or "",
             label=obj.label.value or "",
             icon=obj.icon.value or "",
             order_weight=obj.order_weight.value,
@@ -96,10 +127,30 @@ class MenuItem(BaseModel):
             permissions=obj.required_permissions.value or [],
         )
 
+    async def to_node(self, db: InfrahubDatabase, parent: CoreMenuItem | None = None) -> CoreMenuItem:
+        obj = await Node.init(db=db, schema=CoreMenuItem)
+        await obj.new(
+            db=db,
+            namespace=self.namespace,
+            name=self.name,
+            label=self.label,
+            kind=self.kind,
+            path=self.get_path(),
+            description=self.description or None,
+            icon=self.icon or None,
+            protected=self.protected,
+            section=self.section.value,
+            order_weight=self.order_weight,
+            parent=parent.id if parent else None,
+            required_permissions=self.permissions,
+        )
+        return obj
+
     @classmethod
     def from_schema(cls, model: NodeSchema | GenericSchema | ProfileSchema | TemplateSchema) -> Self:
         return cls(
-            identifier=get_full_name(model),
+            name=model.name,
+            namespace=model.namespace,
             label=model.label or model.kind,
             path=f"/objects/{model.kind}",
             icon=model.icon or "",
@@ -111,8 +162,14 @@ class MenuItemDict(MenuItem):
     hidden: bool = False
     children: dict[str, MenuItemDict] = Field(default_factory=dict, description="Child objects")
 
+    def get_all_identifiers(self) -> set[str]:
+        identifiers: set[str] = {str(self.identifier)}
+        for child in self.children.values():
+            identifiers.update(child.get_all_identifiers())
+        return identifiers
+
     def to_list(self) -> MenuItemList:
-        data = self.model_dump(exclude={"children"})
+        data = self.model_dump(exclude={"children", "id"})
         unsorted_children = [child.to_list() for child in self.children.values() if child.hidden is False]
         data["children"] = sorted(unsorted_children, key=lambda d: d.order_weight)
         return MenuItemList(**data)
@@ -125,6 +182,35 @@ class MenuItemDict(MenuItem):
             permissions.append(GlobalPermission.from_string(input=permission))
         return permissions
 
+    def diff_attributes(self, other: Self) -> dict[str, Any]:
+        other_attributes = other.model_dump(exclude={"children"})
+        self_attributes = self.model_dump(exclude={"children"})
+        return {
+            key: value
+            for key, value in other_attributes.items()
+            if value != self_attributes[key] and key not in ["id", "children"]
+        }
+
+    @classmethod
+    def from_definition(cls, definition: MenuItemDefinition) -> Self:
+        menu_item = cls(
+            name=definition.name,
+            namespace=definition.namespace,
+            label=definition.label,
+            path=definition.get_path() or "",
+            icon=definition.icon,
+            kind=definition.kind,
+            protected=definition.protected,
+            section=definition.section,
+            permissions=definition.permissions,
+            order_weight=definition.order_weight,
+        )
+
+        for child in definition.children:
+            menu_item.children[child.full_name] = MenuItemDict.from_definition(definition=child)
+
+        return menu_item
+
 
 class MenuItemList(MenuItem):
     children: list[MenuItemList] = Field(default_factory=list, description="Child objects")
@@ -162,6 +248,21 @@ class MenuItemDefinition(BaseModel):
         )
         return obj
 
+    @classmethod
+    async def from_node(cls, node: CoreMenuItem) -> Self:
+        return cls(
+            namespace=node.namespace.value,
+            name=node.name.value,
+            label=node.label.value or "",
+            description=node.description.value or "",
+            icon=node.icon.value or "",
+            protected=node.protected.value,
+            path=node.path.value or "",
+            kind=node.kind.value or "",
+            section=node.section.value,
+            order_weight=node.order_weight.value,
+        )
+
     def get_path(self) -> str | None:
         if self.path:
             return self.path

infrahub/menu/repository.py

@@ -0,0 +1,111 @@
+from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreMenuItem
+from infrahub.database import InfrahubDatabase
+
+from .models import MenuDict, MenuItemDefinition, MenuItemDict
+
+
+class MenuRepository:
+    def __init__(self, db: InfrahubDatabase):
+        self.db = db
+
+    async def get_menu(self, nodes: dict[str, CoreMenuItem] | None = None) -> MenuDict:
+        menu_nodes = nodes or await self.get_menu_db()
+        return await self._convert_menu_from_db(nodes=menu_nodes)
+
+    async def _convert_menu_from_db(self, nodes: dict[str, CoreMenuItem]) -> MenuDict:
+        menu = MenuDict()
+        menu_by_ids = {menu_node.get_id(): MenuItemDict.from_node(menu_node) for menu_node in nodes.values()}
+
+        async def add_children(menu_item: MenuItemDict, menu_node: CoreMenuItem) -> MenuItemDict:
+            children = await menu_node.children.get_peers(db=self.db, peer_type=CoreMenuItem)
+            for child_id, child_node in children.items():
+                child_menu_item = menu_by_ids[child_id]
+                child = await add_children(child_menu_item, child_node)
+                menu_item.children[str(child.identifier)] = child
+            return menu_item
+
+        for menu_node in nodes.values():
+            menu_item = menu_by_ids[menu_node.get_id()]
+            parent = await menu_node.parent.get_peer(db=self.db, peer_type=CoreMenuItem)
+            if parent:
+                continue
+
+            children = await menu_node.children.get_peers(db=self.db, peer_type=CoreMenuItem)
+            for child_id, child_node in children.items():
+                child_menu_item = menu_by_ids[child_id]
+                child = await add_children(child_menu_item, child_node)
+                menu_item.children[str(child.identifier)] = child
+
+            menu.data[str(menu_item.identifier)] = menu_item
+
+        return menu
+
+    async def get_menu_db(self) -> dict[str, CoreMenuItem]:
+        menu_nodes = await NodeManager.query(
+            schema=CoreMenuItem,
+            filters={"namespace__value": "Builtin"},
+            prefetch_relationships=True,
+            db=self.db,
+        )
+        return {node.get_id(): node for node in menu_nodes}
+
+    async def create_menu(self, menu: list[MenuItemDefinition]) -> None:
+        for item in menu:
+            obj = await item.to_node(db=self.db)
+            await obj.save(db=self.db)
+            if item.children:
+                await self.create_menu_children(parent=obj, children=item.children)
+
+    async def create_menu_children(self, parent: CoreMenuItem, children: list[MenuItemDefinition]) -> None:
+        for child in children:
+            obj = await child.to_node(db=self.db, parent=parent)
+            await obj.save(db=self.db)
+            if child.children:
+                await self.create_menu_children(parent=obj, children=child.children)
+
+    async def update_menu(
+        self, existing_menu: MenuDict, new_menu: MenuDict, menu_nodes: dict[str, CoreMenuItem]
+    ) -> None:
+        async def process_menu_item(menu_item: MenuItemDict, parent: CoreMenuItem | None) -> None:
+            existing_item = existing_menu.find_item(name=str(menu_item.identifier))
+            if existing_item and existing_item.id:
+                node = menu_nodes[existing_item.id]
+                await self.update_menu_item(
+                    node=node, existing_menu_item=existing_item, new_menu_item=menu_item, parent=parent
+                )
+            else:
+                node = await self.create_menu_item(new_menu_item=menu_item, parent=parent)
+
+            for child_item in menu_item.children.values():
+                await process_menu_item(menu_item=child_item, parent=node)
+
+        for top_level_item in new_menu.data.values():
+            await process_menu_item(menu_item=top_level_item, parent=None)
+
+        # Delete items that are not in the new menu
+        menu_to_delete = existing_menu.get_all_identifiers() - new_menu.get_all_identifiers()
+        for item_to_delete in menu_to_delete:
+            existing_item = existing_menu.find_item(name=item_to_delete)
+            if existing_item and existing_item.id:
+                node = menu_nodes[existing_item.id]
+                await node.delete(db=self.db)
+
+    async def update_menu_item(
+        self,
+        node: CoreMenuItem,
+        existing_menu_item: MenuItemDict,
+        new_menu_item: MenuItemDict,
+        parent: CoreMenuItem | None,
+    ) -> None:
+        attrs_to_update = existing_menu_item.diff_attributes(new_menu_item)
+        for attr_name, value in attrs_to_update.items():
+            attr = getattr(node, attr_name)
+            attr.value = value
+        await node.parent.update(data=parent, db=self.db)  # type: ignore[arg-type]
+        await node.save(db=self.db)
+
+    async def create_menu_item(self, new_menu_item: MenuItemDict, parent: CoreMenuItem | None) -> CoreMenuItem:
+        obj = await new_menu_item.to_node(db=self.db, parent=parent)
+        await obj.save(db=self.db)
+        return obj

infrahub/menu/utils.py

@@ -1,12 +1,9 @@
-from infrahub.core.protocols import CoreMenuItem
 from infrahub.database import InfrahubDatabase
 
-from .models import MenuItemDefinition
+from .menu import default_menu
+from .repository import MenuRepository
 
 
-async def create_menu_children(db: InfrahubDatabase, parent: CoreMenuItem, children: list[MenuItemDefinition]) -> None:
-    for child in children:
-        obj = await child.to_node(db=db, parent=parent)
-        await obj.save(db=db)
-        if child.children:
-            await create_menu_children(db=db, parent=obj, children=child.children)
+async def create_default_menu(db: InfrahubDatabase) -> None:
+    repository = MenuRepository(db=db)
+    await repository.create_menu(menu=default_menu)