Bring node subpackage up to date

Also start using mypy and adding type hints.

Author: Cito

.travis.yml

@@ -2,7 +2,7 @@ language: python
 
 matrix:
   include:
-    - env: TOXENV=flake8
+    - env: TOXENV=flake8,mypy
       python: 3.7
       dist: xenial
       sudo: true

poetry.lock

@@ -37,6 +37,7 @@ pytest-cov = "^2.7"
 pyyaml = "^5.1"
 black = ">=19.3b0"
 flake8 = "^3.7"
+mypy = ">=0.711"
 codecov = "^2"
 check-manifest = ">=0.39"
 tox = "^3.13"

pyproject.toml

@@ -32,5 +32,8 @@
     python_requires='>=3.6,<4',
     packages=find_packages('src'),
     package_dir={'': 'src'},
+    # PEP-561: https://www.python.org/dev/peps/pep-0561/
+    package_data={"graphql_relay": ["py.typed"]},
+    include_package_data=True,
     zip_safe=False,
 )

setup.py

@@ -1,3 +1,5 @@
+from typing import Any, Callable, NamedTuple
+
 from graphql_relay.utils.base64 import base64, unbase64
 
 from graphql.type import (
@@ -6,15 +8,27 @@
     GraphQLID,
     GraphQLField,
     GraphQLInterfaceType,
+    GraphQLList,
+    GraphQLResolveInfo,
+    GraphQLTypeResolver
 )
 
 
-def node_definitions(id_fetcher, type_resolver=None):
+class GraphQLNodeDefinitions(NamedTuple):
+
+    node_interface: GraphQLInterfaceType
+    node_field: GraphQLField
+    nodes_field: GraphQLField
+
+
+def node_definitions(
+        id_fetcher: Callable[[str, GraphQLResolveInfo], Any],
+        type_resolver: GraphQLTypeResolver = None) -> GraphQLNodeDefinitions:
     """
     Given a function to map from an ID to an underlying object, and a function
     to map from an underlying object to the concrete GraphQLObjectType it
     corresponds to, constructs a `Node` interface that objects can implement,
-    and a field config for a `node` root field.
+    and a field object to be used as a `node` root field.
 
     If the type_resolver is omitted, object resolution on the interface will be
     handled with the `is_type_of` method on object types, as with any GraphQL
@@ -29,6 +43,7 @@ def node_definitions(id_fetcher, type_resolver=None):
                 description='The id of the object.')},
         resolve_type=type_resolver,
     )
+
     # noinspection PyShadowingBuiltins
     node_field = GraphQLField(
         node_interface,
@@ -39,39 +54,59 @@ def node_definitions(id_fetcher, type_resolver=None):
                 description='The ID of an object')},
         resolve=lambda _obj, info, id: id_fetcher(id, info)
     )
-    return node_interface, node_field
 
+    nodes_field = GraphQLField(
+        GraphQLNonNull(GraphQLList(node_interface)),
+        args={
+            'ids': GraphQLArgument(
+                GraphQLNonNull(GraphQLList(GraphQLNonNull(GraphQLID))),
+                description='The IDs of objects')},
+        resolve=lambda _obj, info, ids: [id_fetcher(id_, info) for id_ in ids]
+    )
+
+    return GraphQLNodeDefinitions(node_interface, node_field, nodes_field)
+
+
+class ResolvedGlobalId(NamedTuple):
+
+    type: str
+    id: str
 
-def to_global_id(type_, id_):
+
+def to_global_id(type_: str, id_: str) -> str:
     """
     Takes a type name and an ID specific to that type name, and returns a
     "global ID" that is unique among all types.
     """
-    return base64(':'.join([type_, str(id_)]))
+    return base64(f'{type_}:{id_}')
 
 
-def from_global_id(global_id):
+def from_global_id(global_id: str) -> ResolvedGlobalId:
     """
-    Takes the "global ID" created by toGlobalID, and retuns the type name and ID
+    Takes the "global ID" created by to_global_id, and returns the type name and ID
     used to create it.
     """
-    unbased_global_id = unbase64(global_id)
-    _type, _id = unbased_global_id.split(':', 1)
-    return _type, _id
+    return ResolvedGlobalId(*unbase64(global_id).split(':', 1))
 
 
-def global_id_field(type_name, id_fetcher=None):
+def global_id_field(
+        type_name: str = None,
+        id_fetcher: Callable[[Any, GraphQLResolveInfo], str] = None) -> GraphQLField:
     """
     Creates the configuration for an id field on a node, using `to_global_id` to
-    construct the ID from the provided typename. The type-specific ID is fetcher
+    construct the ID from the provided typename. The type-specific ID is fetched
     by calling id_fetcher on the object, or if not provided, by accessing the `id`
-    property on the object.
+    attribute of the object, or the `id` if the object is a dict.
     """
+
+    def resolve(obj: Any, info: GraphQLResolveInfo, **_args: Any) -> str:
+        type_ = type_name or info.parent_type.name
+        id_ = id_fetcher(obj, info) if id_fetcher else (
+            obj['id'] if isinstance(obj, dict) else obj.id)
+        return to_global_id(type_, id_)
+
     return GraphQLField(
         GraphQLNonNull(GraphQLID),
         description='The ID of an object',
-        resolve=lambda obj, info, **args: to_global_id(
-            type_name or info.parent_type.name,
-            id_fetcher(obj, info) if id_fetcher else obj.id
-        )
+        resolve=resolve
     )

src/graphql_relay/node/node.py

@@ -1,14 +1,23 @@
+from typing import Any, Callable
+
 from graphql.type import (
     GraphQLArgument,
+    GraphQLField,
+    GraphQLInputType,
+    GraphQLOutputType,
     GraphQLList,
     GraphQLNonNull,
-    GraphQLField
-)
+    GraphQLResolveInfo)
 
 
 def plural_identifying_root_field(
-        arg_name, input_type, output_type,
-        resolve_single_input, description=None):
+        arg_name: str,
+        input_type: GraphQLInputType,
+        output_type: GraphQLOutputType,
+        resolve_single_input: Callable[[GraphQLResolveInfo, str], Any],
+        description: str = None) -> GraphQLField:
+    if isinstance(input_type, GraphQLNonNull):
+        input_type = input_type.of_type
     input_args = {arg_name: GraphQLArgument(
         GraphQLNonNull(GraphQLList(GraphQLNonNull(input_type))))}
 

src/graphql_relay/node/plural.py

@@ -0,0 +1 @@
+# Marker file for PEP 561. The graphql package uses inline types.