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

infrahub/graphql/mutations/branch.py

@@ -9,6 +9,8 @@ from typing_extensions import Self
 
 from infrahub.core.branch import Branch
 from infrahub.database import retry_db_transaction
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
 from infrahub.log import get_logger
 from infrahub.workflows.catalogue import (
     BRANCH_CREATE,
@@ -28,8 +30,6 @@ if TYPE_CHECKING:
     from ..initialization import GraphqlContext
 
 
-# pylint: disable=unused-argument
-
 log = get_logger()
 
 
@@ -46,6 +46,7 @@ class BranchCreateInput(InputObjectType):
 class BranchCreate(Mutation):
     class Arguments:
         data = BranchCreateInput(required=True)
+        context = ContextInput(required=False)
         background_execution = Boolean(required=False, deprecation_reason="Please use `wait_until_completion` instead")
         wait_until_completion = Boolean(required=False)
 
@@ -57,28 +58,32 @@ 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,
+        context: ContextInput | None = None,
         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)
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         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)
 
@@ -96,6 +101,7 @@ class BranchUpdateInput(InputObjectType):
 class BranchDelete(Mutation):
     class Arguments:
         data = BranchNameInput(required=True)
+        context = ContextInput(required=False)
         wait_until_completion = Boolean(required=False)
 
     ok = Boolean()
@@ -103,19 +109,25 @@ 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,
+        context: ContextInput | None = None,
+        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))
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         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)})
 
@@ -123,22 +135,30 @@ class BranchDelete(Mutation):
 class BranchUpdate(Mutation):
     class Arguments:
         data = BranchUpdateInput(required=True)
+        context = ContextInput(required=False)
 
     ok = Boolean()
 
     @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,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: BranchNameInput,
+        context: ContextInput | None = None,
+    ) -> Self:
+        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"])
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         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)
@@ -147,6 +167,7 @@ class BranchUpdate(Mutation):
 class BranchRebase(Mutation):
     class Arguments:
         data = BranchNameInput(required=True)
+        context = ContextInput(required=False)
         wait_until_completion = Boolean(required=False)
 
     ok = Boolean()
@@ -155,23 +176,29 @@ 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,
+        context: ContextInput | None = None,
+        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))
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
         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}
 
@@ -184,6 +211,7 @@ class BranchRebase(Mutation):
 class BranchValidate(Mutation):
     class Arguments:
         data = BranchNameInput(required=True)
+        context = ContextInput(required=False)
         wait_until_completion = Boolean(required=False)
 
     ok = Boolean()
@@ -193,21 +221,27 @@ 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,
+        context: ContextInput | None = None,
+        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))
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
         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}
 
@@ -219,6 +253,7 @@ class BranchValidate(Mutation):
 class BranchMerge(Mutation):
     class Arguments:
         data = BranchNameInput(required=True)
+        context = ContextInput(required=False)
         wait_until_completion = Boolean(required=False)
 
     ok = Boolean()
@@ -227,23 +262,34 @@ 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,
+        context: ContextInput | None = None,
+        wait_until_completion: bool = True,
     ) -> Self:
         branch_name = data["name"]
         task: dict | None = None
+        graphql_context: GraphqlContext = info.context
+        await apply_external_context(graphql_context=graphql_context, context_input=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,8 +9,11 @@ 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.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
 from infrahub.log import get_log_data
 from infrahub.worker import WORKER_IDENTITY
 
@@ -30,6 +33,7 @@ class InfrahubComputedAttributeUpdateInput(InputObjectType):
 class UpdateComputedAttribute(Mutation):
     class Arguments:
         data = InfrahubComputedAttributeUpdateInput(required=True)
+        context = ContextInput(required=False)
 
     ok = Boolean()
 
@@ -40,9 +44,12 @@ class UpdateComputedAttribute(Mutation):
         _: dict,
         info: GraphQLResolveInfo,
         data: InfrahubComputedAttributeUpdateInput,
+        context: ContextInput | None = None,
     ) -> 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 +57,21 @@ 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,
             )
         )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
 
         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 +89,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

@@ -1,15 +1,22 @@
 from typing import TYPE_CHECKING
 
-from graphene import Boolean, DateTime, InputObjectType, Mutation, String
+from graphene import Boolean, DateTime, Field, InputObjectType, Mutation, String
 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.database import retry_db_transaction
+from infrahub.core.diff.repository.repository import DiffRepository
+from infrahub.core.timestamp import Timestamp
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.exceptions import ValidationError
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
 from infrahub.workflows.catalogue import DIFF_UPDATE
 
+from ..types.task import TaskInfo
+
 if TYPE_CHECKING:
     from ..initialization import GraphqlContext
 
@@ -19,34 +26,64 @@ class DiffUpdateInput(InputObjectType):
     name = String(required=False)
     from_time = DateTime(required=False)
     to_time = DateTime(required=False)
-    wait_for_completion = Boolean(required=False)
+    wait_for_completion = Boolean(required=False, deprecation_reason="Please use `wait_until_completion` instead")
 
 
 class DiffUpdateMutation(Mutation):
     class Arguments:
         data = DiffUpdateInput(required=True)
+        context = ContextInput(required=False)
+        wait_until_completion = Boolean(required=False)
 
     ok = Boolean()
+    task = Field(TaskInfo, required=False)
 
     @classmethod
-    @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
+        context: ContextInput | None = None,
+        wait_until_completion: bool = False,
+    ) -> dict[str, bool | dict[str, str]]:
+        graphql_context: GraphqlContext = info.context
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        if data.wait_for_completion is True:
+            wait_until_completion = True
 
         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_metadatas = 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_metadatas:
+            metadata = existing_diffs_metadatas[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 wait_until_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 +101,10 @@ 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:
+            workflow = await graphql_context.service.workflow.submit_workflow(
+                workflow=DIFF_UPDATE, parameters={"model": model}
+            )
+            return {"ok": True, "task": {"id": str(workflow.id)}}
 
         return {"ok": True}

infrahub/graphql/mutations/diff_conflict.py

@@ -11,7 +11,9 @@ from infrahub.core.manager import NodeManager
 from infrahub.database import retry_db_transaction
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.exceptions import ProcessingError
+from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.enums import ConflictSelection as GraphQlConflictSelection
+from infrahub.graphql.types.context import ContextInput
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -19,9 +21,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(
@@ -32,6 +31,7 @@ class ResolveDiffConflictInput(InputObjectType):
 class ResolveDiffConflict(Mutation):
     class Arguments:
         data = ResolveDiffConflictInput(required=True)
+        context = ContextInput(required=False)
 
     ok = Boolean()
 
@@ -39,14 +39,18 @@ class ResolveDiffConflict(Mutation):
     @retry_db_transaction(name="resolve_diff_conflict")
     async def mutate(
         cls,
-        root: dict,
+        root: dict,  # noqa: ARG003
         info: GraphQLResolveInfo,
         data: ResolveDiffConflictInput,
+        context: ContextInput | None = None,
     ) -> ResolveDiffConflict:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
+        await apply_external_context(graphql_context=graphql_context, context_input=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 +59,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 +73,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/generator.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from graphene import Boolean, Field, InputField, InputObjectType, List, Mutation, NonNull, String
+
+from infrahub.core.manager import NodeManager
+from infrahub.generators.models import ProposedChangeGeneratorDefinition, RequestGeneratorDefinitionRun
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
+from infrahub.graphql.types.task import TaskInfo
+from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from ..initialization import GraphqlContext
+
+
+class GeneratorDefinitionRequestRunInput(InputObjectType):
+    id = InputField(String(required=True), description="ID of the generator definition to run")
+    nodes = InputField(List(of_type=NonNull(String)), description="ID list of targets to run the generator for")
+
+
+class GeneratorDefinitionRequestRun(Mutation):
+    class Arguments:
+        data = GeneratorDefinitionRequestRunInput(required=True)
+        context = ContextInput(required=False)
+        wait_until_completion = Boolean(required=False)
+
+    ok = Boolean()
+    task = Field(TaskInfo, required=False)
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: GeneratorDefinitionRequestRunInput,
+        context: ContextInput | None = None,
+        wait_until_completion: bool = True,
+    ) -> GeneratorDefinitionRequestRun:
+        graphql_context: GraphqlContext = info.context
+        db = graphql_context.db
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+        generator_definition = await NodeManager.get_one(
+            id=str(data.id), db=db, branch=graphql_context.branch, prefetch_relationships=True, raise_on_error=True
+        )
+        query = await generator_definition.query.get_peer(db=db)
+        repository = await generator_definition.repository.get_peer(db=db)
+        group = await generator_definition.targets.get_peer(db=db)
+
+        request_model = RequestGeneratorDefinitionRun(
+            generator_definition=ProposedChangeGeneratorDefinition(
+                definition_id=generator_definition.id,
+                definition_name=generator_definition.name.value,
+                class_name=generator_definition.class_name.value,
+                file_path=generator_definition.file_path.value,
+                query_name=query.name.value,
+                query_models=query.models.value,
+                repository_id=repository.id,
+                parameters=generator_definition.parameters.value,
+                group_id=group.id,
+                convert_query_response=generator_definition.convert_query_response.value or False,
+            ),
+            branch=graphql_context.branch.name,
+            target_members=data.get("nodes", []),
+        )
+
+        if not wait_until_completion:
+            workflow = await graphql_context.active_service.workflow.submit_workflow(
+                workflow=REQUEST_GENERATOR_DEFINITION_RUN,
+                context=graphql_context.get_context(),
+                parameters={"model": request_model},
+            )
+            return cls(ok=True, task={"id": workflow.id})
+
+        await graphql_context.active_service.workflow.execute_workflow(
+            workflow=REQUEST_GENERATOR_DEFINITION_RUN,
+            context=graphql_context.get_context(),
+            parameters={"model": request_model},
+        )
+        return cls(ok=True)