infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/graphql/mutations/proposed_change.py

@@ -1,8 +1,11 @@
+from __future__ import annotations
+
 from typing import TYPE_CHECKING, Any, Self
 
-from graphene import Boolean, Field, InputObjectType, Mutation, String
+from graphene import Boolean, Enum, Field, InputObjectType, List, Mutation, String
 from graphql import GraphQLResolveInfo
 
+from infrahub import lock
 from infrahub.core.account import GlobalPermission
 from infrahub.core.branch import Branch
 from infrahub.core.constants import (
@@ -12,26 +15,45 @@ from infrahub.core.constants import (
     PermissionDecision,
 )
 from infrahub.core.manager import NodeManager
-from infrahub.core.node import Node
+from infrahub.core.protocols import CoreProposedChange
 from infrahub.core.schema import NodeSchema
 from infrahub.database import InfrahubDatabase, retry_db_transaction
+from infrahub.events import (
+    EventMeta,
+    ProposedChangeApprovalRevokedEvent,
+    ProposedChangeApprovedEvent,
+    ProposedChangeRejectedEvent,
+    ProposedChangeRejectionRevokedEvent,
+)
 from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, ValidationError
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
-from infrahub.proposed_change.constants import ProposedChangeState
+from infrahub.graphql.types.task import TaskInfo
+from infrahub.lock import InfrahubLock, build_object_lock_name
+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 ...proposed_change.models import RequestProposedChangePipeline
-from ..types.task import TaskInfo
 from .main import InfrahubMutationOptions
 
 if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.node import Node
+    from infrahub.events.models import InfrahubEvent
+
     from ..initialization import GraphqlContext
 
+ProposedChangeApprovalDecisionInput = Enum.from_enum(ProposedChangeApprovalDecision)
+
 
 class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
     @classmethod
-    def __init_subclass_with_meta__(cls, schema: NodeSchema = None, _meta=None, **options) -> None:
+    def __init_subclass_with_meta__(
+        cls, schema: NodeSchema, _meta: InfrahubMutationOptions | None = None, **options: dict[str, Any]
+    ) -> None:
         # Make sure schema is a valid NodeSchema Node Class
         if not isinstance(schema, NodeSchema):
             raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
@@ -50,11 +72,19 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
         database: InfrahubDatabase | None = None,  # noqa: ARG003
+        override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
 
+        override_data = {"created_by": {"id": graphql_context.active_account_session.account_id}}
+        state = data.get("state", {}).get("value")
+        if state and state != ProposedChangeState.OPEN.value:
+            raise ValidationError(input_value="A proposed change has to be in the open state during creation")
+
         async with graphql_context.db.start_transaction() as dbt:
-            proposed_change, result = await super().mutate_create(info=info, data=data, branch=branch, database=dbt)
+            proposed_change, result = await super().mutate_create(
+                info=info, data=data, branch=branch, database=dbt, override_data=override_data
+            )
             destination_branch = proposed_change.destination_branch.value
             source_branch = await _get_source_branch(db=dbt, name=proposed_change.source_branch.value)
             if destination_branch == source_branch.name:
@@ -100,7 +130,7 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
             include_source=True,
         )
         state = ProposedChangeState(obj.state.value.value)
-        state.validate_editability()
+        state.validate_updatable()
 
         updated_state = None
         if state_update := data.get("state", {}).get("value"):
@@ -192,6 +222,165 @@ class ProposedChangeRequestRunCheck(Mutation):
         return {"ok": True}
 
 
+class ProposedChangeReviewInput(InputObjectType):
+    id = String(required=True, description="The ID of the proposed change to review.")
+    decision = ProposedChangeApprovalDecisionInput(
+        required=True, description="The decision for the proposed change review."
+    )
+
+
+class ProposedChangeReview(Mutation):
+    class Arguments:
+        data = ProposedChangeReviewInput(required=True)
+
+    ok = Boolean()
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: ProposedChangeReviewInput,
+    ) -> dict[str, bool]:
+        """
+        This mutation is used to approve or reject a proposed change.
+        It can also be used to undo an approval or rejection.
+        """
+
+        graphql_context: GraphqlContext = info.context
+        graphql_context.active_permissions.raise_for_permission(
+            permission=GlobalPermission(
+                action=GlobalPermissions.REVIEW_PROPOSED_CHANGE.value, decision=PermissionDecision.ALLOW_ALL.value
+            )
+        )
+        pc_id = str(data.id)
+        lock_name = build_object_lock_name(pc_id)
+        async with InfrahubLock(name=lock_name, connection=lock.registry.connection):
+            proposed_change = await NodeManager.get_one_by_id_or_default_filter(
+                id=pc_id, kind=CoreProposedChange, db=graphql_context.db, prefetch_relationships=True
+            )
+            state = ProposedChangeState(proposed_change.state.value.value)
+            state.validate_reviewable()
+
+            created_by = await proposed_change.created_by.get_peer(db=graphql_context.db)
+            if created_by and created_by.id == graphql_context.active_account_session.account_id:
+                raise ValidationError(input_value="You cannot review your own proposed changes")
+
+            current_user = await NodeManager.get_one_by_id_or_default_filter(
+                id=graphql_context.active_account_session.account_id,
+                kind=InfrahubKind.GENERICACCOUNT,
+                db=graphql_context.db,
+            )
+
+            async with graphql_context.db.start_session() as db:
+                event = await cls._handle_decision(
+                    db=db,
+                    decision=data.decision,
+                    proposed_change=proposed_change,
+                    current_user=current_user,
+                    context=graphql_context,
+                )
+                await proposed_change.save(db=db)
+
+                if event:
+                    event_service = await get_event_service()
+                    await event_service.send(event=event)
+
+        return {"ok": True}
+
+    @classmethod
+    async def _handle_decision(
+        cls,
+        db: InfrahubDatabase,
+        decision: ProposedChangeApprovalDecision,
+        proposed_change: CoreProposedChange,
+        current_user: Node,
+        context: GraphqlContext,
+    ) -> InfrahubEvent | None:
+        """Modify approved_by and rejected_by relationships of the prpoposed change based on the decision."""
+
+        approved_by = await proposed_change.approved_by.get_peers(db=db)
+        rejected_by = await proposed_change.rejected_by.get_peers(db=db)
+        approved_by_ids = [node.id for _, node in approved_by.items()]
+        rejected_by_ids = [node.id for _, node in rejected_by.items()]
+        event: InfrahubEvent | None = None
+        event_meta = EventMeta.from_context(context=context.get_context())
+
+        match decision:
+            case ProposedChangeApprovalDecision.APPROVE:
+                if current_user.id in approved_by_ids:
+                    raise ValidationError(input_value="You have already approved this proposed change")
+                await proposed_change.approved_by.add(db=db, data=current_user)
+                if current_user.id in rejected_by_ids:
+                    await proposed_change.rejected_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeApprovedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_decision=decision.value,
+                    meta=event_meta,
+                )
+
+            case ProposedChangeApprovalDecision.CANCEL_APPROVE:
+                if current_user.id not in approved_by_ids:
+                    raise ValidationError(
+                        input_value="You did not approve this proposed change yet, it can't be un-approved"
+                    )
+                await proposed_change.approved_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeApprovalRevokedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_former_decision=ProposedChangeApprovalDecision.APPROVE.value,
+                    meta=event_meta,
+                )
+
+            case ProposedChangeApprovalDecision.REJECT:
+                if current_user.id in rejected_by_ids:
+                    raise ValidationError(input_value="You have already rejected this proposed change")
+                await proposed_change.rejected_by.add(db=db, data=current_user)
+                if current_user.id in approved_by_ids:
+                    await proposed_change.approved_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeRejectedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_decision=decision.value,
+                    meta=event_meta,
+                )
+
+            case ProposedChangeApprovalDecision.CANCEL_REJECT:
+                if current_user.id not in rejected_by_ids:
+                    raise ValidationError(
+                        input_value="You did not reject this proposed change yet, it can't be un-rejected"
+                    )
+                await proposed_change.rejected_by.remove_locally(db=db, peer_id=current_user.id)
+
+                event = ProposedChangeRejectionRevokedEvent(
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    reviewer_account_id=current_user.id,
+                    reviewer_account_name=current_user.name.value,
+                    reviewer_former_decision=ProposedChangeApprovalDecision.REJECT.value,
+                    meta=event_meta,
+                )
+
+            case _:
+                raise ValidationError(input_value=f"Invalid decision {decision}")
+
+        return event
+
+
 class ProposedChangeMergeInput(InputObjectType):
     id = String(required=True)
 
@@ -250,6 +439,34 @@ class ProposedChangeMerge(Mutation):
         return cls(ok=True, task=task)
 
 
+class ProposedChangeCheckForApprovalRevokeInput(InputObjectType):
+    ids = Field(List(of_type=String, required=True), required=False)
+
+
+class ProposedChangeCheckForApprovalRevoke(Mutation):
+    class Arguments:
+        data = ProposedChangeCheckForApprovalRevokeInput(required=True)
+
+    ok = Boolean()
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: dict[str, Any],
+    ) -> dict[str, bool]:
+        db = info.context.db
+        ids: list[str] | None
+        try:
+            ids = data["ids"]
+        except KeyError:
+            ids = None
+
+        await do_revoke_approvals_on_updated_pcs(db=db, proposed_changes_ids=ids)
+        return cls(ok=True)
+
+
 async def _get_source_branch(db: InfrahubDatabase, name: str) -> Branch:
     try:
         return await Branch.get_by_name(name=name, db=db)

infrahub/graphql/mutations/relationship.py

@@ -332,6 +332,11 @@ async def _validate_node(info: GraphQLResolveInfo, data: RelationshipNodesInput)
     if rel_schema.cardinality != RelationshipCardinality.MANY:
         raise ValidationError({"name": f"'{relationship_name}' must be a relationship of cardinality Many"})
 
+    if rel_schema.read_only:
+        # These mutations should never be allowed to update read-only relationships, as those typically
+        # have custom code tied to them such as the approved_by relationship of a CoreProposedChange.
+        raise ValidationError({source.get_kind(): f"'{relationship_name}' is a read-only relationship"})
+
     return source
 
 

infrahub/graphql/mutations/repository.py

@@ -64,12 +64,13 @@ class InfrahubRepositoryMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
         database: InfrahubDatabase | None = None,  # noqa: ARG003
+        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)
+        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

infrahub/graphql/mutations/tasks.py

@@ -15,16 +15,17 @@ 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 InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workers.dependencies import get_database, get_workflow
 from infrahub.workflows.catalogue import BRANCH_MERGE
 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, context: InfrahubContext, service: InfrahubServices) -> None:
+async def merge_branch_mutation(branch: str, context: InfrahubContext) -> None:
     await add_tags(branches=[branch])
 
-    async with service.database.start_session() as db:
+    database = await get_database()
+    async with database.start_session() as db:
         obj = await Branch.get_by_name(db=db, name=branch)
         base_branch = await Branch.get_by_name(db=db, name=registry.default_branch)
 
@@ -52,7 +53,7 @@ async def merge_branch_mutation(branch: str, context: InfrahubContext, service:
             diff_repository=diff_repository,
             source_branch=obj,
             diff_locker=DiffLocker(),
-            service=service,
+            workflow=get_workflow(),
         )
         candidate_schema = merger.get_candidate_schema()
         determiner = ConstraintValidatorDeterminer(schema_branch=candidate_schema)
@@ -62,13 +63,10 @@ async def merge_branch_mutation(branch: str, context: InfrahubContext, service:
 
         if constraints:
             responses = await schema_validate_migrations(
-                message=SchemaValidateMigrationData(
-                    branch=obj, schema_branch=candidate_schema, constraints=constraints
-                ),
-                service=service,
+                message=SchemaValidateMigrationData(branch=obj, schema_branch=candidate_schema, constraints=constraints)
             )
             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, context=context, parameters={"branch": obj.name})
