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

infrahub/graphql/middleware.py

@@ -0,0 +1,12 @@
+from infrahub.core.branch.needs_rebase_status import check_need_rebase_status
+
+ALLOWED_MUTATIONS_ON_NEED_REBASE_BRANCH = ["BranchRebase", "BranchDelete", "BranchCreate", "ProposedChangeCreate"]
+
+
+def raise_on_mutation_on_branch_needing_rebase(next, root, info, **kwargs):  # type: ignore  # noqa
+    if info.operation.operation.value == "mutation":
+        mutation_name = info.operation.selection_set.selections[0].name.value
+        if mutation_name not in ALLOWED_MUTATIONS_ON_NEED_REBASE_BRANCH:
+            check_need_rebase_status(branch=info.context.branch)
+
+    return next(root, info, **kwargs)

infrahub/graphql/mutations/branch.py

@@ -7,8 +7,10 @@ from opentelemetry import trace
 from typing_extensions import Self
 
 from infrahub.branch.merge_mutation_checker import verify_branch_merge_mutation_allowed
+from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.database import retry_db_transaction
+from infrahub.exceptions import BranchNotFoundError, ValidationError
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.field_extractor import extract_graphql_fields
 from infrahub.graphql.types.context import ContextInput
@@ -66,12 +68,21 @@ class BranchCreate(Mutation):
         background_execution: bool = False,
         wait_until_completion: bool = True,
     ) -> Self:
+        if data.origin_branch and data.origin_branch != registry.default_branch:
+            raise ValueError(f"origin_branch must be '{registry.default_branch}'")
+
         graphql_context: GraphqlContext = info.context
         task: dict | None = None
 
         model = BranchCreateModel(**data)
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
+        try:
+            await Branch.get_by_name(db=graphql_context.db, name=model.name)
+            raise ValidationError(f"The branch {model.name} already exists")
+        except BranchNotFoundError:
+            pass
+
         if background_execution or not wait_until_completion:
             workflow = await graphql_context.active_service.workflow.submit_workflow(
                 workflow=BRANCH_CREATE, context=graphql_context.get_context(), parameters={"model": model}

infrahub/graphql/mutations/computed_attribute.py

@@ -2,20 +2,28 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, InputObjectType, Mutation, String
+from graphene import Boolean, InputObjectType, List, Mutation, NonNull, String
 
 from infrahub.core.account import ObjectPermission
 from infrahub.core.constants import ComputedAttributeKind, PermissionAction, PermissionDecision
 from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreTransformPython
 from infrahub.core.registry import registry
 from infrahub.database import retry_db_transaction
 from infrahub.events import EventMeta
 from infrahub.events.node_action import NodeUpdatedEvent
-from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.exceptions import NodeNotFoundError, ProcessingError, ValidationError
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.types.context import ContextInput
 from infrahub.log import get_log_data
 from infrahub.worker import WORKER_IDENTITY
+from infrahub.workers.dependencies import get_workflow
+from infrahub.workflows.catalogue import (
+    COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
+    COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
+    TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+    TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+)
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -89,7 +97,7 @@ class UpdateComputedAttribute(Mutation):
             raise NodeNotFoundError(
                 node_type="target_node",
                 identifier=str(data.id),
-                message="The indicated not does not have the specified attribute_name",
+                message="The indicated node does not have the specified attribute_name",
             )
         if attribute_field.value != str(data.value):
             attribute_field.value = str(data.value)
@@ -117,3 +125,102 @@ class UpdateComputedAttribute(Mutation):
         result: dict[str, Any] = {"ok": True}
 
         return cls(**result)
+
+
+class InfrahubComputedAttributeRecomputeInput(InputObjectType):
+    kind = String(required=True, description="Kind of the node to update")
+    attribute = String(required=True, description="Name of the computed attribute that must be recomputed")
+    node_ids = List(NonNull(String), description="ID of the nodes for which the attribute must be recomputed")
+
+
+class RecomputeComputedAttribute(Mutation):
+    class Arguments:
+        data = InfrahubComputedAttributeRecomputeInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_computed_attribute")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubComputedAttributeRecomputeInput,
+        context: ContextInput | None = None,
+    ) -> RecomputeComputedAttribute:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+
+        graphql_context.active_permissions.raise_for_permission(
+            permission=ObjectPermission(
+                namespace=node_schema.namespace,
+                name=node_schema.name,
+                action=PermissionAction.UPDATE.value,
+                decision=PermissionDecision.ALLOW_DEFAULT.value
+                if graphql_context.branch.name == registry.default_branch
+                else PermissionDecision.ALLOW_OTHER.value,
+            )
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        attribute = node_schema.get_attribute(name=str(data.attribute))
+
+        if not attribute:
+            raise ProcessingError(
+                message=f"The indicated node does not have the specified attribute '{data.attribute}'"
+            )
+        if not attribute.computed_attribute:
+            raise ProcessingError(
+                message=f"The indicated node does not use a computed attribute for the specified attribute '{data.attribute}'"
+            )
+
+        recalculate_single_workflow = COMPUTED_ATTRIBUTE_PROCESS_JINJA2
+        recalculate_all_workflow = TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES
+        if attribute.computed_attribute.kind == ComputedAttributeKind.TRANSFORM_PYTHON:
+            if not await NodeManager.query(
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                schema=CoreTransformPython,
+                filters={"name__value": attribute.computed_attribute.transform},
+            ):
+                raise ProcessingError(
+                    message=f"The transform for the indicated node computed attribute for the specified attribute '{data.attribute}' does not exist"
+                )
+
+            recalculate_single_workflow = COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM
+            recalculate_all_workflow = TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES
+
+        if data.node_ids:
+            nodes = await NodeManager.get_many(
+                db=graphql_context.db, branch=graphql_context.branch, ids=list(data.node_ids)
+            )
+            for node in nodes.values():
+                await get_workflow().submit_workflow(
+                    workflow=recalculate_single_workflow,
+                    context=graphql_context.get_context(),
+                    parameters={
+                        "branch_name": graphql_context.branch.name,
+                        "computed_attribute_name": str(data.attribute),
+                        "computed_attribute_kind": node_schema.kind,
+                        "node_kind": node_schema.kind,
+                        "object_id": node.id,
+                        "context": context,
+                    },
+                )
+        else:
+            await get_workflow().submit_workflow(
+                workflow=recalculate_all_workflow,
+                context=graphql_context.get_context(),
+                parameters={
+                    "branch_name": graphql_context.branch.name,
+                    "computed_attribute_name": str(data.attribute),
+                    "computed_attribute_kind": node_schema.kind,
+                    "context": context,
+                },
+            )
+
+        result: dict[str, Any] = {"ok": True}
+        return cls(**result)

infrahub/graphql/mutations/convert_object_type.py

@@ -5,9 +5,12 @@ from graphene.types.generic import GenericScalar
 from graphql import GraphQLResolveInfo
 
 from infrahub.core import registry
-from infrahub.core.convert_object_type.conversion import InputForDestField, convert_object_type
+from infrahub.core.constants.infrahubkind import READONLYREPOSITORY, REPOSITORY
+from infrahub.core.convert_object_type.object_conversion import ConversionFieldInput, convert_and_validate_object_type
+from infrahub.core.convert_object_type.repository_conversion import convert_repository_type
 from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
 from infrahub.core.manager import NodeManager
+from infrahub.repositories.create_repository import RepositoryFinalizer
 
 if TYPE_CHECKING:
     from infrahub.graphql.initialization import GraphqlContext
@@ -44,26 +47,44 @@ class ConvertObjectType(Mutation):
         source_schema = registry.get_node_schema(name=node_to_convert.get_kind(), branch=graphql_context.branch)
         target_schema = registry.get_node_schema(name=str(data.target_kind), branch=graphql_context.branch)
 
-        fields_mapping: dict[str, InputForDestField] = {}
+        fields_mapping: dict[str, ConversionFieldInput] = {}
         if not isinstance(data.fields_mapping, dict):
-            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(fields_mapping)}")
+            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(data.fields_mapping)}")
 
         for field_name, input_for_dest_field_str in data.fields_mapping.items():
-            fields_mapping[field_name] = InputForDestField(**input_for_dest_field_str)
+            fields_mapping[field_name] = ConversionFieldInput(**input_for_dest_field_str)
+
+        node_to_convert = await NodeManager.get_one(
+            id=str(data.node_id), db=graphql_context.db, branch=graphql_context.branch
+        )
 
         # Complete fields mapping with auto-mapping.
         mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
         for field_name, mapping_value in mapping.items():
             if mapping_value.source_field_name is not None and field_name not in fields_mapping:
-                fields_mapping[field_name] = InputForDestField(source_field=mapping_value.source_field_name)
-
-        new_node = await convert_object_type(
-            node=node_to_convert,
-            target_schema=target_schema,
-            mapping=fields_mapping,
-            branch=graphql_context.branch,
-            db=graphql_context.db,
-        )
+                fields_mapping[field_name] = ConversionFieldInput(source_field=mapping_value.source_field_name)
+
+        if target_schema.kind in [REPOSITORY, READONLYREPOSITORY]:
+            new_node = await convert_repository_type(
+                repository=node_to_convert,
+                target_schema=target_schema,
+                mapping=fields_mapping,
+                branch=graphql_context.branch,
+                db=graphql_context.db,
+                repository_post_creator=RepositoryFinalizer(
+                    account_session=graphql_context.active_account_session,
+                    services=graphql_context.active_service,
+                    context=graphql_context.get_context(),
+                ),
+            )
+        else:
+            new_node = await convert_and_validate_object_type(
+                node=node_to_convert,
+                target_schema=target_schema,
+                mapping=fields_mapping,
+                branch=graphql_context.branch,
+                db=graphql_context.db,
+            )
 
         dict_node = await new_node.to_graphql(db=graphql_context.db, fields={})
         result: dict[str, Any] = {"ok": True, "node": dict_node}

infrahub/graphql/mutations/display_label.py

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

infrahub/graphql/mutations/generator.py

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

infrahub/graphql/mutations/hfid.py

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

infrahub/graphql/mutations/ipam.py

@@ -16,10 +16,12 @@ from infrahub.core.node import Node
 from infrahub.core.schema import NodeSchema
 from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import NodeNotFoundError, ValidationError
-from infrahub.lock import InfrahubMultiLock, build_object_lock_name
+from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_logger
 
-from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
+from ...core.node.create import create_node
+from ...core.node.lock_utils import build_object_lock_name
+from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions, build_graphql_response
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
 if TYPE_CHECKING:
@@ -121,7 +123,13 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         ip_address: IPv4Interface | ipaddress.IPv6Interface,
         namespace_id: str,
     ) -> Node:
-        address = await cls.mutate_create_object(data=data, db=db, branch=branch)
+        address = await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=cls._meta.active_schema,
+        )
+
         reconciler = IpamReconciler(db=db, branch=branch)
         reconciled_address = await reconciler.reconcile(
             ip_value=ip_address, namespace=namespace_id, node_uuid=address.get_id()
@@ -152,9 +160,9 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
                 reconciled_address = await cls._mutate_create_object_and_reconcile(
                     data=data, branch=branch, db=dbt, ip_address=ip_address, namespace_id=namespace_id
                 )
-            result = await cls.mutate_create_to_graphql(info=info, db=dbt, obj=reconciled_address)
+            graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_address)
 
-        return reconciled_address, result
+        return reconciled_address, cls(**graphql_response)
 
     @classmethod
     async def _mutate_update_object_and_reconcile(
@@ -275,7 +283,12 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         db: InfrahubDatabase,
         namespace_id: str,
     ) -> Node:
-        prefix = await cls.mutate_create_object(data=data, db=db, branch=branch)
+        prefix = await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=cls._meta.active_schema,
+        )
         return await cls._reconcile_prefix(
             branch=branch, db=db, prefix=prefix, namespace_id=namespace_id, is_delete=False
         )
@@ -300,9 +313,9 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
                     data=data, branch=branch, db=dbt, namespace_id=namespace_id
                 )
 
-            result = await cls.mutate_create_to_graphql(info=info, db=dbt, obj=reconciled_prefix)
+            graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_prefix)
 
-        return reconciled_prefix, result
+        return reconciled_prefix, cls(**graphql_response)
 
     @classmethod
     async def _mutate_update_object_and_reconcile(