Added 'execute_sync': synchronous version of execute.

Replicates graphql/graphql-js@8f3d09b

Author: Cito

Diff for: src/graphql/__init__.py

@@ -262,6 +262,7 @@
 # Execute GraphQL documents.
 from .execution import (
     execute,
+    execute_sync,
     default_field_resolver,
     default_type_resolver,
     get_directive_values,
@@ -611,6 +612,7 @@
     "EnumTypeExtensionNode",
     "InputObjectTypeExtensionNode",
     "execute",
+    "execute_sync",
     "default_field_resolver",
     "default_type_resolver",
     "get_directive_values",

Diff for: src/graphql/execution/__init__.py

@@ -6,6 +6,7 @@
 
 from .execute import (
     execute,
+    execute_sync,
     default_field_resolver,
     default_type_resolver,
     ExecutionContext,
@@ -19,6 +20,7 @@
 
 __all__ = [
     "execute",
+    "execute_sync",
     "default_field_resolver",
     "default_type_resolver",
     "ExecutionContext",

Diff for: src/graphql/execution/execute.py

@@ -1,5 +1,6 @@
-from asyncio import gather
+from asyncio import ensure_future, gather
 from collections.abc import Mapping
+from inspect import isawaitable
 from typing import (
     Any,
     Awaitable,
@@ -68,6 +69,7 @@
     "default_field_resolver",
     "default_type_resolver",
     "execute",
+    "execute_sync",
     "get_field_def",
     "ExecutionResult",
     "ExecutionContext",
@@ -1094,6 +1096,61 @@ def execute(
     return exe_context.build_response(data)
 
 
+def assume_not_awaitable(_value: Any) -> bool:
+    """Replacement for isawaitable if everything is assumed to be synchronous."""
+    return False
+
+
+def execute_sync(
+    schema: GraphQLSchema,
+    document: DocumentNode,
+    root_value: Any = None,
+    context_value: Any = None,
+    variable_values: Optional[Dict[str, Any]] = None,
+    operation_name: Optional[str] = None,
+    field_resolver: Optional[GraphQLFieldResolver] = None,
+    type_resolver: Optional[GraphQLTypeResolver] = None,
+    middleware: Optional[Middleware] = None,
+    execution_context_class: Optional[Type["ExecutionContext"]] = None,
+    check_sync: bool = False,
+) -> ExecutionResult:
+    """Execute a GraphQL operation synchronously.
+
+    Also implements the "Evaluating requests" section of the GraphQL specification.
+
+    However, it guarantees to complete synchronously (or throw an error) assuming
+    that all field resolvers are also synchronous.
+
+    Set check_sync to True to still run checks that no awaitable values are returned.
+    """
+    is_awaitable = (
+        check_sync
+        if callable(check_sync)
+        else (None if check_sync else assume_not_awaitable)
+    )
+
+    result = execute(
+        schema,
+        document,
+        root_value,
+        context_value,
+        variable_values,
+        operation_name,
+        field_resolver,
+        type_resolver,
+        middleware,
+        execution_context_class,
+        is_awaitable,
+    )
+
+    # Assert that the execution was synchronous.
+    if isawaitable(result):
+        ensure_future(cast(Awaitable[ExecutionResult], result)).cancel()
+        raise RuntimeError("GraphQL execution failed to complete synchronously.")
+
+    return cast(ExecutionResult, result)
+
+
 def assert_valid_execution_arguments(
     schema: GraphQLSchema,
     document: DocumentNode,

Diff for: src/graphql/utilities/introspection_from_schema.py

@@ -32,9 +32,9 @@ def introspection_from_schema(
         )
     )
 
-    from ..execution.execute import execute, ExecutionResult
+    from ..execution.execute import execute_sync, ExecutionResult
 
-    result = execute(schema, document)
+    result = execute_sync(schema, document)
     if not isinstance(result, ExecutionResult):  # pragma: no cover
         raise RuntimeError("Introspection cannot be executed")
     if result.errors:  # pragma: no cover

Diff for: tests/benchmarks/test_introspection_from_schema.py

@@ -1,4 +1,4 @@
-from graphql import build_schema, parse, execute
+from graphql import build_schema, parse, execute_sync
 from graphql.utilities import get_introspection_query
 
 from ..fixtures import big_schema_sdl  # noqa: F401
@@ -7,5 +7,5 @@
 def test_execute_introspection_query(benchmark, big_schema_sdl):  # noqa: F811
     schema = build_schema(big_schema_sdl, assume_valid=True)
     document = parse(get_introspection_query())
-    result = benchmark(lambda: execute(schema=schema, document=document))
+    result = benchmark(lambda: execute_sync(schema=schema, document=document))
     assert result.errors is None

Diff for: tests/execution/test_abstract.py

@@ -1,7 +1,8 @@
 from typing import NamedTuple
 
-from graphql import graphql_sync
 from graphql.error import format_error
+from graphql.execution import execute_sync
+from graphql.language import parse
 from graphql.type import (
     GraphQLBoolean,
     GraphQLField,
@@ -89,7 +90,8 @@ def is_type_of_used_to_resolve_runtime_type_for_interface():
             types=[CatType, DogType],
         )
 
-        query = """
+        document = parse(
+            """
             {
               pets {
                 name
@@ -102,8 +104,9 @@ def is_type_of_used_to_resolve_runtime_type_for_interface():
               }
             }
             """
+        )
 
-        result = graphql_sync(schema, query)
+        result = execute_sync(schema, document)
         assert result == (
             {
                 "pets": [
@@ -150,7 +153,8 @@ def is_type_of_used_to_resolve_runtime_type_for_union():
             )
         )
 
-        query = """
+        document = parse(
+            """
             {
               pets {
                 ... on Dog {
@@ -164,8 +168,9 @@ def is_type_of_used_to_resolve_runtime_type_for_union():
               }
             }
             """
+        )
 
-        result = graphql_sync(schema, query)
+        result = execute_sync(schema, document)
         assert result == (
             {
                 "pets": [
@@ -226,7 +231,8 @@ def resolve_type_on_interface_yields_useful_error():
             types=[CatType, DogType],
         )
 
-        query = """
+        document = parse(
+            """
             {
               pets {
                 name
@@ -239,8 +245,9 @@ def resolve_type_on_interface_yields_useful_error():
               }
             }
             """
+        )
 
-        result = graphql_sync(schema, query)
+        result = execute_sync(schema, document)
         assert result.data == {
             "pets": [
                 {"name": "Odie", "woofs": True},
@@ -301,7 +308,8 @@ def resolve_type_on_union_yields_useful_error():
             )
         )
 
-        query = """
+        document = parse(
+            """
             {
               pets {
                 ... on Dog {
@@ -315,8 +323,9 @@ def resolve_type_on_union_yields_useful_error():
               }
             }
             """
+        )
 
-        result = graphql_sync(schema, query)
+        result = execute_sync(schema, document)
         assert result.data == {
             "pets": [
                 {"name": "Odie", "woofs": True},
@@ -355,7 +364,8 @@ def returning_invalid_value_from_resolve_type_yields_useful_error():
             types=[foo_object],
         )
 
-        result = graphql_sync(schema, "{ foo { bar } }")
+        document = parse("{ foo { bar } }")
+        result = execute_sync(schema, document)
 
         assert result == (
             {"foo": None},
@@ -391,7 +401,8 @@ def missing_both_resolve_type_and_is_type_of_yields_useful_error():
             types=[foo_object],
         )
 
-        result = graphql_sync(schema, "{ foo { bar } }")
+        document = parse("{ foo { bar } }")
+        result = execute_sync(schema, document)
 
         assert result == (
             {"foo": None},
@@ -446,7 +457,8 @@ def resolve_type_allows_resolving_with_type_name():
             types=[CatType, DogType],
         )
 
-        query = """
+        document = parse(
+            """
             {
               pets {
                 name
@@ -458,8 +470,9 @@ def resolve_type_allows_resolving_with_type_name():
                 }
               }
             }"""
+        )
 
-        result = graphql_sync(schema, query)
+        result = execute_sync(schema, document)
         assert result == (
             {
                 "pets": [

Diff for: tests/execution/test_directives.py

@@ -1,6 +1,5 @@
-from graphql.execution import execute, ExecutionResult
+from graphql.execution import execute_sync, ExecutionResult
 from graphql.language import parse
-from graphql.pyutils import AwaitableOrValue
 from graphql.type import GraphQLObjectType, GraphQLField, GraphQLSchema, GraphQLString
 
 schema = GraphQLSchema(
@@ -19,9 +18,9 @@ def b(self, *_args):
         return "b"
 
 
-def execute_test_query(query: str) -> AwaitableOrValue[ExecutionResult]:
+def execute_test_query(query: str) -> ExecutionResult:
     document = parse(query)
-    return execute(schema, document, RootValue())
+    return execute_sync(schema, document, RootValue())
 
 
 def describe_execute_handles_directives():