+        await get_workflow().execute_workflow(workflow=BRANCH_MERGE, context=context, parameters={"branch": obj.name})

infrahub/graphql/mutations/webhook.py

@@ -67,6 +67,7 @@ class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
         data: InputObjectType,
         branch: Branch,
         database: InfrahubDatabase | None = None,
+        override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
         graphql_context: GraphqlContext = info.context
 
@@ -74,7 +75,9 @@ class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
 
         _validate_input(graphql_context=graphql_context, branch=branch, input_data=input_data)
 
-        obj, result = await super().mutate_create(info=info, data=data, branch=branch, database=database)
+        obj, result = await super().mutate_create(
+            info=info, data=data, branch=branch, database=database, override_data=override_data
+        )
 
         return obj, result
 

infrahub/graphql/parser.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 from graphql.language import (
     DirectiveNode,
     FieldNode,
+    FragmentSpreadNode,
     InlineFragmentNode,
     ListValueNode,
     NameNode,
@@ -15,7 +16,9 @@ from graphql.language import (
 from infrahub_sdk.utils import deep_merge_dict
 
 if TYPE_CHECKING:
-    from infrahub.core.schema import NodeSchema
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.schema import GenericSchema, NodeSchema
 
 
 @dataclass
@@ -26,14 +29,14 @@ class FieldEnricher:
     fields: dict = field(default_factory=dict)
 
 
-async def extract_selection(field_node: FieldNode, schema: NodeSchema) -> dict:
-    graphql_extractor = GraphQLExtractor(field_node=field_node, schema=schema)
+async def extract_selection(info: GraphQLResolveInfo, schema: NodeSchema | GenericSchema) -> dict:
+    graphql_extractor = GraphQLExtractor(info=info, schema=schema)
     return await graphql_extractor.get_fields()
 
 
 class GraphQLExtractor:
-    def __init__(self, field_node: FieldNode, schema: NodeSchema) -> None:
-        self.field_node = field_node
+    def __init__(self, info: GraphQLResolveInfo, schema: NodeSchema | GenericSchema) -> None:
+        self.info = info
         self.schema = schema
         self.typename_paths: dict[str, list[FieldEnricher]] = {}
         self.node_path: dict[str, list[FieldEnricher]] = {}
@@ -43,7 +46,7 @@ class GraphQLExtractor:
             self.node_path[path] = []
 
     async def get_fields(self) -> dict:
-        return await self.extract_fields(selection_set=self.field_node.selection_set) or {}
+        return await self.extract_fields(selection_set=self.info.field_nodes[0].selection_set) or {}
 
     def _process_expand_directive(self, path: str, directive: DirectiveNode) -> None:
         excluded_fields = []
@@ -204,6 +207,12 @@ class GraphQLExtractor:
                         elif isinstance(fields[sub_node.name.value], dict) and isinstance(value, dict):
                             fields[sub_node.name.value].update(value)  # type: ignore[union-attr]
 
+            elif isinstance(node, FragmentSpreadNode):
+                if node.name.value in self.info.fragments:
+                    fragment_fields = await self.extract_fields(self.info.fragments[node.name.value].selection_set)
+                    if fragment_fields:
+                        fields.update(fragment_fields)
+
         return self.apply_directives(selection_set=selection_set, fields=fields, path=path)
 
 

infrahub/graphql/queries/__init__.py

@@ -1,7 +1,13 @@
 from .account import AccountPermissions, AccountToken
 from .branch import BranchQueryList
 from .internal import InfrahubInfo
-from .ipam import InfrahubIPAddressGetNextAvailable, InfrahubIPPrefixGetNextAvailable
+from .ipam import (
+    DeprecatedIPAddressGetNextAvailable,
+    DeprecatedIPPrefixGetNextAvailable,
+    InfrahubIPAddressGetNextAvailable,
+    InfrahubIPPrefixGetNextAvailable,
+)
+from .proposed_change import ProposedChangeAvailableActions
 from .relationship import Relationship
 from .resource_manager import InfrahubResourcePoolAllocated, InfrahubResourcePoolUtilization
 from .search import InfrahubSearchAnywhere
@@ -12,6 +18,8 @@ __all__ = [
     "AccountPermissions",
     "AccountToken",
     "BranchQueryList",
+    "DeprecatedIPAddressGetNextAvailable",
+    "DeprecatedIPPrefixGetNextAvailable",
     "InfrahubIPAddressGetNextAvailable",
     "InfrahubIPPrefixGetNextAvailable",
     "InfrahubInfo",
@@ -19,6 +27,7 @@ __all__ = [
     "InfrahubResourcePoolUtilization",
     "InfrahubSearchAnywhere",
     "InfrahubStatus",
+    "ProposedChangeAvailableActions",
     "Relationship",
     "Task",
 ]

infrahub/graphql/queries/account.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from graphene import Field, Int, List, NonNull, ObjectType, String
-from infrahub_sdk.utils import extract_fields_first_node
 
 from infrahub.core.manager import NodeManager
 from infrahub.core.protocols import InternalAccountToken
 from infrahub.exceptions import PermissionDeniedError
+from infrahub.graphql.field_extractor import extract_graphql_fields
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -44,7 +44,7 @@ async def resolve_account_tokens(
     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)
+    fields = extract_graphql_fields(info)
 
     filters = {"account__ids": [graphql_context.account_session.account_id]}
     response: dict[str, Any] = {}
@@ -121,7 +121,7 @@ async def resolve_account_permissions(
     if not graphql_context.account_session:
         raise ValueError("An account_session is mandatory to execute this query")
 
-    fields = await extract_fields_first_node(info)
+    fields = extract_graphql_fields(info)
 
     response: dict[str, dict[str, Any]] = {}
     if "global_permissions" in fields:

infrahub/graphql/queries/branch.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from graphene import ID, Field, List, NonNull, String
-from infrahub_sdk.utils import extract_fields_first_node
 
+from infrahub.graphql.field_extractor import extract_graphql_fields
 from infrahub.graphql.types import BranchType
 
 if TYPE_CHECKING:
@@ -16,7 +16,7 @@ async def branch_resolver(
     info: GraphQLResolveInfo,
     **kwargs: Any,
 ) -> list[dict[str, Any]]:
-    fields = await extract_fields_first_node(info)
+    fields = extract_graphql_fields(info)
     return await BranchType.get_list(graphql_context=info.context, fields=fields, **kwargs)
 
 

infrahub/graphql/queries/diff/tree.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Any
 
 from graphene import Argument, Boolean, DateTime, Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene import Enum as GrapheneEnum
-from infrahub_sdk.utils import extract_fields
 
 from infrahub.core import registry
 from infrahub.core.constants import DiffAction, RelationshipCardinality
@@ -16,6 +15,7 @@ from infrahub.core.query.diff import DiffCountChanges
 from infrahub.core.timestamp import Timestamp
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.graphql.enums import ConflictSelection as GraphQLConflictSelection
+from infrahub.graphql.field_extractor import extract_graphql_fields
 
 if TYPE_CHECKING:
     from datetime import datetime
@@ -438,7 +438,7 @@ class DiffTreeResolver:
         else:
             enriched_diff = enriched_diffs[0]
 
-        full_fields = await extract_fields(info.field_nodes[0].selection_set)
+        full_fields = extract_graphql_fields(info=info)
         diff_tree = await self.to_diff_tree(enriched_diff_root=enriched_diff, graphql_context=graphql_context)
         need_base_changes = "num_untracked_base_changes" in full_fields
         need_branch_changes = "num_untracked_diff_changes" in full_fields
@@ -495,7 +495,7 @@ class DiffTreeResolver:
             to_time=summary.to_time.to_datetime(),
             **summary.model_dump(exclude={"from_time", "to_time"}),
         )
-        full_fields = await extract_fields(info.field_nodes[0].selection_set)
+        full_fields = extract_graphql_fields(info=info)
         need_base_changes = "num_untracked_base_changes" in full_fields
         need_branch_changes = "num_untracked_diff_changes" in full_fields
         if need_base_changes or need_branch_changes:

infrahub/graphql/queries/event.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Argument, Boolean, DateTime, Field, Int, List, NonNull, ObjectType, String
-from infrahub_sdk.utils import extract_fields_first_node
+from graphene import Argument, Boolean, DateTime, Enum, Field, Int, List, NonNull, ObjectType, String
 
+from infrahub.events.constants import EventSortOrder
 from infrahub.exceptions import ValidationError
+from infrahub.graphql.field_extractor import extract_graphql_fields
 from infrahub.graphql.types.event import EventNodes, EventTypeFilter
 from infrahub.task_manager.event import PrefectEvent
 from infrahub.task_manager.models import InfrahubEventFilter
@@ -15,6 +16,8 @@ if TYPE_CHECKING:
 
     from graphql import GraphQLResolveInfo
 
+InfrahubEventSortOrder = Enum.from_enum(EventSortOrder)
+
 
 class Events(ObjectType):
     edges = List(NonNull(EventNodes), required=True)
@@ -24,6 +27,7 @@ class Events(ObjectType):
     async def resolve(
         root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
+        order: EventSortOrder,
         limit: int = 10,
         has_children: bool | None = None,
         level: int | None = None,
@@ -57,6 +61,7 @@ class Events(ObjectType):
             since=since,
             until=until,
             level=level,
+            order=order,
         )
 
         return await Events.query(
@@ -74,7 +79,7 @@ class Events(ObjectType):
         limit: int,
         offset: int | None = None,
     ) -> dict[str, Any]:
-        fields = await extract_fields_first_node(info)
+        fields = extract_graphql_fields(info)
 
         prefect_tasks = await PrefectEvent.query(
             fields=fields,
@@ -110,6 +115,11 @@ Event = Field(
     branches=List(NonNull(String), required=False, description="Filter the query to specific branches"),
     account__ids=List(NonNull(String), required=False, description="Filter the query to specific accounts"),
     ids=List(NonNull(String)),
+    order=InfrahubEventSortOrder(
+        required=False,
+        default_value=EventSortOrder.DESC,
+        description="Sort order of the events, defaults to descending order",
+    ),
     resolver=Events.resolve,
     required=True,
 )

infrahub/graphql/queries/ipam.py

@@ -74,7 +74,7 @@ class IPPrefixGetNextAvailable(ObjectType):
         root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         prefix_id: str,
-        prefix_length: int,
+        prefix_length: int | None = None,
     ) -> dict[str, str]:
         graphql_context: GraphqlContext = info.context
 
@@ -119,3 +119,25 @@ InfrahubIPPrefixGetNextAvailable = Field(
     resolver=IPPrefixGetNextAvailable.resolve,
     required=True,
 )
+
+# The following two query fields must be removed once we are sure that people are not using the old queries anymore. Those fields only exist to
+# expose a deprecation message.
+
+DeprecatedIPAddressGetNextAvailable = Field(
+    IPAddressGetNextAvailable,
+    prefix_id=String(required=True),
+    prefix_length=Int(required=False),
+    resolver=IPAddressGetNextAvailable.resolve,
+    required=True,
+    deprecation_reason="This query has been renamed to 'InfrahubIPAddressGetNextAvailable'. It will be removed in the next version of Infrahub.",
+)
+
+
+DeprecatedIPPrefixGetNextAvailable = Field(
+    IPPrefixGetNextAvailable,
+    prefix_id=String(required=True),
+    prefix_length=Int(required=False),
+    resolver=IPPrefixGetNextAvailable.resolve,
+    required=True,
+    deprecation_reason="This query has been renamed to 'InfrahubIPPrefixGetNextAvailable'. It will be removed in the next version of Infrahub.",
+)