Use GraphQL-core version 3 instead of version 2

Also made some of the tests more robust.

Author: Cito

gql/client.py

@@ -1,11 +1,16 @@
 import asyncio
 from typing import Any, AsyncGenerator, Dict, Generator, Optional, Union, cast
 
-from graphql import build_ast_schema, build_client_schema, introspection_query, parse
-from graphql.execution import ExecutionResult
-from graphql.language.ast import Document
-from graphql.type import GraphQLSchema
-from graphql.validation import validate
+from graphql import (
+    DocumentNode,
+    ExecutionResult,
+    GraphQLSchema,
+    build_ast_schema,
+    build_client_schema,
+    get_introspection_query,
+    parse,
+    validate,
+)
 
 from .transport.async_transport import AsyncTransport
 from .transport.exceptions import TransportQueryError
@@ -32,7 +37,7 @@ def __init__(
             ), "Cant fetch the schema from transport if is already provided"
             if isinstance(transport, Transport):
                 # For sync transports, we fetch the schema directly
-                execution_result = transport.execute(parse(introspection_query))
+                execution_result = transport.execute(parse(get_introspection_query()))
                 execution_result = cast(ExecutionResult, execution_result)
                 introspection = execution_result.data
         if introspection:
@@ -72,11 +77,11 @@ def validate(self, document):
         if validation_errors:
             raise validation_errors[0]
 
-    async def execute_async(self, document: Document, *args, **kwargs) -> Dict:
+    async def execute_async(self, document: DocumentNode, *args, **kwargs) -> Dict:
         async with self as session:
             return await session.execute(document, *args, **kwargs)
 
-    def execute(self, document: Document, *args, **kwargs) -> Dict:
+    def execute(self, document: DocumentNode, *args, **kwargs) -> Dict:
         """Execute the provided document AST against the configured remote server.
 
         This function WILL BLOCK until the result is received from the server.
@@ -118,7 +123,7 @@ def execute(self, document: Document, *args, **kwargs) -> Dict:
             return result.data
 
     async def subscribe_async(
-        self, document: Document, *args, **kwargs
+        self, document: DocumentNode, *args, **kwargs
     ) -> AsyncGenerator[Dict, None]:
         async with self as session:
 
@@ -130,7 +135,7 @@ async def subscribe_async(
                 yield result
 
     def subscribe(
-        self, document: Document, *args, **kwargs
+        self, document: DocumentNode, *args, **kwargs
     ) -> Generator[Dict, None, None]:
         """Execute a GraphQL subscription with a python generator.
 
@@ -193,7 +198,7 @@ class ClientSession:
     def __init__(self, client: Client):
         self.client = client
 
-    async def validate(self, document: Document):
+    async def validate(self, document: DocumentNode):
         """ Fetch schema from transport if needed and validate document if schema is present """
 
         # Get schema from transport if needed
@@ -205,7 +210,7 @@ async def validate(self, document: Document):
             self.client.validate(document)
 
     async def subscribe(
-        self, document: Document, *args, **kwargs
+        self, document: DocumentNode, *args, **kwargs
     ) -> AsyncGenerator[Dict, None]:
 
         # Fetch schema from transport if needed and validate document if schema is present
