incrementalDelivery: remove singleResult wrapper

Replicates graphql/graphql-js@364cd71

Author: Cito

docs/conf.py

@@ -141,7 +141,7 @@
 AsyncPayloadRecord
 AwaitableOrValue
 EnterLeaveVisitor
-ExperimentalExecuteIncrementallyResults
+ExperimentalIncrementalExecutionResults
 FormattedSourceLocation
 GraphQLAbstractType
 GraphQLErrorExtensions
@@ -154,8 +154,7 @@
 graphql.execution.map_async_iterable.MapAsyncIterable
 graphql.execution.Middleware
 graphql.execution.execute.DeferredFragmentRecord
-graphql.execution.execute.ExperimentalExecuteMultipleResults
-graphql.execution.execute.ExperimentalExecuteSingleResult
+graphql.execution.execute.ExperimentalIncrementalExecutionResults
 graphql.execution.execute.StreamArguments
 graphql.execution.execute.StreamRecord
 graphql.language.lexer.EscapeSequence

docs/modules/execution.rst

@@ -24,7 +24,7 @@ Execution
 .. autoclass:: FormattedExecutionResult
    :no-inherited-members:
 
-.. autoclass:: ExperimentalExecuteIncrementallyResults
+.. autoclass:: ExperimentalIncrementalExecutionResults
 
 .. autoclass:: InitialIncrementalExecutionResult
 

src/graphql/__init__.py

@@ -435,7 +435,18 @@
     # Types
     ExecutionContext,
     ExecutionResult,
+    ExperimentalIncrementalExecutionResults,
+    InitialIncrementalExecutionResult,
+    SubsequentIncrementalExecutionResult,
+    IncrementalDeferResult,
+    IncrementalStreamResult,
+    IncrementalResult,
     FormattedExecutionResult,
+    FormattedInitialIncrementalExecutionResult,
+    FormattedSubsequentIncrementalExecutionResult,
+    FormattedIncrementalDeferResult,
+    FormattedIncrementalStreamResult,
+    FormattedIncrementalResult,
     # Subscription
     subscribe,
     create_source_event_stream,
@@ -702,7 +713,18 @@
     "get_variable_values",
     "ExecutionContext",
     "ExecutionResult",
+    "ExperimentalIncrementalExecutionResults",
+    "InitialIncrementalExecutionResult",
+    "SubsequentIncrementalExecutionResult",
+    "IncrementalDeferResult",
+    "IncrementalStreamResult",
+    "IncrementalResult",
     "FormattedExecutionResult",
+    "FormattedInitialIncrementalExecutionResult",
+    "FormattedSubsequentIncrementalExecutionResult",
+    "FormattedIncrementalDeferResult",
+    "FormattedIncrementalStreamResult",
+    "FormattedIncrementalResult",
     "Middleware",
     "MiddlewareManager",
     "subscribe",

src/graphql/execution/__init__.py

@@ -16,9 +16,7 @@
     experimental_subscribe_incrementally,
     ExecutionContext,
     ExecutionResult,
-    ExperimentalExecuteIncrementallyResults,
-    ExperimentalExecuteMultipleResults,
-    ExperimentalExecuteSingleResult,
+    ExperimentalIncrementalExecutionResults,
     InitialIncrementalExecutionResult,
     SubsequentIncrementalExecutionResult,
     IncrementalDeferResult,
@@ -48,9 +46,7 @@
     "experimental_subscribe_incrementally",
     "ExecutionContext",
     "ExecutionResult",
-    "ExperimentalExecuteIncrementallyResults",
-    "ExperimentalExecuteMultipleResults",
-    "ExperimentalExecuteSingleResult",
+    "ExperimentalIncrementalExecutionResults",
     "InitialIncrementalExecutionResult",
     "SubsequentIncrementalExecutionResult",
     "IncrementalDeferResult",

src/graphql/execution/execute.py

@@ -104,9 +104,7 @@ async def anext(iterator: AsyncIterator) -> Any:
     "StreamRecord",
     "ExecutionResult",
     "ExecutionContext",
-    "ExperimentalExecuteIncrementallyResults",
-    "ExperimentalExecuteMultipleResults",
-    "ExperimentalExecuteSingleResult",
+    "ExperimentalIncrementalExecutionResults",
     "FormattedExecutionResult",
     "FormattedIncrementalDeferResult",
     "FormattedIncrementalResult",
@@ -600,24 +598,13 @@ class StreamArguments(NamedTuple):
     label: Optional[str]
 
 
