Experimental support for async iterables as list values (#123)

Author: Cito

src/graphql/execution/execute.py

@@ -3,6 +3,7 @@
 from inspect import isawaitable
 from typing import (
     Any,
+    AsyncIterable,
     Awaitable,
     Callable,
     Dict,
@@ -670,17 +671,31 @@ def complete_list_value(
         field_nodes: List[FieldNode],
         info: GraphQLResolveInfo,
         path: Path,
-        result: Iterable[Any],
+        result: Union[AsyncIterable[Any], Iterable[Any]],
     ) -> AwaitableOrValue[List[Any]]:
         """Complete a list value.
 
         Complete a list value by completing each item in the list with the inner type.
         """
         if not is_iterable(result):
+            # experimental: allow async iterables
+            if isinstance(result, AsyncIterable):
+                # noinspection PyShadowingNames
+                async def async_iterable_to_list(
+                    async_result: AsyncIterable[Any],
+                ) -> Any:
+                    sync_result = [item async for item in async_result]
+                    return self.complete_list_value(
+                        return_type, field_nodes, info, path, sync_result
+                    )
+
+                return async_iterable_to_list(result)
+
             raise GraphQLError(
                 "Expected Iterable, but did not find one for field"
                 f" '{info.parent_type.name}.{info.field_name}'."
             )
+        result = cast(Iterable[Any], result)
 
         # This is specified as a simple map, however we're optimizing the path where
         # the list contains no coroutine objects by avoiding creating another coroutine

tests/execution/test_lists.py

@@ -1,9 +1,10 @@
-from typing import Any
+from typing import cast, Any, Awaitable
 
 from pytest import mark
 
 from graphql.execution import execute, execute_sync, ExecutionResult
 from graphql.language import parse
+from graphql.pyutils import is_awaitable
 from graphql.utilities import build_schema
 
 
@@ -45,6 +46,24 @@ def list_field():
             None,
         )
 
+    def accepts_a_custom_iterable_as_a_list_value():
+        class ListField:
+            def __iter__(self):
+                self.last = "hello"
+                return self
+
+            def __next__(self):
+                last = self.last
+                if last == "stop":
+                    raise StopIteration
+                self.last = "world" if last == "hello" else "stop"
+                return last
+
+        assert _complete(ListField()) == (
+            {"listField": ["hello", "world"]},
+            None,
+        )
+
     def accepts_function_arguments_as_a_list_value():
         def get_args(*args):
             return args  # actually just a tuple, nothing special in Python
@@ -195,3 +214,46 @@ async def results_in_errors():
             None,
             errors,
         )
+
+
+def describe_experimental_execute_accepts_async_iterables_as_list_value():
+    async def _complete(list_field):
+        result = execute(
+            build_schema("type Query { listField: [String] }"),
+            parse("{ listField }"),
+            Data(list_field),
+        )
+        assert is_awaitable(result)
+        result = cast(Awaitable, result)
+        return await result
+
+    @mark.asyncio
+    async def accepts_an_async_generator_as_a_list_value():
+        async def list_field():
+            yield "one"
+            yield 2
+            yield True
+
+        assert await _complete(list_field()) == (
+            {"listField": ["one", "2", "true"]},
+            None,
+        )
+
+    @mark.asyncio
+    async def accepts_a_custom_async_iterable_as_a_list_value():
+        class ListField:
+            def __aiter__(self):
+                self.last = "hello"
+                return self
+
+            async def __anext__(self):
+                last = self.last
+                if last == "stop":
+                    raise StopAsyncIteration
+                self.last = "world" if last == "hello" else "stop"
+                return last
+
+        assert await _complete(ListField()) == (
+            {"listField": ["hello", "world"]},
+            None,
+        )