@@ -227,7 +232,7 @@ async def subscribe(
             elif result.data is not None:
                 yield result.data
 
-    async def execute(self, document: Document, *args, **kwargs) -> Dict:
+    async def execute(self, document: DocumentNode, *args, **kwargs) -> Dict:
 
         # Fetch schema from transport if needed and validate document if schema is present
         await self.validate(document)
@@ -245,7 +250,9 @@ async def execute(self, document: Document, *args, **kwargs) -> Dict:
         return result.data
 
     async def fetch_schema(self) -> None:
-        execution_result = await self.transport.execute(parse(introspection_query))
+        execution_result = await self.transport.execute(
+            parse(get_introspection_query())
+        )
         self.client.introspection = execution_result.data
         self.client.schema = build_client_schema(self.client.introspection)
 

gql/dsl.py

@@ -1,16 +1,27 @@
 from functools import partial
 
 import six
-from graphql.language import ast
-from graphql.language.printer import print_ast
-from graphql.type import (
+from graphql import (
+    ArgumentNode,
+    DocumentNode,
+    EnumValueNode,
+    FieldNode,
     GraphQLEnumType,
-    GraphQLInputObjectField,
+    GraphQLInputField,
     GraphQLInputObjectType,
     GraphQLList,
     GraphQLNonNull,
+    ListValueNode,
+    NameNode,
+    ObjectFieldNode,
+    ObjectValueNode,
+    OperationDefinitionNode,
+    OperationType,
+    SelectionSetNode,
+    ast_from_value,
+    print_ast,
 )
-from graphql.utils.ast_from_value import ast_from_value
+from graphql.pyutils import FrozenList
 
 from .utils import to_camel_case
 
@@ -43,8 +54,8 @@ def execute(self, document):
 
 
 class DSLType(object):
-    def __init__(self, type):
-        self.type = type
+    def __init__(self, type_):
+        self.type = type_
 
     def __getattr__(self, name):
         formatted_name, field_def = self.get_field(name)
@@ -72,30 +83,40 @@ def selections(*fields):
 class DSLField(object):
     def __init__(self, name, field):
         self.field = field
-        self.ast_field = ast.Field(name=ast.Name(value=name), arguments=[])
+        self.ast_field = FieldNode(name=NameNode(value=name), arguments=FrozenList())
         self.selection_set = None
 
     def select(self, *fields):
-        if not self.ast_field.selection_set:
-            self.ast_field.selection_set = ast.SelectionSet(selections=[])
-        self.ast_field.selection_set.selections.extend(selections(*fields))
+        selection_set = self.ast_field.selection_set
+        added_selections = selections(*fields)
+        if selection_set:
+            selection_set.selections = FrozenList(
+                selection_set.selections + added_selections
+            )
+        else:
+            self.ast_field.selection_set = SelectionSetNode(
+                selections=FrozenList(added_selections)
+            )
         return self
 
     def __call__(self, **kwargs):
         return self.args(**kwargs)
 
     def alias(self, alias):
-        self.ast_field.alias = ast.Name(value=alias)
+        self.ast_field.alias = NameNode(value=alias)
         return self
 
     def args(self, **kwargs):
+        added_args = []
         for name, value in kwargs.items():
             arg = self.field.args.get(name)
             arg_type_serializer = get_arg_serializer(arg.type)
             serialized_value = arg_type_serializer(value)
-            self.ast_field.arguments.append(
-                ast.Argument(name=ast.Name(value=name), value=serialized_value)
+            added_args.append(
+                ArgumentNode(name=NameNode(value=name), value=serialized_value)
             )
+        ast_field = self.ast_field
+        ast_field.arguments = FrozenList(ast_field.arguments + added_args)
         return self
 
     @property
@@ -116,11 +137,13 @@ def selection_field(field):
 def query(*fields, **kwargs):
     if "operation" not in kwargs:
         kwargs["operation"] = "query"
-    return ast.Document(
+    return DocumentNode(
         definitions=[
-            ast.OperationDefinition(
-                operation=kwargs["operation"],
-                selection_set=ast.SelectionSet(selections=list(selections(*fields))),
+            OperationDefinitionNode(
+                operation=OperationType(kwargs["operation"]),
+                selection_set=SelectionSetNode(
+                    selections=FrozenList(selections(*fields))
+                ),
             )
         ]
     )
@@ -130,25 +153,25 @@ def serialize_list(serializer, list_values):
     assert isinstance(list_values, Iterable), 'Expected iterable, received "{}"'.format(
         repr(list_values)
     )
-    return ast.ListValue(values=[serializer(v) for v in list_values])
+    return ListValueNode(values=FrozenList(serializer(v) for v in list_values))
 
 
 def get_arg_serializer(arg_type):
     if isinstance(arg_type, GraphQLNonNull):
         return get_arg_serializer(arg_type.of_type)
-    if isinstance(arg_type, GraphQLInputObjectField):
+    if isinstance(arg_type, GraphQLInputField):
         return get_arg_serializer(arg_type.type)
     if isinstance(arg_type, GraphQLInputObjectType):
         serializers = {k: get_arg_serializer(v) for k, v in arg_type.fields.items()}
-        return lambda value: ast.ObjectValue(
-            fields=[
-                ast.ObjectField(ast.Name(k), serializers[k](v))
+        return lambda value: ObjectValueNode(
+            fields=FrozenList(
+                ObjectFieldNode(name=NameNode(value=k), value=serializers[k](v))
                 for k, v in value.items()
-            ]
+            )
         )
     if isinstance(arg_type, GraphQLList):
         inner_serializer = get_arg_serializer(arg_type.of_type)
         return partial(serialize_list, inner_serializer)
     if isinstance(arg_type, GraphQLEnumType):
-        return lambda value: ast.EnumValue(value=arg_type.serialize(value))
-    return lambda value: ast_from_value(arg_type.serialize(value))
+        return lambda value: EnumValueNode(value=arg_type.serialize(value))
+    return lambda value: ast_from_value(arg_type.serialize(value), arg_type)

gql/transport/aiohttp.py

@@ -6,9 +6,7 @@
 from aiohttp.client_reqrep import Fingerprint
 from aiohttp.helpers import BasicAuth
 from aiohttp.typedefs import LooseCookies, LooseHeaders
-from graphql.execution import ExecutionResult
-from graphql.language.ast import Document
-from graphql.language.printer import print_ast
+from graphql import DocumentNode, ExecutionResult, print_ast
 
 from .async_transport import AsyncTransport
 from .exceptions import (
@@ -92,7 +90,7 @@ async def close(self) -> None:
 
     async def execute(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
         extra_args: Dict[str, Any] = {},
@@ -143,7 +141,7 @@ async def execute(
 
     def subscribe(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
     ) -> AsyncGenerator[ExecutionResult, None]:

gql/transport/async_transport.py

@@ -3,7 +3,7 @@
 
 import six
 from graphql.execution import ExecutionResult
-from graphql.language.ast import Document
+from graphql.language.ast import DocumentNode
 
 
 @six.add_metaclass(abc.ABCMeta)
@@ -27,7 +27,7 @@ async def close(self):
     @abc.abstractmethod
     async def execute(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
     ) -> ExecutionResult:
@@ -40,7 +40,7 @@ async def execute(
     @abc.abstractmethod
     def subscribe(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
     ) -> AsyncGenerator[ExecutionResult, None]:

gql/transport/local_schema.py

@@ -1,6 +1,6 @@
 from graphql import GraphQLSchema
 from graphql.execution import ExecutionResult, execute
-from graphql.language.ast import Document
+from graphql.language.ast import DocumentNode
 
 from gql.transport import Transport
 
@@ -17,7 +17,7 @@ def __init__(
         """
         self.schema = schema
 
-    def execute(self, document: Document, *args, **kwargs) -> ExecutionResult:
+    def execute(self, document: DocumentNode, *args, **kwargs) -> ExecutionResult:
         """Execute the given document against the configured local schema.
 
         :param document: GraphQL query as AST Node object.

gql/transport/requests.py

@@ -1,9 +1,7 @@
 from typing import Any, Dict, Optional, Union
 
 import requests
-from graphql.execution import ExecutionResult
-from graphql.language.ast import Document
-from graphql.language.printer import print_ast
+from graphql import DocumentNode, ExecutionResult, print_ast
 from requests.adapters import HTTPAdapter, Retry
 from requests.auth import AuthBase
 from requests.cookies import RequestsCookieJar
@@ -76,7 +74,7 @@ def __init__(
 
     def execute(  # type: ignore
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, Any]] = None,
         timeout: Optional[int] = None,
     ) -> ExecutionResult:

gql/transport/transport.py

@@ -2,13 +2,13 @@
 
 import six
 from graphql.execution import ExecutionResult
-from graphql.language.ast import Document
+from graphql.language.ast import DocumentNode
 
 
 @six.add_metaclass(abc.ABCMeta)
 class Transport:
     @abc.abstractmethod
-    def execute(self, document: Document, *args, **kwargs) -> ExecutionResult:
+    def execute(self, document: DocumentNode, *args, **kwargs) -> ExecutionResult:
         """Execute the provided document AST for either a remote or local GraphQL Schema.
 
         :param document: GraphQL query as AST Node or Document object.

gql/transport/websockets.py

@@ -5,9 +5,7 @@
 from typing import Any, AsyncGenerator, Dict, Optional, Tuple, Union, cast
 
 import websockets
-from graphql.execution import ExecutionResult
-from graphql.language.ast import Document
-from graphql.language.printer import print_ast
+from graphql import DocumentNode, ExecutionResult, print_ast
 from websockets.client import WebSocketClientProtocol
 from websockets.exceptions import ConnectionClosed
 from websockets.http import HeadersLike
@@ -217,7 +215,7 @@ async def _send_connection_terminate_message(self) -> None:
 
     async def _send_query(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
     ) -> int:
@@ -361,7 +359,7 @@ async def _receive_data_loop(self) -> None:
 
     async def subscribe(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
         send_stop: Optional[bool] = True,
@@ -419,7 +417,7 @@ async def subscribe(
 
     async def execute(
         self,
-        document: Document,
+        document: DocumentNode,
         variable_values: Optional[Dict[str, str]] = None,
         operation_name: Optional[str] = None,
     ) -> ExecutionResult: