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

infrahub/graphql/mutations/branch.py

@@ -28,8 +28,6 @@ if TYPE_CHECKING:
     from ..initialization import GraphqlContext
 
 
-# pylint: disable=unused-argument
-
 log = get_logger()
 
 
@@ -57,28 +55,30 @@ class BranchCreate(Mutation):
     @trace.get_tracer(__name__).start_as_current_span("branch_create")
     async def mutate(
         cls,
-        root: dict,
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: BranchCreateInput,
         background_execution: bool = False,
         wait_until_completion: bool = True,
     ) -> Self:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
         task: dict | None = None
 
         model = BranchCreateModel(**data)
 
         if background_execution or not wait_until_completion:
-            workflow = await context.active_service.workflow.submit_workflow(
-                workflow=BRANCH_CREATE, parameters={"model": model}
+            workflow = await graphql_context.active_service.workflow.submit_workflow(
+                workflow=BRANCH_CREATE, context=graphql_context.get_context(), parameters={"model": model}
             )
             task = {"id": workflow.id}
             return cls(ok=True, task=task)
 
-        await context.active_service.workflow.execute_workflow(workflow=BRANCH_CREATE, parameters={"model": model})
+        await graphql_context.active_service.workflow.execute_workflow(
+            workflow=BRANCH_CREATE, context=graphql_context.get_context(), parameters={"model": model}
+        )
 
         # Retrieve created branch
-        obj = await Branch.get_by_name(db=context.db, name=model.name)
+        obj = await Branch.get_by_name(db=graphql_context.db, name=model.name)
         fields = await extract_fields(info.field_nodes[0].selection_set)
         return cls(object=await obj.to_graphql(fields=fields.get("object", {})), ok=True, task=task)
 
@@ -103,19 +103,23 @@ class BranchDelete(Mutation):
 
     @classmethod
     async def mutate(
-        cls, root: dict, info: GraphQLResolveInfo, data: BranchNameInput, wait_until_completion: bool = True
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: BranchNameInput,
+        wait_until_completion: bool = True,
     ) -> Self:
-        context: GraphqlContext = info.context
-        obj = await Branch.get_by_name(db=context.db, name=str(data.name))
+        graphql_context: GraphqlContext = info.context
+        obj = await Branch.get_by_name(db=graphql_context.db, name=str(data.name))
 
         if wait_until_completion:
-            await context.active_service.workflow.execute_workflow(
-                workflow=BRANCH_DELETE, parameters={"branch": obj.name}
+            await graphql_context.active_service.workflow.execute_workflow(
+                workflow=BRANCH_DELETE, context=graphql_context.get_context(), parameters={"branch": obj.name}
             )
             return cls(ok=True)
 
-        workflow = await context.active_service.workflow.submit_workflow(
-            workflow=BRANCH_DELETE, parameters={"branch": obj.name}
+        workflow = await graphql_context.active_service.workflow.submit_workflow(
+            workflow=BRANCH_DELETE, context=graphql_context.get_context(), parameters={"branch": obj.name}
         )
         return cls(ok=True, task={"id": str(workflow.id)})
 
@@ -128,17 +132,17 @@ class BranchUpdate(Mutation):
 
     @classmethod
     @retry_db_transaction(name="branch_update")
-    async def mutate(cls, root: dict, info: GraphQLResolveInfo, data: BranchNameInput) -> Self:
-        context: GraphqlContext = info.context
+    async def mutate(cls, root: dict, info: GraphQLResolveInfo, data: BranchNameInput) -> Self:  # noqa: ARG003
+        graphql_context: GraphqlContext = info.context
 
-        obj = await Branch.get_by_name(db=context.db, name=data["name"])
+        obj = await Branch.get_by_name(db=graphql_context.db, name=data["name"])
 
         to_extract = ["description"]
         for field_name in to_extract:
             if field_name in data and data.get(field_name) is not None:
                 setattr(obj, field_name, data[field_name])
 
-        async with context.db.start_transaction() as db:
+        async with graphql_context.db.start_transaction() as db:
             await obj.save(db=db)
 
         return cls(ok=True)
@@ -155,23 +159,27 @@ class BranchRebase(Mutation):
 
     @classmethod
     async def mutate(
-        cls, root: dict, info: GraphQLResolveInfo, data: BranchNameInput, wait_until_completion: bool = True
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: BranchNameInput,
+        wait_until_completion: bool = True,
     ) -> Self:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        obj = await Branch.get_by_name(db=context.db, name=str(data.name))
+        obj = await Branch.get_by_name(db=graphql_context.db, name=str(data.name))
         task: dict | None = None
 
         if wait_until_completion:
-            await context.active_service.workflow.execute_workflow(
-                workflow=BRANCH_REBASE, parameters={"branch": obj.name}
+            await graphql_context.active_service.workflow.execute_workflow(
+                workflow=BRANCH_REBASE, context=graphql_context.get_context(), parameters={"branch": obj.name}
             )
 
             # Pull the latest information about the branch from the database directly
-            obj = await Branch.get_by_name(db=context.db, name=str(data.name))
+            obj = await Branch.get_by_name(db=graphql_context.db, name=str(data.name))
         else:
-            workflow = await context.active_service.workflow.submit_workflow(
-                workflow=BRANCH_REBASE, parameters={"branch": obj.name}
+            workflow = await graphql_context.active_service.workflow.submit_workflow(
+                workflow=BRANCH_REBASE, context=graphql_context.get_context(), parameters={"branch": obj.name}
             )
             task = {"id": workflow.id}
 
@@ -193,21 +201,25 @@ class BranchValidate(Mutation):
     @classmethod
     @retry_db_transaction(name="branch_validate")
     async def mutate(
-        cls, root: dict, info: GraphQLResolveInfo, data: BranchNameInput, wait_until_completion: bool = True
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: BranchNameInput,
+        wait_until_completion: bool = True,
     ) -> Self:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        obj = await Branch.get_by_name(db=context.db, name=str(data.name))
+        obj = await Branch.get_by_name(db=graphql_context.db, name=str(data.name))
         task: dict | None = None
         ok = True
 
         if wait_until_completion:
-            await context.active_service.workflow.execute_workflow(
-                workflow=BRANCH_VALIDATE, parameters={"branch": obj.name}
+            await graphql_context.active_service.workflow.execute_workflow(
+                workflow=BRANCH_VALIDATE, context=graphql_context.get_context(), parameters={"branch": obj.name}
             )
         else:
-            workflow = await context.active_service.workflow.submit_workflow(
-                workflow=BRANCH_VALIDATE, parameters={"branch": obj.name}
+            workflow = await graphql_context.active_service.workflow.submit_workflow(
+                workflow=BRANCH_VALIDATE, context=graphql_context.get_context(), parameters={"branch": obj.name}
             )
             task = {"id": workflow.id}
 
@@ -227,23 +239,32 @@ class BranchMerge(Mutation):
 
     @classmethod
     async def mutate(
-        cls, root: dict, info: GraphQLResolveInfo, data: BranchNameInput, wait_until_completion: bool = True
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: BranchNameInput,
+        wait_until_completion: bool = True,
     ) -> Self:
         branch_name = data["name"]
         task: dict | None = None
+        graphql_context: GraphqlContext = info.context
 
         if wait_until_completion:
-            await info.context.active_service.workflow.execute_workflow(
-                workflow=BRANCH_MERGE_MUTATION, parameters={"branch": branch_name}
+            await graphql_context.active_service.workflow.execute_workflow(
+                workflow=BRANCH_MERGE_MUTATION,
+                context=graphql_context.get_context(),
+                parameters={"branch": branch_name},
             )
         else:
-            workflow = await info.context.active_service.workflow.submit_workflow(
-                workflow=BRANCH_MERGE_MUTATION, parameters={"branch": branch_name}
+            workflow = await graphql_context.active_service.workflow.submit_workflow(
+                workflow=BRANCH_MERGE_MUTATION,
+                context=graphql_context.get_context(),
+                parameters={"branch": branch_name},
             )
             task = {"id": workflow.id}
 
         # Pull the latest information about the branch from the database directly
-        obj = await Branch.get_by_name(db=info.context.db, name=branch_name)
+        obj = await Branch.get_by_name(db=graphql_context.db, name=branch_name)
 
         fields = await extract_fields(info.field_nodes[0].selection_set)
         ok = True

infrahub/graphql/mutations/computed_attribute.py

@@ -9,7 +9,8 @@ from infrahub.core.constants import ComputedAttributeKind, MutationAction, Permi
 from infrahub.core.manager import NodeManager
 from infrahub.core.registry import registry
 from infrahub.database import retry_db_transaction
-from infrahub.events import EventMeta, NodeMutatedEvent
+from infrahub.events import EventMeta
+from infrahub.events.node_action import NodeMutatedEvent
 from infrahub.exceptions import NodeNotFoundError, ValidationError
 from infrahub.log import get_log_data
 from infrahub.worker import WORKER_IDENTITY
@@ -41,8 +42,10 @@ class UpdateComputedAttribute(Mutation):
         info: GraphQLResolveInfo,
         data: InfrahubComputedAttributeUpdateInput,
     ) -> UpdateComputedAttribute:
-        context: GraphqlContext = info.context
-        node_schema = registry.schema.get_node_schema(name=str(data.kind), branch=context.branch.name, duplicate=False)
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
         target_attribute = node_schema.get_attribute(name=str(data.attribute))
         if (
             not target_attribute.computed_attribute
@@ -50,20 +53,20 @@ class UpdateComputedAttribute(Mutation):
         ):
             raise ValidationError(input_value=f"{node_schema.kind}.{target_attribute.name} is not a computed attribute")
 
-        context.active_permissions.raise_for_permission(
+        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 context.branch.name == registry.default_branch
+                if graphql_context.branch.name == registry.default_branch
                 else PermissionDecision.ALLOW_OTHER.value,
             )
         )
 
         if not (
             target_node := await NodeManager.get_one(
-                db=context.db, kind=node_schema.kind, id=str(data.id), branch=context.branch
+                db=graphql_context.db, kind=node_schema.kind, id=str(data.id), branch=graphql_context.branch
             )
         ):
             raise NodeNotFoundError(
@@ -81,24 +84,27 @@ class UpdateComputedAttribute(Mutation):
             )
         if attribute_field.value != str(data.value):
             attribute_field.value = str(data.value)
-            async with context.db.start_transaction() as dbt:
+            async with graphql_context.db.start_transaction() as dbt:
                 await target_node.save(db=dbt, fields=[str(data.attribute)])
 
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")
 
-            graphql_payload = await target_node.to_graphql(db=context.db, filter_sensitive=True)
-
             event = NodeMutatedEvent(
-                branch=context.branch.name,
                 kind=node_schema.kind,
                 node_id=target_node.get_id(),
-                data=graphql_payload,
+                data=target_node.node_changelog.model_dump(),
                 fields=[str(data.attribute)],
                 action=MutationAction.UPDATED,
-                meta=EventMeta(initiator_id=WORKER_IDENTITY, request_id=request_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 context.active_service.event.send(event=event)
+            await graphql_context.active_service.event.send(event=event)
 
         result: dict[str, Any] = {"ok": True}
 

infrahub/graphql/mutations/diff.py

@@ -5,9 +5,13 @@ from graphql import GraphQLResolveInfo
 
 from infrahub.core import registry
 from infrahub.core.diff.coordinator import DiffCoordinator
+from infrahub.core.diff.model.path import NameTrackingId
 from infrahub.core.diff.models import RequestDiffUpdate
+from infrahub.core.diff.repository.repository import DiffRepository
+from infrahub.core.timestamp import Timestamp
 from infrahub.database import retry_db_transaction
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.exceptions import ValidationError
 from infrahub.workflows.catalogue import DIFF_UPDATE
 
 if TYPE_CHECKING:
@@ -32,21 +36,43 @@ class DiffUpdateMutation(Mutation):
     @retry_db_transaction(name="diff_update")
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: DiffUpdateInput,
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         from_timestamp_str = DateTime.serialize(data.from_time) if data.from_time else None
         to_timestamp_str = DateTime.serialize(data.to_time) if data.to_time else None
-        if data.wait_for_completion is True:
-            component_registry = get_component_registry()
-            base_branch = await registry.get_branch(db=context.db, branch=registry.default_branch)
-            diff_branch = await registry.get_branch(db=context.db, branch=data.branch)
+        if (data.from_time or data.to_time) and not data.name:
+            raise ValidationError("diff with specified time range requires a name")
+
+        component_registry = get_component_registry()
+        base_branch = await registry.get_branch(db=graphql_context.db, branch=registry.default_branch)
+        diff_branch = await registry.get_branch(db=graphql_context.db, branch=data.branch)
+        diff_repository = await component_registry.get_component(
+            DiffRepository, db=graphql_context.db, branch=diff_branch
+        )
 
+        tracking_id = NameTrackingId(name=data.name)
+        existing_diffs_metatdatas = await diff_repository.get_roots_metadata(
+            diff_branch_names=[diff_branch.name], base_branch_names=[base_branch.name], tracking_id=tracking_id
+        )
+        if existing_diffs_metatdatas:
+            metadata = existing_diffs_metatdatas[0]
+            from_time = Timestamp(from_timestamp_str) if from_timestamp_str else None
+            to_time = Timestamp(to_timestamp_str) if to_timestamp_str else None
+            branched_from_timestamp = Timestamp(diff_branch.get_branched_from())
+            if from_time and from_time > metadata.from_time:
+                raise ValidationError(f"from_time must be null or less than or equal to {metadata.from_time}")
+            if from_time and from_time < branched_from_timestamp:
+                raise ValidationError(f"from_time must be null or greater than or equal to {branched_from_timestamp}")
+            if to_time and to_time < metadata.to_time:
+                raise ValidationError(f"to_time must be null or greater than or equal to {metadata.to_time}")
+
+        if data.wait_for_completion is True:
             diff_coordinator = await component_registry.get_component(
-                DiffCoordinator, db=context.db, branch=diff_branch
+                DiffCoordinator, db=graphql_context.db, branch=diff_branch
             )
             await diff_coordinator.run_update(
                 base_branch=base_branch,
@@ -64,7 +90,9 @@ class DiffUpdateMutation(Mutation):
             from_time=from_timestamp_str,
             to_time=to_timestamp_str,
         )
-        if context.service:
-            await context.service.workflow.submit_workflow(workflow=DIFF_UPDATE, parameters={"model": model})
+        if graphql_context.service:
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=DIFF_UPDATE, context=graphql_context.get_context(), parameters={"model": model}
+            )
 
         return {"ok": True}

infrahub/graphql/mutations/diff_conflict.py

@@ -19,9 +19,6 @@ if TYPE_CHECKING:
     from ..initialization import GraphqlContext
 
 
-# pylint: disable=unused-argument
-
-
 class ResolveDiffConflictInput(InputObjectType):
     conflict_id = InputField(String(required=True), description="ID of the diff conflict to resolve")
     selected_branch = InputField(
@@ -39,14 +36,16 @@ class ResolveDiffConflict(Mutation):
     @retry_db_transaction(name="resolve_diff_conflict")
     async def mutate(
         cls,
-        root: dict,
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: ResolveDiffConflictInput,
     ) -> ResolveDiffConflict:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         component_registry = get_component_registry()
-        diff_repo = await component_registry.get_component(DiffRepository, db=context.db, branch=context.branch)
+        diff_repo = await component_registry.get_component(
+            DiffRepository, db=graphql_context.db, branch=graphql_context.branch
+        )
 
         selection = ConflictSelection(data.selected_branch.value) if data.selected_branch else None
         conflict = await diff_repo.get_conflict_by_id(conflict_id=data.conflict_id)
@@ -55,7 +54,9 @@ class ResolveDiffConflict(Mutation):
         await diff_repo.update_conflict_by_id(conflict_id=data.conflict_id, selection=selection)
 
         core_data_checks = await NodeManager.query(
-            db=context.db, schema=InfrahubKind.DATACHECK, filters={"enriched_conflict_id__value": data.conflict_id}
+            db=graphql_context.db,
+            schema=InfrahubKind.DATACHECK,
+            filters={"enriched_conflict_id__value": data.conflict_id},
         )
         if not core_data_checks:
             return cls(ok=True)
@@ -67,5 +68,5 @@ class ResolveDiffConflict(Mutation):
             keep_branch = None
         for cdc in core_data_checks:
             cdc.keep_branch.value = keep_branch
-            await cdc.save(db=context.db)
+            await cdc.save(db=graphql_context.db)
         return cls(ok=True)

infrahub/graphql/mutations/graphql_query.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 
 class InfrahubGraphQLQueryMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls, schema: NodeSchema, _meta: Optional[Any] = None, **options: dict[str, Any]
     ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
@@ -34,20 +34,24 @@ class InfrahubGraphQLQueryMutation(InfrahubMutationMixin, Mutation):
 
     @classmethod
     async def extract_query_info(
-        cls, info: GraphQLResolveInfo, data: InputObjectType, branch: Branch
+        cls, info: GraphQLResolveInfo, data: InputObjectType, branch: Branch, db: InfrahubDatabase
     ) -> dict[str, Any]:
         query_value = data.get("query", {}).get("value", None)
         if query_value is None:
             return {}
 
         query_info = {}
-        analyzer = InfrahubGraphQLQueryAnalyzer(query=query_value, schema=info.schema, branch=branch)
+        schema_branch = db.schema.get_schema_branch(name=branch.name)
+
+        analyzer = InfrahubGraphQLQueryAnalyzer(
+            query=query_value, schema=info.schema, branch=branch, schema_branch=schema_branch
+        )
 
         valid, errors = analyzer.is_valid
         if not valid:
             raise ValueError(f"Query is not valid, {str(errors)}")
 
-        query_info["models"] = {"value": sorted(list(await analyzer.get_models_in_use(types=info.context.types)))}
+        query_info["models"] = {"value": analyzer.query_report.impacted_models}
         query_info["depth"] = {"value": await analyzer.calculate_depth()}
         query_info["height"] = {"value": await analyzer.calculate_height()}
         query_info["operations"] = {
@@ -63,11 +67,13 @@ class InfrahubGraphQLQueryMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        data.update(await cls.extract_query_info(info=info, data=data, branch=context.branch))
+        data.update(
+            await cls.extract_query_info(info=info, data=data, branch=graphql_context.branch, db=graphql_context.db)
+        )
 
         obj, result = await super().mutate_create(info=info, data=data, branch=branch)
 
@@ -79,12 +85,14 @@ class InfrahubGraphQLQueryMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: Optional[InfrahubDatabase] = None,
-        node: Optional[Node] = None,
+        database: Optional[InfrahubDatabase] = None,  # noqa: ARG003
+        node: Optional[Node] = None,  # noqa: ARG003
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        data.update(await cls.extract_query_info(info=info, data=data, branch=context.branch))
+        data.update(
+            await cls.extract_query_info(info=info, data=data, branch=graphql_context.branch, db=graphql_context.db)
+        )
 
         obj, result = await super().mutate_update(info=info, data=data, branch=branch)
 

infrahub/graphql/mutations/ipam.py

@@ -53,7 +53,7 @@ async def validate_namespace(
 
 class InfrahubIPNamespaceMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls,
         schema: NodeSchema,
         _meta: Optional[Any] = None,
@@ -84,7 +84,7 @@ class InfrahubIPNamespaceMutation(InfrahubMutationMixin, Mutation):
 
 class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls,
         schema: NodeSchema,
         _meta: Optional[Any] = None,
@@ -132,8 +132,8 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         branch: Branch,
         database: Optional[InfrahubDatabase] = None,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
         ip_address = ipaddress.ip_interface(data["address"]["value"])
         namespace_id = await validate_namespace(db=db, branch=branch, data=data)
 
@@ -179,8 +179,8 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         database: Optional[InfrahubDatabase] = None,
         node: Optional[Node] = None,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
 
         address = node or await NodeManager.get_one_by_id_or_default_filter(
             db=db,
@@ -219,8 +219,8 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         node_getters: list[MutationNodeGetterInterface],
         database: Optional[InfrahubDatabase] = None,
     ) -> tuple[Node, Self, bool]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
 
         await validate_namespace(db=db, branch=branch, data=data)
         prefix, result, created = await super().mutate_upsert(
@@ -241,7 +241,7 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
 
 class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls,
         schema: NodeSchema,
         _meta: Optional[Any] = None,
@@ -286,8 +286,8 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         branch: Branch,
         database: Optional[InfrahubDatabase] = None,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
         namespace_id = await validate_namespace(db=db, branch=branch, data=data)
 
         async with db.start_transaction() as dbt:
@@ -330,8 +330,8 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         database: Optional[InfrahubDatabase] = None,
         node: Optional[Node] = None,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
 
         prefix = node or await NodeManager.get_one_by_id_or_default_filter(
             db=db,
@@ -369,8 +369,8 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         node_getters: list[MutationNodeGetterInterface],
         database: Optional[InfrahubDatabase] = None,
     ):
-        context: GraphqlContext = info.context
-        db = database or context.db
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
 
         await validate_namespace(db=db, branch=branch, data=data)
         prefix, result, created = await super().mutate_upsert(
@@ -403,17 +403,19 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
     ) -> tuple[Node, Self]:
-        context: GraphqlContext = info.context
-        db = context.db
+        graphql_context: GraphqlContext = info.context
+        db = graphql_context.db
 
-        prefix = await NodeManager.get_one(data.get("id"), context.db, branch=branch, prefetch_relationships=True)
+        prefix = await NodeManager.get_one(
+            data.get("id"), graphql_context.db, branch=branch, prefetch_relationships=True
+        )
         if not prefix:
             raise NodeNotFoundError(branch, cls._meta.schema.kind, data.get("id"))
 
         namespace_rels = await prefix.ip_namespace.get_relationships(db=db)
         namespace_id = namespace_rels[0].peer_id
         try:
-            async with context.db.start_transaction() as dbt:
+            async with graphql_context.db.start_transaction() as dbt:
                 if lock_name := cls._get_lock_name(namespace_id, branch):
                     async with InfrahubMultiLock(lock_registry=lock.registry, locks=[lock_name]):
                         reconciled_prefix = await cls._reconcile_prefix(