Add extensions in arrayconnection back again

Author: Cito

README.md

@@ -62,12 +62,10 @@ returning those types.
 they return a connection type.
  - `connection_definitions` returns a `connection_type` and its associated
 `edgeType`, given a name and a node type.
- - `connection_from_list` is a helper method that takes an array and the
+ - `connection_from_array` is a helper method that takes an array and the
 arguments from `connection_args`, does pagination and filtering, and returns
 an object in the shape expected by a `connection_type`'s `resolver` function.
- - `connection_from_promised_list` is similar to `connection_from_list`, but
-it takes a promise that resolves to an array, and returns a promise that
-resolves to the expected shape by `connection_type`.
+
  - `cursor_for_object_in_connection` is a helper method that takes an array and a
 member object, and returns a cursor for use in the mutation payload.
 
@@ -89,7 +87,7 @@ factionType = GraphQLObjectType(
             ship_connection,
             description='The ships used by the faction.',
             args=connection_args,
-            resolve=lambda faction, _info, **args: connection_from_list(
+            resolve=lambda faction, _info, **args: connection_from_array(
                 [getShip(ship) for ship in faction.ships], args),
         )
     },
@@ -98,28 +96,28 @@ factionType = GraphQLObjectType(
 ```
 
 This shows adding a `ships` field to the `Faction` object that is a connection.
-It uses `connection_definitions({name: 'Ship', nodeType: shipType})` to create
-the connection type, adds `connection_args` as arguments on this function, and
-then implements the resolver function by passing the array of ships and the
-arguments to `connection_from_list`.
+It uses `connection_definitions('Ship', shipType)` to create the connection
+type, adds `connection_args` as arguments on this function, and then implements
+the resolver function by passing the array of ships and the arguments to
+`connection_from_array`.
 
 ### Object Identification
 
 Helper functions are provided for both building the GraphQL types
 for nodes and for implementing global IDs around local IDs.
 
  - `node_definitions` returns the `Node` interface that objects can implement,
-and returns the `node` root field to include on the query type. To implement
-this, it takes a function to resolve an ID to an object, and to determine
-the type of a given object.
+    and returns the `node` root field to include on the query type.
+    To implement this, it takes a function to resolve an ID to an object,
+    and to determine the type of a given object.
  - `to_global_id` takes a type name and an ID specific to that type name,
-and returns a "global ID" that is unique among all types.
- - `from_global_id` takes the "global ID" created by `toGlobalID`, and returns
-the type name and ID used to create it.
+    and returns a "global ID" that is unique among all types.
+ - `from_global_id` takes the "global ID" created by `to_global_id`, and
+    returns the type name and ID used to create it.
  - `global_id_field` creates the configuration for an `id` field on a node.
  - `plural_identifying_root_field` creates a field that accepts a list of
-non-ID identifiers (like a username) and maps then to their corresponding
-objects.
+    non-ID identifiers (like a username) and maps then to their corresponding
+    objects.
 
 An example usage of these methods from the [test schema](tests/starwars/schema.py):
 
@@ -184,7 +182,7 @@ class IntroduceShipMutation:
         self.factionId = factionId
         self.clientMutationId = clientMutationId
 
-def mutate_and_get_payload(_info, shipName, factionId, **_input):
+def mutate_and_get_payload(_info, shipName, factionId):
     newShip = createShip(shipName, factionId)
     return IntroduceShipMutation(shipId=newShip.id, factionId=factionId)
 
@@ -221,9 +219,9 @@ mutationType = GraphQLObjectType(
 
 This code creates a mutation named `IntroduceShip`, which takes a faction
 ID and a ship name as input. It outputs the `Faction` and the `Ship` in
-question. `mutate_and_get_payload` then gets an object with a property for
-each input field, performs the mutation by constructing the new ship, then
-returns an object that will be resolved by the output fields.
+question. `mutate_and_get_payload` then gets each input field as keyword
+parameter, performs the mutation by constructing the new ship, then returns
+an object that will be resolved by the output fields.
 
 Our mutation type then creates the `introduceShip` field using the return
 value of `mutation_with_client_mutation_id`.

src/graphql_relay/connection/arrayconnection.py

@@ -1,5 +1,5 @@
 import binascii
-from typing import Any, Collection, Optional, TypeVar
+from typing import Any, Optional, Sequence
 
 from ..utils.base64 import base64, unbase64
 from .connectiontypes import (
@@ -11,40 +11,65 @@
     'get_offset_with_default', 'offset_to_cursor'
 ]
 
-T = TypeVar('T')
-
 
 def connection_from_array(
-        data: Collection, args: ConnectionArguments) -> Connection:
-    """Create a connection argument from a collection.
+        data: Sequence, args: ConnectionArguments = None,
+        connection_type: Any = Connection,
+        edge_type: Any = Edge, page_info_type: Any = PageInfo) -> Connection:
+    """Create a connection object from a sequence of objects.
+
+    Note that different from its JavaScript counterpart which expects an array,
+    this function accepts any kind of sliceable object with a length.
 
-    A simple function that accepts a collection (e.g. a Python list) and connection
-    arguments, and returns a connection object for use in GraphQL. It uses array
-    offsets as pagination, so pagination will only work if the array is static.
+    Given this `data` object representing the result set, and connection arguments,
+    this simple function returns a connection object for use in GraphQL. It uses
+    offsets as pagination, so pagination will only work if the data is static.
+
+    The result will use the default types provided in the `connectiontypes` module
+    if you don't pass custom types as arguments.
     """
     return connection_from_array_slice(
         data, args,
         slice_start=0,
         array_length=len(data),
+        connection_type=connection_type,
+        edge_type=edge_type, page_info_type=page_info_type,
     )
 
 
 def connection_from_array_slice(
-        array_slice: Collection, args: ConnectionArguments,
-        slice_start: int, array_length: int
-        ) -> Connection:
-    """Given a slice of a collection, returns a connection object for use in GraphQL.
+        array_slice: Sequence, args: ConnectionArguments = None,
+        slice_start: int = 0, array_length: int = None, array_slice_length: int = None,
+        connection_type: Any = Connection,
+        edge_type: Any = Edge, page_info_type: Any = PageInfo) -> Connection:
+    """Create a connection object from a slice of the result set.
+
+    Note that different from its JavaScript counterpart which expects an array,
+    this function accepts any kind of sliceable object. This object represents
+    a slice of the full result set. You need to pass the start position of the
+    slice as `slice start` and the length of the full result set as `array_length`.
+    If the `array_slice` does not have a length, you need to provide it separately
+    in `array_slice_length` as well.
 
     This function is similar to `connection_from_array`, but is intended for use
     cases where you know the cardinality of the connection, consider it too large
-    to materialize the entire collection, and instead wish pass in a slice of the
-    total result large enough to cover the range specified in `args`.
+    to materialize the entire result set, and instead wish to pass in only a slice
+    of the total result large enough to cover the range specified in `args`.
+
+    If you do not provide a `slice_start`, we assume that the slice starts at
+    the beginning of the result set, and if you do not provide an `array_length`,
+    we assume that the slice ends at the end of the result set.
     """
+    args = args or {}
     before = args.get('before')
     after = args.get('after')
     first = args.get('first')
     last = args.get('last')
-    slice_end = slice_start + len(array_slice)
+    if array_slice_length is None:
+        array_slice_length = len(array_slice)
+    slice_end = slice_start + array_slice_length
+    if array_length is None:
+        array_length = slice_end
     before_offset = get_offset_with_default(before, array_length)
     after_offset = get_offset_with_default(after, -1)
 
@@ -64,12 +89,11 @@ def connection_from_array_slice(
 
     # If supplied slice is too large, trim it down before mapping over it.
     trimmed_slice = array_slice[
-        max(start_offset - slice_start, 0):
-        len(array_slice) - (slice_end - end_offset)
+        start_offset - slice_start:array_slice_length - (slice_end - end_offset)
     ]
 
     edges = [
-        Edge(
+        edge_type(
             node=value,
             cursor=offset_to_cursor(start_offset + index)
         )
@@ -81,9 +105,9 @@ def connection_from_array_slice(
     lower_bound = after_offset + 1 if after else 0
     upper_bound = before_offset if before else array_length
 
-    return Connection(
+    return connection_type(
         edges=edges,
-        pageInfo=PageInfo(
+        pageInfo=page_info_type(
             startCursor=first_edge_cursor,
             endCursor=last_edge_cursor,
             hasPreviousPage=isinstance(last, int) and start_offset > lower_bound,
@@ -108,16 +132,27 @@ def cursor_to_offset(cursor: ConnectionCursor) -> Optional[int]:
         return None
 
 
-def cursor_for_object_in_connection(data: Collection, obj: T) -> Optional[Any]:
-    """Return the cursor associated with an object in a collection."""
+def cursor_for_object_in_connection(
+        data: Sequence, obj: Any) -> Optional[ConnectionCursor]:
+    """Return the cursor associated with an object in a sequence.
+
+    This function uses the `index` method of the sequence if it exists,
+    otherwise searches the object by iterating via the `__getitem__` method.
+    """
     try:
-        # noinspection PyUnresolvedReferences
-        offset = data.index(obj)  # type: ignore
-    except AttributeError:  # collection does not have an index method
-        for offset, value in data:
-            if value == obj:
-                return offset
-        return None
+        offset = data.index(obj)
+    except AttributeError:
+        # data does not have an index method
+        offset = 0
+        try:
+            while True:
+                if data[offset] == obj:
+                    break
+                offset += 1
+        except IndexError:
+            return None
+        else:
+            return offset_to_cursor(offset)
     except ValueError:
         return None
     else:

src/graphql_relay/connection/connection.py

@@ -59,7 +59,7 @@ def connection_definitions(
         resolve_cursor: GraphQLFieldResolver = None,
         edge_fields: Thunk[GraphQLFieldMap] = None,
         connection_fields: Thunk[GraphQLFieldMap] = None
-        ) -> GraphQLConnectionDefinitions:
+) -> GraphQLConnectionDefinitions:
     """Return GraphQLObjectTypes for a connection with the given name.
 
     The nodes of the returned object types will be of the specified type.

src/graphql_relay/connection/connectiontypes.py

@@ -35,7 +35,7 @@ class Connection(NamedTuple):
 """A type describing the arguments a connection field receives in GraphQL.
 
 The following kinds of arguments are expected (all optional):
- 
+
     before: ConnectionCursor
     after: ConnectionCursor
     first: int

src/graphql_relay/mutation/mutation.py

@@ -1,5 +1,5 @@
 from inspect import isawaitable
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
 from graphql.error import GraphQLError
 from graphql.pyutils import AwaitableOrValue, inspect
@@ -17,7 +17,14 @@
     Thunk
 )
 
-MutationFn = Callable[[Dict[str, Any], GraphQLResolveInfo], AwaitableOrValue[Any]]
+
+# Note: Contrary to the Javascript implementation of MutationFn,
+# the context is passed as part of the GraphQLResolveInfo and any arguments
+# are passed individually as keyword arguments.
+MutationFnWithoutArgs = Callable[[GraphQLResolveInfo], AwaitableOrValue[Any]]
+# Unfortunately there is currently no syntax to indicate optional or keyword
+# arguments in Python, so we also allow any other Callable as a workaround:
+MutationFn = Callable[..., AwaitableOrValue[Any]]
 
 
 def resolve_maybe_thunk(thing_or_thunk: Thunk) -> Any:
@@ -40,9 +47,10 @@ def mutation_with_client_mutation_id(
     An input object will be created containing the input fields, and an
     object will be created containing the output fields.
 
-    mutate_and_get_payload will receive a dict with a key for each input field,
-    and it should return an object (or a dict) with an attribute (or a key)
-    for each output field. It may return synchronously or asynchronously.
+    mutate_and_get_payload will receive a GraphQLResolveInfo as first argument,
+    and the input fields as keyword arguments, and it should return an object
+    (or a dict) with an attribute (or a key) for each output field.
+    It may return synchronously or asynchronously.
     """
     def augmented_input_fields() -> GraphQLInputFieldMap:
         return dict(
@@ -66,7 +74,7 @@ def augmented_output_fields() -> GraphQLFieldMap:
 
     # noinspection PyShadowingBuiltins
     async def resolve(_root, info, input):
-        payload = mutate_and_get_payload(input, info)
+        payload = mutate_and_get_payload(info, **input)
         if isawaitable(payload):
             payload = await payload
         try: