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

infrahub/graphql/mutations/resource_manager.py

@@ -61,11 +61,11 @@ class IPPrefixPoolGetResource(Mutation):
     @classmethod
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: InputObjectType,
     ) -> Self:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         member_type = data.get("member_type", None)
         allowed_member_types = [t.value for t in PrefixMemberType]
@@ -73,15 +73,15 @@ class IPPrefixPoolGetResource(Mutation):
             raise QueryValidationError(f"Invalid member_type value, allowed values are {allowed_member_types}")
 
         obj: CoreIPPrefixPool = await registry.manager.find_object(  # type: ignore[assignment]
-            db=context.db,
+            db=graphql_context.db,
             kind=InfrahubKind.IPPREFIXPOOL,
             id=data.get("id"),
             hfid=data.get("hfid"),
-            branch=context.branch,
+            branch=graphql_context.branch,
         )
         resource = await obj.get_resource(
-            db=context.db,
-            branch=context.branch,
+            db=graphql_context.db,
+            branch=graphql_context.branch,
             identifier=data.get("identifier", None),
             prefixlen=data.get("prefix_length", None),
             member_type=member_type,
@@ -95,8 +95,8 @@ class IPPrefixPoolGetResource(Mutation):
                 "id": resource.id,
                 "kind": resource.get_kind(),
                 "identifier": data.get("identifier", None),
-                "display_label": await resource.render_display_label(db=context.db),
-                "branch": context.branch.name,
+                "display_label": await resource.render_display_label(db=graphql_context.db),
+                "branch": graphql_context.branch.name,
             },
         }
 
@@ -113,26 +113,26 @@ class IPAddressPoolGetResource(Mutation):
     @classmethod
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: dict[str, Any],
     ) -> Self:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         obj: CoreIPAddressPool = await registry.manager.find_object(
-            db=context.db,
+            db=graphql_context.db,
             kind=InfrahubKind.IPADDRESSPOOL,
             id=data.get("id"),
             hfid=data.get("hfid"),
-            branch=context.branch,
+            branch=graphql_context.branch,
         )
         resource = await obj.get_resource(
-            db=context.db,
-            branch=context.branch,
-            identifier=data.get("identifier", None),
-            prefixlen=data.get("prefix_length", None),
-            address_type=data.get("address_type", None),
-            data=data.get("data", None),
+            db=graphql_context.db,
+            branch=graphql_context.branch,
+            identifier=data.get("identifier"),
+            prefixlen=data.get("prefix_length"),
+            address_type=data.get("address_type"),
+            data=data.get("data"),
         )
 
         result = {
@@ -140,9 +140,9 @@ class IPAddressPoolGetResource(Mutation):
             "node": {
                 "id": resource.id,
                 "kind": resource.get_kind(),
-                "identifier": data.get("identifier", None),
-                "display_label": await resource.render_display_label(db=context.db),
-                "branch": context.branch.name,
+                "identifier": data.get("identifier"),
+                "display_label": await resource.render_display_label(db=graphql_context.db),
+                "branch": graphql_context.branch.name,
             },
         }
 
@@ -151,7 +151,7 @@ class IPAddressPoolGetResource(Mutation):
 
 class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
+    def __init_subclass_with_meta__(
         cls,
         schema: NodeSchema | None = None,
         _meta: InfrahubMutationOptions | None = None,
@@ -174,7 +174,7 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: InfrahubDatabase | None = None,
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
             pool_node = registry.get_node_schema(name=data["node"].value)
@@ -204,16 +204,16 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         info: GraphQLResolveInfo,
         data: InputObjectType,
         branch: Branch,
-        database: InfrahubDatabase | None = None,
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
         node: Node | None = None,
     ) -> tuple[Node, Self]:
         if (data.get("node") and data.get("node").value) or (
             data.get("node_attribute") and data.get("node_attribute").value
         ):
             raise ValidationError(input_value="The fields 'node' or 'node_attribute' can't be changed.")
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        async with context.db.start_transaction() as dbt:
+        async with graphql_context.db.start_transaction() as dbt:
             number_pool, result = await super().mutate_update(
                 info=info, data=data, branch=branch, database=dbt, node=node
             )

