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

infrahub/graphql/mutations/main.py

@@ -1,22 +1,18 @@
 from __future__ import annotations
 
-import hashlib
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
+from infrahub_sdk.utils import extract_fields_first_node
 from typing_extensions import Self
 
 from infrahub import config, lock
-from infrahub.core.constants import InfrahubKind, MutationAction
+from infrahub.core.constants import MutationAction
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
 from infrahub.core.manager import NodeManager
-from infrahub.core.node.create import (
-    create_node,
-    get_profile_ids,
-    refresh_for_profile_update,
-)
+from infrahub.core.node.create import create_node, get_profile_ids
 from infrahub.core.schema import MainSchemaTypes, NodeSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
@@ -28,9 +24,11 @@ from infrahub.events.generator import generate_node_mutation_events
 from infrahub.exceptions import HFIDViolatedError, InitializationError, NodeNotFoundError
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.field_extractor import extract_graphql_fields
-from infrahub.lock import InfrahubMultiLock, build_object_lock_name
+from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_log_data, get_logger
+from infrahub.profiles.node_applier import NodeProfilesApplier
 
+from ...core.node.lock_utils import get_kind_lock_names_on_object_mutation
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
 if TYPE_CHECKING:
@@ -38,7 +36,6 @@ if TYPE_CHECKING:
 
     from infrahub.core.branch import Branch
     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
 
@@ -47,8 +44,6 @@ if TYPE_CHECKING:
 
 log = get_logger()
 
-KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED = [InfrahubKind.GENERICGROUP]
-
 
 @dataclass
 class DeleteResult:
@@ -146,23 +141,6 @@ class InfrahubMutationMixin:
 
         return mutation
 
-    @classmethod
-    async def _call_mutate_create_object(
-        cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch, override_data: dict[str, Any] | None = None
-    ) -> 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.active_schema.kind, branch=branch, schema_branch=schema_branch, data=data
-        )
-        if lock_names:
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-                return await cls.mutate_create_object(data=data, db=db, branch=branch, override_data=override_data)
-
-        return await cls.mutate_create_object(data=data, db=db, branch=branch, override_data=override_data)
-
     @classmethod
     async def mutate_create(
         cls,
@@ -172,40 +150,21 @@ class InfrahubMutationMixin:
         database: InfrahubDatabase | None = None,
         override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
-        graphql_context: GraphqlContext = info.context
-        db = database or graphql_context.db
-        obj = await cls._call_mutate_create_object(data=data, db=db, branch=branch, override_data=override_data)
-        result = await cls.mutate_create_to_graphql(info=info, db=db, obj=obj)
-        return obj, result
-
-    @classmethod
-    @retry_db_transaction(name="object_create")
-    async def mutate_create_object(
-        cls,
-        data: InputObjectType,
-        db: InfrahubDatabase,
-        branch: Branch,
-        override_data: dict[str, Any] | None = None,
-    ) -> Node:
+        db = database or info.context.db
         schema = cls._meta.active_schema
-        if isinstance(schema, GenericSchema):
-            raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+
         create_data = dict(data)
         create_data.update(override_data or {})
-        return await create_node(
+
+        obj = await create_node(
             data=create_data,
             db=db,
             branch=branch,
             schema=schema,
         )
 
-    @classmethod
-    async def mutate_create_to_graphql(cls, info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> Self:
-        fields = extract_graphql_fields(info=info)
-        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)
+        graphql_response = await build_graphql_response(info=info, db=db, obj=obj)
+        return obj, cls(**graphql_response)
 
     @classmethod
     async def _call_mutate_update(
@@ -222,8 +181,8 @@ class InfrahubMutationMixin:
         """
 
         schema_branch = db.schema.get_schema_branch(name=branch.name)
-        lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=data
+        lock_names = get_kind_lock_names_on_object_mutation(
+            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=dict(data)
         )
 
         if db.is_transaction:
@@ -290,7 +249,6 @@ 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 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(
@@ -302,15 +260,13 @@ class InfrahubMutationMixin:
             if field_to_remove in fields:
                 fields.remove(field_to_remove)
 
+        after_mutate_profile_ids = await get_profile_ids(db=db, obj=obj)
+        if after_mutate_profile_ids or (not after_mutate_profile_ids and obj.uses_profiles()):
+            node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+            updated_field_names = await node_profiles_applier.apply_profiles(node=obj)
+            fields += updated_field_names
         await obj.save(db=db, fields=fields)
 
-        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
 
     @classmethod
@@ -422,6 +378,15 @@ class InfrahubMutationMixin:
             )
             return updated_obj, mutation, False
 
+    @classmethod
+    async def _delete_obj(cls, graphql_context: GraphqlContext, branch: Branch, obj: Node) -> list[Node]:
+        db = graphql_context.db
+        async with db.start_transaction() as dbt:
+            deleted = await NodeManager.delete(db=dbt, 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}")
+        return deleted
+
     @classmethod
     @retry_db_transaction(name="object_delete")
     async def mutate_delete(
@@ -440,11 +405,7 @@ class InfrahubMutationMixin:
             branch=branch,
         )
 
-        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}")
+        deleted = await cls._delete_obj(graphql_context=graphql_context, branch=branch, obj=obj)
 
         ok = True
 
@@ -471,90 +432,13 @@ class InfrahubMutation(InfrahubMutationMixin, Mutation):
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
 
-def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch) -> list[str]:
-    """
-    Return kinds for which we want to lock during creating / updating an object of a given schema node.
-    Lock should be performed on schema kind and its generics having a uniqueness_constraint defined.
-    If a generic uniqueness constraint is the same as the node schema one,
-    it means node schema overrided this constraint, in which case we only need to lock on the generic.
-    """
-
-    node_schema = schema_branch.get(name=kind)
-
-    schema_uc = None
-    kinds = []
-    if node_schema.uniqueness_constraints:
-        kinds.append(node_schema.kind)
-        schema_uc = node_schema.uniqueness_constraints
-
-    if node_schema.is_generic_schema:
-        return kinds
-
-    generics_kinds = node_schema.inherit_from
-
-    node_schema_kind_removed = False
-    for generic_kind in generics_kinds:
-        generic_uc = schema_branch.get(name=generic_kind).uniqueness_constraints
-        if generic_uc:
-            kinds.append(generic_kind)
-            if not node_schema_kind_removed and generic_uc == schema_uc:
-                # Check whether we should remove original schema kind as it simply overrides uniqueness_constraint
-                # of a generic
-                kinds.pop(0)
-                node_schema_kind_removed = True
-    return kinds
-
-
-def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch) -> bool:
-    """
-    Check whether kind or any kind generic is in KINDS_TO_LOCK_ON_ANY_BRANCH.
-    """
-
-    if kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
-        return True
-
-    node_schema = schema_branch.get(name=kind)
-    if node_schema.is_generic_schema:
-        return False
-
-    for generic_kind in node_schema.inherit_from:
-        if generic_kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
-            return True
-    return False
-
-
-def _hash(value: str) -> str:
-    # Do not use builtin `hash` for lock names as due to randomization results would differ between
-    # different processes.
-    return hashlib.sha256(value.encode()).hexdigest()
-
-
-def _get_kind_lock_names_on_object_mutation(
-    kind: str, branch: Branch, schema_branch: SchemaBranch, data: InputObjectType
-) -> list[str]:
-    """
-    Return objects kind for which we want to avoid concurrent mutation (create/update). Except for some specific kinds,
-    concurrent mutations are only allowed on non-main branch as objects validations will be performed at least when merging in main branch.
-    """
-
-    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind=kind, schema_branch=schema_branch):
-        return []
-
-    if kind == InfrahubKind.GRAPHQLQUERYGROUP:
-        # Lock on name as well to improve performances
-        try:
-            name = data.name.value
-            return [build_object_lock_name(kind + "." + _hash(name))]
-        except AttributeError:
-            # We might reach here if we are updating a CoreGraphQLQueryGroup without updating the name,
-            # in which case we would not need to lock. This is not supposed to happen as current `update`
-            # logic first fetches the node with its name.
-            return []
-
-    lock_kinds = _get_kinds_to_lock_on_object_mutation(kind, schema_branch)
-    lock_names = [build_object_lock_name(kind) for kind in lock_kinds]
-    return lock_names
-
-
 def _get_data_fields(data: InputObjectType) -> list[str]:
     return [field for field in data.keys() if field not in ["id", "hfid"]]
+
+
+async def build_graphql_response(info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> dict:
+    fields = await extract_fields_first_node(info)
+    result: dict[str, Any] = {"ok": True}
+    if "object" in fields:
+        result["object"] = await obj.to_graphql(db=db, fields=fields.get("object", {}))
+    return result

infrahub/graphql/mutations/profile.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from graphene import Boolean, InputObjectType, Mutation, String
+from graphql import GraphQLResolveInfo
+from opentelemetry import trace
+from typing_extensions import Self
+
+from infrahub.core.manager import NodeManager
+from infrahub.core.schema import ProfileSchema
+from infrahub.graphql.types.context import ContextInput
+from infrahub.log import get_logger
+from infrahub.profiles.node_applier import NodeProfilesApplier
+from infrahub.workflows.catalogue import PROFILE_REFRESH_MULTIPLE
+
+from .main import InfrahubMutationMixin, InfrahubMutationOptions
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.database import InfrahubDatabase
+    from infrahub.graphql.initialization import GraphqlContext
+    from infrahub.services.adapters.workflow import InfrahubWorkflow
+
+log = get_logger()
+
+
+class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: ProfileSchema,
+        _meta: InfrahubMutationOptions | None = None,
+        **options: dict[str, Any],
+    ) -> None:
+        # Make sure schema is a valid NodeSchema Node Class
+        if not isinstance(schema, ProfileSchema):
+            raise ValueError(f"You need to pass a valid ProfileSchema in '{cls.__name__}.Meta', received '{schema}'")
+
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def _send_profile_refresh_workflows(
+        cls,
+        db: InfrahubDatabase,
+        workflow_service: InfrahubWorkflow,
+        branch_name: str,
+        obj: Node,
+        node_ids: list[str] | None = None,
+    ) -> None:
+        if not node_ids:
+            related_nodes = await obj.related_nodes.get_relationships(db=db)  # type: ignore[attr-defined]
+            node_ids = [rel.peer_id for rel in related_nodes]
+        if node_ids:
+            await workflow_service.submit_workflow(
+                workflow=PROFILE_REFRESH_MULTIPLE,
+                parameters={
+                    "branch_name": branch_name,
+                    "node_ids": node_ids,
+                },
+            )
+
+    @classmethod
+    def _get_profile_attr_values_map(cls, obj: Node) -> dict[str, Any]:
+        attr_values_map = {}
+        for attr_schema in obj.get_schema().attributes:
+            # profile name update can be ignored
+            if attr_schema.name == "profile_name":
+                continue
+            attr_values_map[attr_schema.name] = getattr(obj, attr_schema.name).value
+        return attr_values_map
+
+    @classmethod
+    async def _get_profile_related_node_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
+        related_nodes = await obj.related_nodes.get_relationships(db=db)  # type: ignore[attr-defined]
+        if related_nodes:
+            related_node_ids = {rel.peer_id for rel in related_nodes}
+        else:
+            related_node_ids = set()
+        return related_node_ids
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+        override_data: dict[str, Any] | None = None,
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
+        workflow_service = graphql_context.active_service.workflow
+
+        obj, mutation = await super().mutate_create(
+            info=info, data=data, branch=branch, database=database, override_data=override_data
+        )
+        await cls._send_profile_refresh_workflows(
+            db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj
+        )
+
+        return obj, mutation
+
+    @classmethod
+    async def _call_mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        db: InfrahubDatabase,
+        obj: Node,
+        skip_uniqueness_check: bool = False,
+    ) -> tuple[Node, Self]:
+        workflow_service = info.context.active_service.workflow
+        original_attr_values = cls._get_profile_attr_values_map(obj=obj)
+        original_related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+
+        obj, mutation = await super()._call_mutate_update(
+            info=info, data=data, branch=branch, db=db, obj=obj, skip_uniqueness_check=skip_uniqueness_check
+        )
+
+        updated_attr_values = cls._get_profile_attr_values_map(obj=obj)
+        updated_related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+
+        if original_attr_values != updated_attr_values:
+            await cls._send_profile_refresh_workflows(
+                db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj
+            )
+        elif updated_related_node_ids != original_related_node_ids:
+            removed_node_ids = original_related_node_ids - updated_related_node_ids
+            added_node_ids = updated_related_node_ids - original_related_node_ids
+            await cls._send_profile_refresh_workflows(
+                db=db,
+                workflow_service=workflow_service,
+                branch_name=branch.name,
+                obj=obj,
+                node_ids=list(removed_node_ids) + list(added_node_ids),
+            )
+
+        return obj, mutation
+
+    @classmethod
+    async def _delete_obj(cls, graphql_context: GraphqlContext, branch: Branch, obj: Node) -> list[Node]:
+        db = graphql_context.db
+        workflow_service = graphql_context.active_service.workflow
+        related_node_ids = await cls._get_profile_related_node_ids(db=db, obj=obj)
+        deleted = await super()._delete_obj(graphql_context=graphql_context, branch=branch, obj=obj)
+        await cls._send_profile_refresh_workflows(
+            db=db, workflow_service=workflow_service, branch_name=branch.name, obj=obj, node_ids=list(related_node_ids)
+        )
+        return deleted
+
+
+class ProfilesRefreshInput(InputObjectType):
+    id = String(required=False)
+
+
+class InfrahubProfilesRefresh(Mutation):
+    class Arguments:
+        data = ProfilesRefreshInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @trace.get_tracer(__name__).start_as_current_span("profiles_refresh")
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: ProfilesRefreshInput,
+        context: ContextInput | None = None,  # noqa: ARG003
+    ) -> Self:
+        graphql_context: GraphqlContext = info.context
+        db = graphql_context.db
+        branch = graphql_context.branch
+        obj = await NodeManager.get_one(
+            db=db,
+            branch=branch,
+            id=str(data.id),
+            include_source=True,
+        )
+        node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+        updated_fields = await node_profiles_applier.apply_profiles(node=obj)
+        if updated_fields:
+            await obj.save(db=db, fields=updated_fields)
+
+        return cls(ok=True)

infrahub/graphql/mutations/proposed_change.py

@@ -29,13 +29,14 @@ from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, Vali
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
 from infrahub.graphql.types.task import TaskInfo
-from infrahub.lock import InfrahubLock, build_object_lock_name
+from infrahub.lock import InfrahubLock
 from infrahub.proposed_change.approval_revoker import do_revoke_approvals_on_updated_pcs
 from infrahub.proposed_change.constants import ProposedChangeApprovalDecision, ProposedChangeState
 from infrahub.proposed_change.models import RequestProposedChangePipeline
 from infrahub.workers.dependencies import get_event_service
 from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE, REQUEST_PROPOSED_CHANGE_PIPELINE
 
+from ...core.node.lock_utils import build_object_lock_name
 from .main import InfrahubMutationOptions
 
 if TYPE_CHECKING:

infrahub/graphql/mutations/relationship.py

@@ -91,7 +91,7 @@ class RelationshipAdd(Mutation):
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         rel_schema = source.get_schema().get_relationship(name=relationship_name)
-        display_label: str = await source.render_display_label(db=graphql_context.db)
+        display_label: str = await source.get_display_label(db=graphql_context.db) or ""
         node_changelog = NodeChangelog(
             node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
         )
@@ -214,7 +214,7 @@ class RelationshipRemove(Mutation):
         await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         rel_schema = source.get_schema().get_relationship(name=relationship_name)
-        display_label: str = await source.render_display_label(db=graphql_context.db)
+        display_label: str = await source.get_display_label(db=graphql_context.db) or ""
         node_changelog = NodeChangelog(
             node_id=source.get_id(), node_kind=source.get_kind(), display_label=display_label
         )

infrahub/graphql/mutations/repository.py

@@ -7,14 +7,11 @@ import httpx
 from graphene import Boolean, Field, InputObjectType, Mutation, String
 
 from infrahub import config
-from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
+from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
-from infrahub.core.protocols import CoreGenericRepository, CoreReadOnlyRepository, CoreRepository
+from infrahub.core.protocols import CoreReadOnlyRepository, CoreRepository
 from infrahub.core.schema import NodeSchema
-from infrahub.exceptions import ValidationError
 from infrahub.git.models import (
-    GitRepositoryAdd,
-    GitRepositoryAddReadOnly,
     GitRepositoryImportObjects,
     GitRepositoryPullReadOnly,
 )
@@ -22,15 +19,15 @@ from infrahub.graphql.types.common import IdentifierInput
 from infrahub.log import get_logger
 from infrahub.message_bus import messages
 from infrahub.message_bus.messages.git_repository_connectivity import GitRepositoryConnectivityResponse
+from infrahub.repositories.create_repository import RepositoryFinalizer
 from infrahub.workflows.catalogue import (
     GIT_REPOSITORIES_IMPORT_OBJECTS,
     GIT_REPOSITORIES_PULL_READ_ONLY,
-    GIT_REPOSITORY_ADD,
-    GIT_REPOSITORY_ADD_READ_ONLY,
 )
 
+from ...core.node.create import create_node
 from ..types.task import TaskInfo
-from .main import InfrahubMutationMixin, InfrahubMutationOptions
+from .main import InfrahubMutationMixin, InfrahubMutationOptions, build_graphql_response
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -63,86 +60,28 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: InfrahubDatabase | None = None,  # noqa: ARG003
+        database: InfrahubDatabase | None = None,
         override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
-
         cleanup_payload(data)
-        # Create the object in the database
-        obj, result = await super().mutate_create(info, data, branch, override_data=override_data)
-        obj = cast(CoreGenericRepository, obj)
-
-        # First check the connectivity to the remote repository
-        # If the connectivity is not good, we remove the repository to allow the user to add a new one
-        if graphql_context.service:
-            message = messages.GitRepositoryConnectivity(
-                repository_name=obj.name.value,
-                repository_location=obj.location.value,
-            )
-            response = await graphql_context.service.message_bus.rpc(
-                message=message, response_class=GitRepositoryConnectivityResponse
-            )
-
-            if response.data.success is False:
-                await obj.delete(db=graphql_context.db)
-                raise ValidationError(response.data.message)
-
-        # If we are in the default branch, we set the sync status to Active
-        # If we are in another branch, we set the sync status to Staging
-        if branch.is_default:
-            obj.internal_status.value = RepositoryInternalStatus.ACTIVE.value
-        else:
-            obj.internal_status.value = RepositoryInternalStatus.STAGING.value
-        await obj.save(db=graphql_context.db)
-
-        # Create the new repository in the filesystem.
-        log.info("create_repository", name=obj.name.value)
-        authenticated_user = None
-        if graphql_context.account_session and graphql_context.account_session.authenticated:
-            authenticated_user = graphql_context.account_session.account_id
-        if obj.get_kind() == InfrahubKind.READONLYREPOSITORY:
-            obj = cast(CoreReadOnlyRepository, obj)
-            model = GitRepositoryAddReadOnly(
-                repository_id=obj.id,
-                repository_name=obj.name.value,
-                location=obj.location.value,
-                ref=obj.ref.value,
-                infrahub_branch_name=branch.name,
-                infrahub_branch_id=str(branch.get_uuid()),
-                internal_status=obj.internal_status.value,
-                created_by=authenticated_user,
-            )
-            if graphql_context.service:
-                await graphql_context.service.workflow.submit_workflow(
-                    workflow=GIT_REPOSITORY_ADD_READ_ONLY,
-                    context=graphql_context.get_context(),
-                    parameters={"model": model},
-                )
-
-        else:
-            obj = cast(CoreRepository, obj)
-            git_repo_add_model = GitRepositoryAdd(
-                repository_id=obj.id,
-                repository_name=obj.name.value,
-                location=obj.location.value,
-                default_branch_name=obj.default_branch.value,
-                infrahub_branch_name=branch.name,
-                infrahub_branch_id=str(branch.get_uuid()),
-                internal_status=obj.internal_status.value,
-                created_by=authenticated_user,
-            )
-
-            if graphql_context.service:
-                await graphql_context.service.workflow.submit_workflow(
-                    workflow=GIT_REPOSITORY_ADD,
-                    context=graphql_context.get_context(),
-                    parameters={"model": git_repo_add_model},
-                )
-
-        # TODO Validate that the creation of the repository went as expected
+        db = database or graphql_context.db
+        create_data = dict(data)
+        create_data.update(override_data or {})
+        obj = await create_node(data=create_data, db=db, branch=branch, schema=cls._meta.active_schema)
+
+        await RepositoryFinalizer(
+            account_session=graphql_context.active_account_session,
+            services=graphql_context.active_service,
+            context=graphql_context.get_context(),
+        ).post_create(
+            obj=obj,  # type: ignore
+            branch=branch,
+            db=db,
+        )
 
-        return obj, result
+        graphql_response = await build_graphql_response(info=info, db=db, obj=obj)
+        return obj, cls(**graphql_response)
 
     @classmethod
     async def mutate_update(

infrahub/graphql/mutations/resource_manager.py

@@ -98,7 +98,7 @@ class IPPrefixPoolGetResource(Mutation):
                 "id": resource.id,
                 "kind": resource.get_kind(),
                 "identifier": data.get("identifier", None),
-                "display_label": await resource.render_display_label(db=graphql_context.db),
+                "display_label": await resource.get_display_label(db=graphql_context.db),
                 "branch": graphql_context.branch.name,
             },
         }
@@ -144,7 +144,7 @@ class IPAddressPoolGetResource(Mutation):
                 "id": resource.id,
                 "kind": resource.get_kind(),
                 "identifier": data.get("identifier"),
-                "display_label": await resource.render_display_label(db=graphql_context.db),
+                "display_label": await resource.get_display_label(db=graphql_context.db),
                 "branch": graphql_context.branch.name,
             },
         }