infrahub-server 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/graphql/mutations/main.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Mapping
+from typing import TYPE_CHECKING, Any
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
@@ -9,12 +9,15 @@ from infrahub_sdk.utils import extract_fields
 from typing_extensions import Self
 
 from infrahub import config, lock
-from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind, MutationAction, RelationshipCardinality, RelationshipKind
+from infrahub.core.constants import InfrahubKind, MutationAction
 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 MainSchemaTypes, NodeSchema, RelationshipSchema
+from infrahub.core.node.create import (
+    create_node,
+    get_profile_ids,
+    refresh_for_profile_update,
+)
+from infrahub.core.schema import MainSchemaTypes, NodeSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
 from infrahub.core.schema.template_schema import TemplateSchema
@@ -33,8 +36,7 @@ if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
     from infrahub.core.branch import Branch
-    from infrahub.core.protocols import CoreObjectTemplate
-    from infrahub.core.relationship.model import RelationshipManager
+    from infrahub.core.node import Node
     from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.types.context import ContextInput
@@ -143,33 +145,6 @@ class InfrahubMutationMixin:
 
         return mutation
 
-    @classmethod
-    async def _get_profile_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
-        if not hasattr(obj, "profiles"):
-            return set()
-        profile_rels = await obj.profiles.get_relationships(db=db)
-        return {pr.peer_id for pr in profile_rels}
-
-    @classmethod
-    async def _refresh_for_profile_update(
-        cls, db: InfrahubDatabase, branch: Branch, obj: Node, previous_profile_ids: set[str] | None = None
-    ) -> Node:
-        if not hasattr(obj, "profiles"):
-            return obj
-        current_profile_ids = await cls._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=cls._meta.active_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
-
     @classmethod
     async def _call_mutate_create_object(cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch) -> Node:
         """
@@ -185,100 +160,6 @@ class InfrahubMutationMixin:
 
         return await cls.mutate_create_object(data=data, db=db, branch=branch)
 
-    @classmethod
-    async def _get_template_relationship_peers(
-        cls, db: InfrahubDatabase, template: CoreObjectTemplate, relationship: RelationshipSchema
-    ) -> Mapping[str, Node]:
-        """For a given relationship on the template, fetch the related peers."""
-        template_relationship_manager: RelationshipManager = getattr(template, relationship.name)
-        if relationship.cardinality == RelationshipCardinality.MANY:
-            return await template_relationship_manager.get_peers(db=db)
-
-        peers: dict[str, Node] = {}
-        template_relationship_peer = await template_relationship_manager.get_peer(db=db)
-        if template_relationship_peer:
-            peers[template_relationship_peer.id] = template_relationship_peer
-        return peers
-
-    @classmethod
-    async def _extract_peer_data(
-        cls,
-        db: InfrahubDatabase,
-        template_peer: Node,
-        obj_peer_schema: MainSchemaTypes,
-        parent_obj: Node,
-        current_template: CoreObjectTemplate,
-    ) -> Mapping[str, Any]:
-        obj_peer_data: dict[str, Any] = {}
-
-        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, "source": template_peer.id}
-
-        for rel in template_peer.get_schema().relationship_names:
-            rel_manager: RelationshipManager = getattr(template_peer, rel)
-            if (
-                rel_manager.schema.kind not in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
-                or rel_manager.schema.name not in obj_peer_schema.relationship_names
-            ):
-                continue
-
-            if list(await rel_manager.get_peers(db=db)) == [current_template.id]:
-                obj_peer_data[rel] = {"id": parent_obj.id}
-
-        return obj_peer_data
-
-    @classmethod
-    async def _handle_template_relationships(
-        cls,
-        db: InfrahubDatabase,
-        branch: Branch,
-        obj: Node,
-        template: CoreObjectTemplate,
-        data: InputObjectType,
-        constraint_runner: NodeConstraintRunner | None = None,
-    ) -> None:
-        if constraint_runner is None:
-            component_registry = get_component_registry()
-            constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
-
-        for relationship in obj.get_relationships(kind=RelationshipKind.COMPONENT, exclude=list(data)):
-            template_relationship_peers = await cls._get_template_relationship_peers(
-                db=db, template=template, relationship=relationship
-            )
-            if not template_relationship_peers:
-                continue
-
-            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,
-                    obj_peer_schema=obj_peer_schema,
-                    parent_obj=obj,
-                    current_template=template,
-                )
-
-                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)
-
-                await cls._handle_template_relationships(
-                    db=db,
-                    branch=branch,
-                    constraint_runner=constraint_runner,
-                    obj=obj_peer,
-                    template=template_relationship_peer,
-                    data=data,
-                )
-
     @classmethod
     async def mutate_create(
         cls,
@@ -301,51 +182,15 @@ class InfrahubMutationMixin:
         db: InfrahubDatabase,
         branch: Branch,
     ) -> Node:
-        component_registry = get_component_registry()
-        node_constraint_runner = await component_registry.get_component(
-            NodeConstraintRunner, db=db.start_session(), branch=branch
+        schema = cls._meta.active_schema
+        if isinstance(schema, GenericSchema):
+            raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+        return await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=schema,
         )
-        node_class = Node
-        if cls._meta.active_schema.kind in registry.node:
-            node_class = registry.node[cls._meta.active_schema.kind]
-
-        fields_to_validate = list(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=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,
-                    )
-
-        if await cls._get_profile_ids(db=db, obj=obj):
-            obj = await cls._refresh_for_profile_update(db=db, branch=branch, obj=obj)
-
-        return obj
 
     @classmethod
     async def mutate_create_to_graphql(cls, info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> Self:
@@ -439,7 +284,7 @@ class InfrahubMutationMixin:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
 
-        before_mutate_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
+        before_mutate_profile_ids = await 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(
@@ -453,8 +298,12 @@ class InfrahubMutationMixin:
 
         await obj.save(db=db, fields=fields)
 
-        obj = await cls._refresh_for_profile_update(
-            db=db, branch=branch, obj=obj, previous_profile_ids=before_mutate_profile_ids
+        obj = await refresh_for_profile_update(
+            db=db,
+            branch=branch,
+            obj=obj,
+            previous_profile_ids=before_mutate_profile_ids,
+            schema=cls._meta.active_schema,
         )
         return obj
 

infrahub/graphql/mutations/proposed_change.py

@@ -18,10 +18,10 @@ from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, ValidationError
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
-from infrahub.message_bus import messages
 from infrahub.proposed_change.constants import ProposedChangeState
-from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE
+from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE, REQUEST_PROPOSED_CHANGE_PIPELINE
 
+from ...proposed_change.models import RequestProposedChangePipeline
 from ..types.task import TaskInfo
 from .main import InfrahubMutationOptions
 
@@ -65,18 +65,18 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
                 )
 
         if graphql_context.service:
-            message_list = [
-                messages.RequestProposedChangePipeline(
-                    proposed_change=proposed_change.id,
-                    source_branch=source_branch.name,
-                    source_branch_sync_with_git=source_branch.sync_with_git,
-                    destination_branch=destination_branch,
-                    context=graphql_context.get_context(),
-                ),
-            ]
-
-            for message in message_list:
-                await graphql_context.service.message_bus.send(message=message)
+            request_proposed_change_model = RequestProposedChangePipeline(
+                proposed_change=proposed_change.id,
+                source_branch=source_branch.name,
+                source_branch_sync_with_git=source_branch.sync_with_git,
+                destination_branch=destination_branch,
+            )
+
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=REQUEST_PROPOSED_CHANGE_PIPELINE,
+                parameters={"model": request_proposed_change_model},
+                context=graphql_context.get_context(),
+            )
 
         return proposed_change, result
 
@@ -175,16 +175,19 @@ class ProposedChangeRequestRunCheck(Mutation):
         destination_branch = proposed_change.destination_branch.value
         source_branch = await _get_source_branch(db=graphql_context.db, name=proposed_change.source_branch.value)
 
-        message = messages.RequestProposedChangePipeline(
+        request_proposed_change_model = RequestProposedChangePipeline(
             proposed_change=proposed_change.id,
             source_branch=source_branch.name,
             source_branch_sync_with_git=source_branch.sync_with_git,
             destination_branch=destination_branch,
             check_type=check_type,
-            context=graphql_context.get_context(),
         )
         if graphql_context.service:
-            await graphql_context.service.message_bus.send(message=message)
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=REQUEST_PROPOSED_CHANGE_PIPELINE,
+                parameters={"model": request_proposed_change_model},
+                context=graphql_context.get_context(),
+            )
 
         return {"ok": True}
 

infrahub/graphql/mutations/relationship.py

@@ -85,6 +85,7 @@ class RelationshipAdd(Mutation):
         nodes = await _validate_peers(info=info, data=data)
         await _validate_permissions(info=info, source_node=source, peers=nodes)
         await _validate_peer_types(info=info, data=data, source_node=source, peers=nodes)
+        await _validate_peer_parents(info=info, data=data, source_node=source, peers=nodes)
 
         # This has to be done after validating the permissions
         await apply_external_context(graphql_context=graphql_context, context_input=context)
@@ -406,6 +407,37 @@ async def _validate_peer_types(
                     )
 
 
+async def _validate_peer_parents(
+    info: GraphQLResolveInfo, data: RelationshipNodesInput, source_node: Node, peers: dict[str, Node]
+) -> None:
+    relationship_name = str(data.name)
+    rel_schema = source_node.get_schema().get_relationship(name=relationship_name)
+    if not rel_schema.common_parent:
+        return
+
+    graphql_context: GraphqlContext = info.context
+
+    source_node_parent = await source_node.get_parent_relationship_peer(
+        db=graphql_context.db, name=rel_schema.common_parent
+    )
+    if not source_node_parent:
+        # If the schema is properly validated we are not expecting this to happen
+        raise ValidationError(f"Node {source_node.id} ({source_node.get_kind()!r}) does not have a parent peer")
+
+    parents: set[str] = {source_node_parent.id}
+    for peer in peers.values():
+        peer_parent = await peer.get_parent_relationship_peer(db=graphql_context.db, name=rel_schema.common_parent)
+        if not peer_parent:
+            # If the schema is properly validated we are not expecting this to happen
+            raise ValidationError(f"Peer {peer.id} ({peer.get_kind()!r}) does not have a parent peer")
+        parents.add(peer_parent.id)
+
+    if len(parents) > 1:
+        raise ValidationError(
+            f"Cannot relate {source_node.id!r} to '{relationship_name}' peers that do not have the same parent"
+        )
+
+
 async def _collect_current_peers(
     info: GraphQLResolveInfo, data: RelationshipNodesInput, source_node: Node
 ) -> dict[str, RelationshipPeerData]:

infrahub/graphql/mutations/resource_manager.py

@@ -6,15 +6,18 @@ from graphene import Boolean, Field, InputField, InputObjectType, Int, List, Mut
 from graphene.types.generic import GenericScalar
 from typing_extensions import Self
 
-from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind
+from infrahub.core import protocols, registry
+from infrahub.core.constants import InfrahubKind, NumberPoolType
 from infrahub.core.ipam.constants import PrefixMemberType
+from infrahub.core.manager import NodeManager
 from infrahub.core.schema import NodeSchema
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.database import retry_db_transaction
 from infrahub.exceptions import QueryValidationError, SchemaNotFoundError, ValidationError
+from infrahub.pools.registration import get_branches_with_schema_number_pool
 
 from ..queries.resource_manager import PoolAllocatedNode
-from .main import InfrahubMutationMixin, InfrahubMutationOptions
+from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -177,14 +180,16 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
-            pool_node = registry.schema.get(name=data["node"].value)
-            if not pool_node.is_generic_schema and not pool_node.is_node_schema:
+            schema_node = registry.schema.get(name=data["node"].value)
+            if not schema_node.is_generic_schema and not schema_node.is_node_schema:
                 raise ValidationError(input_value="The selected model is not a Node or a Generic")
         except SchemaNotFoundError as exc:
             exc.message = "The selected model does not exist"
             raise exc
 
-        attributes = [attribute for attribute in pool_node.attributes if attribute.name == data["node_attribute"].value]
+        attributes = [
+            attribute for attribute in schema_node.attributes if attribute.name == data["node_attribute"].value
+        ]
         if not attributes:
             raise ValidationError(input_value="The selected attribute doesn't exist in the selected model")
 
@@ -192,9 +197,22 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         if attribute.kind != "Number":
             raise ValidationError(input_value="The selected attribute is not of the kind Number")
 
-        if data["start_range"].value > data["end_range"].value:
+        start_range = data["start_range"].value
+        end_range = data["end_range"].value
+        if start_range > end_range:
             raise ValidationError(input_value="start_range can't be larger than end_range")
 
+        if not isinstance(attribute.parameters, NumberAttributeParameters):
+            raise ValidationError(
+                input_value="The selected attribute parameters are not of the kind NumberAttributeParameters"
+            )
+
+        if attribute.parameters.min_value is not None and start_range < attribute.parameters.min_value:
+            raise ValidationError(input_value="start_range can't be less than min_value")
+
+        if attribute.parameters.max_value is not None and end_range > attribute.parameters.max_value:
+            raise ValidationError(input_value="end_range can't be larger than max_value")
+
         return await super().mutate_create(info=info, data=data, branch=branch)
 
     @classmethod
@@ -217,7 +235,45 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
             number_pool, result = await super().mutate_update(
                 info=info, data=data, branch=branch, database=dbt, node=node
             )
+
+            if number_pool.pool_type.value.value == NumberPoolType.SCHEMA.value and (  # type: ignore[attr-defined]
+                "start_range" in data.keys() or "end_range" in data.keys()
+            ):
+                raise ValidationError(
+                    input_value="start_range or end_range can't be updated on schema defined pools, update the schema in the default branch instead"
+                )
+
             if number_pool.start_range.value > number_pool.end_range.value:  # type: ignore[attr-defined]
                 raise ValidationError(input_value="start_range can't be larger than end_range")
 
         return number_pool, result
+
+    @classmethod
+    @retry_db_transaction(name="resource_manager_update")
+    async def mutate_delete(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+    ) -> DeleteResult:
+        graphql_context: GraphqlContext = info.context
+
+        number_pool = await NodeManager.find_object(
+            db=graphql_context.db,
+            kind=protocols.CoreNumberPool,
+            id=data.get("id"),
+            hfid=data.get("hfid"),
+            branch=branch,
+        )
+
+        violating_branches = get_branches_with_schema_number_pool(
+            kind=number_pool.node.value, attribute_name=number_pool.node_attribute.value
+        )
+
+        if violating_branches:
+            raise ValidationError(
+                input_value=f"Unable to delete number pool {number_pool.node.value}.{number_pool.node_attribute.value}"
+                f" is in use (branches: {','.join(violating_branches)})"
+            )
+
+        return await super().mutate_delete(info=info, data=data, branch=branch)

infrahub/graphql/queries/convert_object_type_mapping.py

@@ -0,0 +1,34 @@
+from graphene import Field, ObjectType, String
+from graphene.types.generic import GenericScalar
+from graphql import GraphQLResolveInfo
+
+from infrahub.core import registry
+from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
+
+
+class FieldsMapping(ObjectType):
+    mapping = GenericScalar(required=True)
+
+
+async def fields_mapping_type_conversion_resolver(
+    root: dict,  # noqa: ARG001
+    info: GraphQLResolveInfo,
+    source_kind: str,
+    target_kind: str,
+) -> dict:
+    source_schema = registry.get_node_schema(name=source_kind, branch=info.context.branch)
+    target_schema = registry.get_node_schema(name=target_kind, branch=info.context.branch)
+
+    mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
+    mapping_dict = {field_name: model.model_dump(mode="json") for field_name, model in mapping.items()}
+    return {"mapping": mapping_dict}
+
+
+FieldsMappingTypeConversion = Field(
+    FieldsMapping,
+    source_kind=String(),
+    target_kind=String(),
+    description="Retrieve fields mapping for converting object type",
+    resolver=fields_mapping_type_conversion_resolver,
+    required=True,
+)

infrahub/graphql/queries/resource_manager.py

@@ -306,7 +306,13 @@ async def resolve_number_pool_allocation(
 async def resolve_number_pool_utilization(
     db: InfrahubDatabase, pool: CoreNode, at: Timestamp | str | None, branch: Branch
 ) -> dict:
-    number_pool = NumberUtilizationGetter(db=db, pool=pool, at=at, branch=branch)
+    """
+    Returns a mapping containg utilization info of a number pool.
+    The utilization is calculated as the percentage of the total number of values in the pool that are not excluded for the corresponding attribute.
+    """
+
+    core_number_pool = await registry.manager.get_one_by_id_or_default_filter(db=db, id=pool.id, kind="CoreNumberPool")
+    number_pool = NumberUtilizationGetter(db=db, pool=core_number_pool, at=at, branch=branch)
     await number_pool.load_data()
 
     return {

infrahub/graphql/resolvers/many_relationship.py

@@ -99,7 +99,7 @@ class ManyRelationshipResolver:
         filters = {
             f"{info.field_name}__{key}": value
             for key, value in kwargs.items()
-            if "__" in key and value or key in ["id", "ids"]
+            if ("__" in key and value) or key in ["id", "ids"]
         }
 
         response: dict[str, Any] = {"edges": [], "count": None}

infrahub/graphql/resolvers/resolver.py

@@ -99,7 +99,7 @@ async def default_resolver(*args: Any, **kwargs) -> dict | list[dict] | None:
     filters = {
         f"{info.field_name}__{key}": value
         for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
+        if ("__" in key and value) or key in ["id", "ids"]
     }
 
     async with graphql_context.db.start_session(read_only=True) as db:
@@ -288,7 +288,7 @@ async def hierarchy_resolver(
     filters = {
         f"{info.field_name}__{key}": value
         for key, value in kwargs.items()
-        if "__" in key and value or key in ["id", "ids"]
+        if ("__" in key and value) or key in ["id", "ids"]
     }
 
     response: dict[str, Any] = {"edges": [], "count": None}

infrahub/graphql/resolvers/single_relationship.py

@@ -107,7 +107,7 @@ class SingleRelationshipResolver:
         filters = {
             f"{field_name}__{key}": value
             for key, value in kwargs.items()
-            if "__" in key and value or key in ["id", "ids"]
+            if ("__" in key and value) or key in ["id", "ids"]
         }
         async with db.start_session(read_only=True) as dbs:
             objs = await NodeManager.query_peers(

infrahub/graphql/schema.py

@@ -16,6 +16,7 @@ from .mutations.branch import (
     BranchValidate,
 )
 from .mutations.computed_attribute import UpdateComputedAttribute
+from .mutations.convert_object_type import ConvertObjectType
 from .mutations.diff import DiffUpdateMutation
 from .mutations.diff_conflict import ResolveDiffConflict
 from .mutations.generator import GeneratorDefinitionRequestRun
@@ -48,6 +49,7 @@ from .queries import (
     InfrahubStatus,
     Relationship,
 )
+from .queries.convert_object_type_mapping import FieldsMappingTypeConversion
 from .queries.diff.tree import DiffTreeQuery, DiffTreeSummaryQuery
 from .queries.event import Event
 from .queries.task import Task, TaskBranchStatus
@@ -77,6 +79,8 @@ class InfrahubBaseQuery(ObjectType):
     InfrahubResourcePoolAllocated = InfrahubResourcePoolAllocated
     InfrahubResourcePoolUtilization = InfrahubResourcePoolUtilization
 
+    FieldsMappingTypeConversion = FieldsMappingTypeConversion
+
 
 class InfrahubBaseMutation(ObjectType):
     InfrahubAccountTokenCreate = InfrahubAccountTokenCreate.Field()
@@ -109,3 +113,5 @@ class InfrahubBaseMutation(ObjectType):
     SchemaEnumAdd = SchemaEnumAdd.Field()
     SchemaEnumRemove = SchemaEnumRemove.Field()
     ResolveDiffConflict = ResolveDiffConflict.Field()
+
+    ConvertObjectType = ConvertObjectType.Field()

infrahub/menu/menu.py

@@ -57,7 +57,7 @@ default_menu = [
                 name="IPPrefix",
                 label="IP Prefixes",
                 kind=InfrahubKind.IPPREFIX,
-                path="/ipam/prefixes",
+                path="/ipam",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPPREFIX)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -68,7 +68,7 @@ default_menu = [
                 name="IPAddress",
                 label="IP Addresses",
                 kind=InfrahubKind.IPPREFIX,
-                path="/ipam/addresses?ipam-tab=ip-details",
+                path="/ipam/ip_addresses",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPADDRESS)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -79,6 +79,7 @@ default_menu = [
                 name="Namespaces",
                 label="Namespaces",
                 kind=InfrahubKind.IPNAMESPACE,
+                path="/ipam/namespaces",
                 icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.IPNAMESPACE)),
                 protected=True,
                 section=MenuSection.INTERNAL,
@@ -246,6 +247,37 @@ default_menu = [
                 section=MenuSection.INTERNAL,
                 order_weight=2000,
             ),
+            MenuItemDefinition(
+                namespace="Builtin",
+                name="TriggerDefinition",
+                label="Events",
+                icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
+                protected=True,
+                section=MenuSection.INTERNAL,
+                order_weight=6000,
+                children=[
+                    MenuItemDefinition(
+                        namespace="Builtin",
+                        name="TriggerRule",
+                        label="Rules",
+                        kind=InfrahubKind.TRIGGERRULE,
+                        icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
+                        protected=True,
+                        section=MenuSection.INTERNAL,
+                        order_weight=1000,
+                    ),
+                    MenuItemDefinition(
+                        namespace="Builtin",
+                        name="Action",
+                        label="Actions",
+                        kind=InfrahubKind.ACTION,
+                        icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.ACTION)),
+                        protected=True,
+                        section=MenuSection.INTERNAL,
+                        order_weight=2000,
+                    ),
+                ],
+            ),
         ],
     ),
     MenuItemDefinition(