infrahub/graphql/mutations/schema.py

@@ -21,6 +21,7 @@ from ..types import DropdownFields
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
+    from infrahub.context import InfrahubContext
     from infrahub.core.branch import Branch
     from infrahub.services import InfrahubServices
 
@@ -58,13 +59,13 @@ class SchemaDropdownAdd(Mutation):
     @retry_db_transaction(name="schema_dropdown_add")
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: SchemaDropdownAddInput,
     ) -> Self:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        kind = context.db.schema.get(name=str(data.kind), branch=context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
         attribute = str(data.attribute)
         validate_kind_dropdown(kind=kind, attribute=attribute)
         dropdown = str(data.dropdown)
@@ -80,13 +81,14 @@ class SchemaDropdownAdd(Mutation):
 
         await update_registry(
             kind=kind,
-            branch=context.branch,
-            db=context.db,
-            account_id=context.active_account_session.account_id,
-            service=context.active_service,
+            branch=graphql_context.branch,
+            db=graphql_context.db,
+            account_id=graphql_context.active_account_session.account_id,
+            service=graphql_context.active_service,
+            context=graphql_context.get_context(),
         )
 
-        kind = context.db.schema.get(name=str(data.kind), branch=context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
         attrib = kind.get_attribute(attribute)
         dropdown_entry = {}
         success = False
@@ -114,19 +116,22 @@ class SchemaDropdownRemove(Mutation):
     @retry_db_transaction(name="schema_dropdown_remove")
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: SchemaDropdownRemoveInput,
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        kind = context.db.schema.get(name=str(data.kind), branch=context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
 
         attribute = str(data.attribute)
         validate_kind_dropdown(kind=kind, attribute=attribute)
         dropdown = str(data.dropdown)
         nodes_with_dropdown = await NodeManager.query(
-            db=context.db, schema=kind.kind, filters={f"{attribute}__value": dropdown}, branch=context.branch
+            db=graphql_context.db,
+            schema=kind.kind,
+            filters={f"{attribute}__value": dropdown},
+            branch=graphql_context.branch,
         )
         if nodes_with_dropdown:
             raise ValidationError(f"There are still {kind.kind} objects using this dropdown")
@@ -143,10 +148,11 @@ class SchemaDropdownRemove(Mutation):
 
         await update_registry(
             kind=kind,
-            branch=context.branch,
-            db=context.db,
-            account_id=context.active_account_session.account_id,
-            service=context.active_service,
+            branch=graphql_context.branch,
+            db=graphql_context.db,
+            account_id=graphql_context.active_account_session.account_id,
+            service=graphql_context.active_service,
+            context=graphql_context.get_context(),
         )
 
         return {"ok": True}
@@ -162,13 +168,13 @@ class SchemaEnumAdd(Mutation):
     @retry_db_transaction(name="schema_dropdown_add")
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: SchemaEnumInput,
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        kind = context.db.schema.get(name=str(data.kind), branch=context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
 
         attribute = str(data.attribute)
         enum = str(data.enum)
@@ -184,10 +190,11 @@ class SchemaEnumAdd(Mutation):
 
         await update_registry(
             kind=kind,
-            branch=context.branch,
-            db=context.db,
-            account_id=context.active_account_session.account_id,
-            service=context.active_service,
+            branch=graphql_context.branch,
+            db=graphql_context.db,
+            account_id=graphql_context.active_account_session.account_id,
+            service=graphql_context.active_service,
+            context=graphql_context.get_context(),
         )
 
         return {"ok": True}
@@ -203,19 +210,22 @@ class SchemaEnumRemove(Mutation):
     @retry_db_transaction(name="schema_enum_remove")
     async def mutate(
         cls,
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: SchemaEnumInput,
     ) -> dict[str, bool]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        kind = context.db.schema.get(name=str(data.kind), branch=context.branch.name)
+        kind = graphql_context.db.schema.get(name=str(data.kind), branch=graphql_context.branch.name)
 
         attribute = str(data.attribute)
         enum = str(data.enum)
         validate_kind_enum(kind=kind, attribute=attribute)
         nodes_with_enum = await NodeManager.query(
-            db=context.db, schema=kind.kind, filters={f"{attribute}__value": enum}, branch=context.branch
+            db=graphql_context.db,
+            schema=kind.kind,
+            filters={f"{attribute}__value": enum},
+            branch=graphql_context.branch,
         )
         if nodes_with_enum:
             raise ValidationError(f"There are still {kind.kind} objects using this enum")
@@ -232,10 +242,11 @@ class SchemaEnumRemove(Mutation):
 
         await update_registry(
             kind=kind,
-            branch=context.branch,
-            db=context.db,
-            account_id=context.active_account_session.account_id,
-            service=context.active_service,
+            branch=graphql_context.branch,
+            db=graphql_context.db,
+            account_id=graphql_context.active_account_session.account_id,
+            service=graphql_context.active_service,
+            context=graphql_context.get_context(),
         )
 
         return {"ok": True}
@@ -268,7 +279,12 @@ def validate_kind(kind: Union[GenericSchema, NodeSchema], attribute: str) -> Non
 
 
 async def update_registry(
-    kind: NodeSchema, db: InfrahubDatabase, branch: Branch, account_id: str, service: InfrahubServices
+    kind: NodeSchema,
+    db: InfrahubDatabase,
+    branch: Branch,
+    account_id: str,
+    service: InfrahubServices,
+    context: InfrahubContext,
 ) -> None:
     async with lock.registry.global_schema_lock():
         branch_schema = registry.schema.get_schema_branch(name=branch.name)
@@ -296,12 +312,14 @@ async def update_registry(
             log_data = get_log_data()
             request_id = log_data.get("request_id", "")
             event = SchemaUpdatedEvent(
-                branch=branch.name,
+                branch_name=branch.name,
                 schema_hash=branch.active_schema_hash.main,
                 meta=EventMeta(
                     initiator_id=WORKER_IDENTITY,
                     request_id=request_id,
                     account_id=account_id,
+                    branch=branch,
+                    context=context,
                 ),
             )
             await service.event.send(event=event)

infrahub/graphql/mutations/tasks.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from prefect import flow
 
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.diff.coordinator import DiffCoordinator
@@ -13,15 +14,14 @@ from infrahub.core.validators.models.validate_migration import SchemaValidateMig
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.exceptions import ValidationError
-from infrahub.services import services
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.catalogue import BRANCH_MERGE
-from infrahub.workflows.utils import add_branch_tag
+from infrahub.workflows.utils import add_tags
 
 
 @flow(name="merge-branch-mutation", flow_run_name="Merge branch graphQL mutation")
-async def merge_branch_mutation(branch: str) -> None:
-    service = services.service
-    await add_branch_tag(branch_name=branch)
+async def merge_branch_mutation(branch: str, context: InfrahubContext, service: InfrahubServices) -> None:
+    await add_tags(branches=[branch])
 
     async with service.database.start_session() as db:
         obj = await Branch.get_by_name(db=db, name=branch)
@@ -31,14 +31,17 @@ async def merge_branch_mutation(branch: str) -> None:
         diff_coordinator = await component_registry.get_component(DiffCoordinator, db=db, branch=obj)
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
         diff_merger = await component_registry.get_component(DiffMerger, db=db, branch=obj)
-        enriched_diff = await diff_coordinator.update_branch_diff_and_return(base_branch=base_branch, diff_branch=obj)
-        if enriched_diff.get_all_conflicts():
+        enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
+        async for _ in diff_repository.get_all_conflicts_for_diff(
+            diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
+        ):
+            # if there are any conflicts, raise the error
             raise ValidationError(
                 f"Branch {obj.name} contains conflicts with the default branch."
                 " Please create a Proposed Change to resolve the conflicts or manually update them before merging."
             )
         node_diff_field_summaries = await diff_repository.get_node_field_summaries(
-            diff_branch_name=enriched_diff.diff_branch_name, diff_id=enriched_diff.uuid
+            diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
         )
 
         merger = BranchMerger(
@@ -57,10 +60,13 @@ async def merge_branch_mutation(branch: str) -> None:
 
         if constraints:
             responses = await schema_validate_migrations(
-                message=SchemaValidateMigrationData(branch=obj, schema_branch=candidate_schema, constraints=constraints)
+                message=SchemaValidateMigrationData(
+                    branch=obj, schema_branch=candidate_schema, constraints=constraints
+                ),
+                service=service,
             )
             error_messages = [violation.message for response in responses for violation in response.violations]
             if error_messages:
                 raise ValidationError(",\n".join(error_messages))
 
-        await service.workflow.execute_workflow(workflow=BRANCH_MERGE, parameters={"branch": obj.name})
+        await service.workflow.execute_workflow(workflow=BRANCH_MERGE, context=context, parameters={"branch": obj.name})

infrahub/graphql/parser.py

@@ -162,7 +162,7 @@ class GraphQLExtractor:
                         FieldNode(
                             kind="field",
                             name=NameNode(kind="name", value=sub_node.key),
-                            selection_set=SelectionSetNode(selections=tuple([sub_node.node])),
+                            selection_set=SelectionSetNode(selections=(sub_node.node,)),
                         )
                     )
                     selection_set.selections = tuple(selections)

infrahub/graphql/permissions.py

@@ -11,23 +11,25 @@ if TYPE_CHECKING:
     from infrahub.graphql.initialization import GraphqlContext
 
 
-async def get_permissions(schema: MainSchemaTypes, context: GraphqlContext) -> dict[str, Any]:
+async def get_permissions(schema: MainSchemaTypes, graphql_context: GraphqlContext) -> dict[str, Any]:
     schema_objects = [schema]
     if isinstance(schema, GenericSchema):
         for node_name in schema.used_by:
             schema_object: MainSchemaTypes
             try:
-                schema_object = registry.schema.get_node_schema(name=node_name, branch=context.branch, duplicate=False)
+                schema_object = registry.schema.get_node_schema(
+                    name=node_name, branch=graphql_context.branch, duplicate=False
+                )
             except ValueError:
                 schema_object = registry.schema.get_profile_schema(
-                    name=node_name, branch=context.branch, duplicate=False
+                    name=node_name, branch=graphql_context.branch, duplicate=False
                 )
             schema_objects.append(schema_object)
 
     response: dict[str, Any] = {"count": len(schema_objects), "edges": []}
 
     nodes = await report_schema_permissions(
-        branch=context.branch, permission_manager=context.active_permissions, schemas=schema_objects
+        branch=graphql_context.branch, permission_manager=graphql_context.active_permissions, schemas=schema_objects
     )
     response["edges"] = [{"node": node} for node in nodes]
 

infrahub/graphql/queries/account.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Field, Int, List, ObjectType, String
+from graphene import Field, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node
 
 from infrahub.core.manager import NodeManager
@@ -27,32 +27,32 @@ class AccountTokenEdge(ObjectType):
 
 class AccountTokenEdges(ObjectType):
     count = Field(Int, required=True)
-    edges = Field(List(of_type=AccountTokenEdge, required=True), required=True)
+    edges = Field(List(of_type=NonNull(AccountTokenEdge), required=True), required=True)
 
 
 async def resolve_account_tokens(
-    root: dict,  # pylint: disable=unused-argument
+    root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
     limit: int = 10,
     offset: int = 0,
 ) -> dict:
-    context: GraphqlContext = info.context
+    graphql_context: GraphqlContext = info.context
 
-    if not context.account_session:
+    if not graphql_context.account_session:
         raise ValueError("An account_session is mandatory to execute this query")
 
-    if not context.account_session.authenticated_by_jwt:
+    if not graphql_context.account_session.authenticated_by_jwt:
         raise PermissionDeniedError("This operation requires authentication with a JWT token")
 
     fields = await extract_fields_first_node(info)
 
-    filters = {"account__ids": [context.account_session.account_id]}
+    filters = {"account__ids": [graphql_context.account_session.account_id]}
     response: dict[str, Any] = {}
     if "count" in fields:
-        response["count"] = await NodeManager.count(db=context.db, schema=InternalAccountToken, filters=filters)
+        response["count"] = await NodeManager.count(db=graphql_context.db, schema=InternalAccountToken, filters=filters)
     if "edges" in fields:
         objs = await NodeManager.query(
-            db=context.db, schema=InternalAccountToken, filters=filters, limit=limit, offset=offset
+            db=graphql_context.db, schema=InternalAccountToken, filters=filters, limit=limit, offset=offset
         )
         response["edges"] = [
             {"node": {"id": obj.id, "name": obj.name.value, "expiration": obj.expiration.value}} for obj in objs
@@ -62,7 +62,11 @@ async def resolve_account_tokens(
 
 
 AccountToken = Field(
-    AccountTokenEdges, resolver=resolve_account_tokens, limit=Int(required=False), offset=Int(required=False)
+    AccountTokenEdges,
+    limit=Int(required=False),
+    offset=Int(required=False),
+    resolver=resolve_account_tokens,
+    required=True,
 )
 
 
@@ -95,12 +99,12 @@ class AccountObjectPermissionEdge(ObjectType):
 
 class AccountGlobalPermissionEdges(ObjectType):
     count = Field(Int, required=True)
-    edges = Field(List(of_type=AccountGlobalPermissionEdge, required=True), required=True)
+    edges = Field(List(of_type=NonNull(AccountGlobalPermissionEdge), required=True), required=True)
 
 
 class AccountObjectPermissionEdges(ObjectType):
     count = Field(Int, required=True)
-    edges = Field(List(of_type=AccountObjectPermissionEdge, required=True), required=True)
+    edges = Field(List(of_type=NonNull(AccountObjectPermissionEdge), required=True), required=True)
 
 
 class AccountPermissionsEdges(ObjectType):
@@ -109,19 +113,19 @@ class AccountPermissionsEdges(ObjectType):
 
 
 async def resolve_account_permissions(
-    root: dict,  # pylint: disable=unused-argument
+    root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
 ) -> dict:
-    context: GraphqlContext = info.context
+    graphql_context: GraphqlContext = info.context
 
-    if not context.account_session:
+    if not graphql_context.account_session:
         raise ValueError("An account_session is mandatory to execute this query")
 
     fields = await extract_fields_first_node(info)
 
     response: dict[str, dict[str, Any]] = {}
     if "global_permissions" in fields:
-        global_list = context.active_permissions.permissions["global_permissions"]
+        global_list = graphql_context.active_permissions.permissions["global_permissions"]
         response["global_permissions"] = {"count": len(global_list)}
         response["global_permissions"]["edges"] = [
             {
@@ -136,7 +140,7 @@ async def resolve_account_permissions(
             for obj in global_list
         ]
     if "object_permissions" in fields:
-        object_list = context.active_permissions.permissions["object_permissions"]
+        object_list = graphql_context.active_permissions.permissions["object_permissions"]
         response["object_permissions"] = {"count": len(object_list)}
         response["object_permissions"]["edges"] = [
             {
@@ -155,4 +159,4 @@ async def resolve_account_permissions(
     return response
 
 
-AccountPermissions = Field(AccountPermissionsEdges, resolver=resolve_account_permissions)
+AccountPermissions = Field(AccountPermissionsEdges, resolver=resolve_account_permissions, required=True)

infrahub/graphql/queries/branch.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import ID, Field, List, String
+from graphene import ID, Field, List, NonNull, String
 from infrahub_sdk.utils import extract_fields_first_node
 
 from infrahub.graphql.types import BranchType
@@ -12,17 +12,19 @@ if TYPE_CHECKING:
 
 
 async def branch_resolver(
-    root: dict,  # pylint: disable=unused-argument
+    root: dict,  # noqa: ARG001
     info: GraphQLResolveInfo,
     **kwargs: Any,
 ) -> list[dict[str, Any]]:
     fields = await extract_fields_first_node(info)
-    return await BranchType.get_list(context=info.context, fields=fields, **kwargs)
+    return await BranchType.get_list(graphql_context=info.context, fields=fields, **kwargs)
 
 
 BranchQueryList = Field(
-    List(BranchType),
+    List(of_type=NonNull(BranchType)),
     ids=List(ID),
     name=String(),
+    description="Retrieve information about active branches.",
     resolver=branch_resolver,
+    required=True,
 )