-class ExperimentalExecuteSingleResult(NamedTuple):
-    """Execution result when retrieved at once."""
-
-    single_result: ExecutionResult
-
-
-class ExperimentalExecuteMultipleResults(NamedTuple):
+class ExperimentalIncrementalExecutionResults(NamedTuple):
     """Execution results when retrieved incrementally."""
 
     initial_result: InitialIncrementalExecutionResult
     subsequent_results: AsyncGenerator[SubsequentIncrementalExecutionResult, None]
 
 
-ExperimentalExecuteIncrementallyResults = Union[
-    ExperimentalExecuteSingleResult, ExperimentalExecuteMultipleResults
-]
-
-
 Middleware: TypeAlias = Optional[Union[Tuple, List, MiddlewareManager]]
 
 
@@ -2012,15 +1999,15 @@ def execute(
         execution_context_class,
         is_awaitable,
     )
-    if isinstance(result, ExperimentalExecuteSingleResult):
-        return result.single_result
-    if isinstance(result, ExperimentalExecuteMultipleResults):
+    if isinstance(result, ExecutionResult):
+        return result
+    if isinstance(result, ExperimentalIncrementalExecutionResults):
         raise GraphQLError(UNEXPECTED_MULTIPLE_PAYLOADS)
 
     async def await_result() -> Any:
         awaited_result = await result  # type: ignore
-        if isinstance(awaited_result, ExperimentalExecuteSingleResult):
-            return awaited_result.single_result
+        if isinstance(awaited_result, ExecutionResult):
+            return awaited_result
         return ExecutionResult(
             None, errors=[GraphQLError(UNEXPECTED_MULTIPLE_PAYLOADS)]
         )
@@ -2041,16 +2028,16 @@ def experimental_execute_incrementally(
     middleware: Optional[Middleware] = None,
     execution_context_class: Optional[Type[ExecutionContext]] = None,
     is_awaitable: Optional[Callable[[Any], bool]] = None,
-) -> AwaitableOrValue[ExperimentalExecuteIncrementallyResults]:
+) -> AwaitableOrValue[Union[ExecutionResult, ExperimentalIncrementalExecutionResults]]:
     """Execute GraphQL operation incrementally (internal implementation).
 
      Implements the "Executing requests" section of the GraphQL specification,
      including `@defer` and `@stream` as proposed in
      https://github.com/graphql/graphql-spec/pull/742
 
-    This function returns an awaitable of an ExperimentalExecuteIncrementallyResults
-    object. This object either contains a single ExecutionResult as
-    `single_result`, or an `initial_result` and a stream of `subsequent_results`.
+    This function returns an awaitable that is either a single ExecutionResult or
+    an ExperimentalIncrementalExecutionResults object, containing an `initialResult`
+    and a stream of `subsequent_results`.
     """
     if execution_context_class is None:
         execution_context_class = ExecutionContext
@@ -2073,16 +2060,14 @@ def experimental_execute_incrementally(
 
     # Return early errors if execution context failed.
     if isinstance(context, list):
-        return ExperimentalExecuteSingleResult(
-            single_result=ExecutionResult(None, errors=context)
-        )
+        return ExecutionResult(None, errors=context)
 
     return execute_impl(context)
 
 
 def execute_impl(
     context: ExecutionContext,
-) -> AwaitableOrValue[ExperimentalExecuteIncrementallyResults]:
+) -> AwaitableOrValue[Union[ExecutionResult, ExperimentalIncrementalExecutionResults]]:
     """Execute GraphQL operation (internal implementation)."""
     # Return a possible coroutine object that will eventually yield the data described
     # by the "Response" section of the GraphQL specification.
@@ -2108,39 +2093,35 @@ async def await_result() -> Any:
                         await result, errors  # type: ignore
                     )
                     if context.subsequent_payloads:
-                        return ExperimentalExecuteMultipleResults(
+                        return ExperimentalIncrementalExecutionResults(
                             initial_result=InitialIncrementalExecutionResult(
                                 initial_result.data,
                                 initial_result.errors,
                                 has_next=True,
                             ),
                             subsequent_results=context.yield_subsequent_payloads(),
                         )
-                    return ExperimentalExecuteSingleResult(single_result=initial_result)
+                    return initial_result
                 except GraphQLError as error:
                     errors.append(error)
-                    return ExperimentalExecuteSingleResult(
-                        single_result=build_response(None, errors)
-                    )
+                    return build_response(None, errors)
 
             return await_result()
 
         initial_result = build_response(result, errors)  # type: ignore
         if context.subsequent_payloads:
-            return ExperimentalExecuteMultipleResults(
+            return ExperimentalIncrementalExecutionResults(
                 initial_result=InitialIncrementalExecutionResult(
                     initial_result.data,
                     initial_result.errors,
                     has_next=True,
                 ),
                 subsequent_results=context.yield_subsequent_payloads(),
             )
-        return ExperimentalExecuteSingleResult(single_result=initial_result)
+        return initial_result
     except GraphQLError as error:
         errors.append(error)
-        return ExperimentalExecuteSingleResult(
-            single_result=build_response(None, errors)
-        )
+        return build_response(None, errors)
 
 
 def assume_not_awaitable(_value: Any) -> bool:
@@ -2192,12 +2173,14 @@ def execute_sync(
     )
 
     # Assert that the execution was synchronous.
-    if isawaitable(result) or isinstance(result, ExperimentalExecuteMultipleResults):
+    if isawaitable(result) or isinstance(
+        result, ExperimentalIncrementalExecutionResults
+    ):
         if isawaitable(result):
             ensure_future(cast(Awaitable[ExecutionResult], result)).cancel()
         raise RuntimeError("GraphQL execution failed to complete synchronously.")
 
-    return cast(ExperimentalExecuteSingleResult, result).single_result
+    return cast(ExecutionResult, result)
 
 
 def handle_field_error(
@@ -2489,7 +2472,9 @@ async def await_result() -> Any:
 
 
 async def ensure_async_iterable(
-    some_execution_result: ExperimentalExecuteIncrementallyResults,
+    some_execution_result: Union[
+        ExecutionResult, ExperimentalIncrementalExecutionResults
+    ],
 ) -> AsyncGenerator[
     Union[
         ExecutionResult,
@@ -2498,8 +2483,8 @@ async def ensure_async_iterable(
     ],
     None,
 ]:
-    if isinstance(some_execution_result, ExperimentalExecuteSingleResult):
-        yield some_execution_result.single_result
+    if isinstance(some_execution_result, ExecutionResult):
+        yield some_execution_result
     else:
         yield some_execution_result.initial_result
         async for result in some_execution_result.subsequent_results:

tests/execution/test_defer.py

@@ -6,8 +6,8 @@
 from graphql.error import GraphQLError
 from graphql.execution import (
     ExecutionContext,
-    ExperimentalExecuteMultipleResults,
-    ExperimentalExecuteSingleResult,
+    ExecutionResult,
+    ExperimentalIncrementalExecutionResults,
     IncrementalDeferResult,
     InitialIncrementalExecutionResult,
     SubsequentIncrementalExecutionResult,
@@ -93,14 +93,14 @@ async def resolve_null_async(_obj, _info) -> None:
 async def complete(document: DocumentNode, root_value: Any = None) -> Any:
     result = experimental_execute_incrementally(schema, document, root_value)
 
-    if isinstance(result, ExperimentalExecuteMultipleResults):
+    if isinstance(result, ExperimentalIncrementalExecutionResults):
         results: List[Any] = [result.initial_result.formatted]
         async for patch in result.subsequent_results:
             results.append(patch.formatted)
         return results
 
-    assert isinstance(result, ExperimentalExecuteSingleResult)
-    return result.single_result.formatted
+    assert isinstance(result, ExecutionResult)
+    return result.formatted
 
 
 def modified_args(args: Dict[str, Any], **modifications: Any) -> Dict[str, Any]:

tests/execution/test_mutations.py

@@ -4,7 +4,7 @@
 from pytest import mark
 
 from graphql.execution import (
-    ExperimentalExecuteMultipleResults,
+    ExperimentalIncrementalExecutionResults,
     execute,
     execute_sync,
     experimental_execute_incrementally,
@@ -234,7 +234,7 @@ async def mutation_fields_with_defer_do_not_block_next_mutation():
         )
 
         patches: List[Any] = []
-        assert isinstance(mutation_result, ExperimentalExecuteMultipleResults)
+        assert isinstance(mutation_result, ExperimentalIncrementalExecutionResults)
         patches.append(mutation_result.initial_result.formatted)
         async for patch in mutation_result.subsequent_results:
             patches.append(patch.formatted)
@@ -305,7 +305,7 @@ async def mutation_with_defer_is_not_executed_serially():
         )
 
         patches: List[Any] = []
-        assert isinstance(mutation_result, ExperimentalExecuteMultipleResults)
+        assert isinstance(mutation_result, ExperimentalIncrementalExecutionResults)
         patches.append(mutation_result.initial_result.formatted)
         async for patch in mutation_result.subsequent_results:
             patches.append(patch.formatted)