Improved fields and args to use OrderedDict instead of dict

Author: syrusakbary

graphql_relay/connection/connection.py

@@ -1,3 +1,5 @@
+from collections import OrderedDict
+
 from graphql.type import (
     GraphQLArgument,
     GraphQLBoolean,
@@ -11,47 +13,47 @@
 from ..utils import resolve_maybe_thunk
 
 
-connection_args = {
-    'before': GraphQLArgument(GraphQLString),
-    'after': GraphQLArgument(GraphQLString),
-    'first': GraphQLArgument(GraphQLInt),
-    'last': GraphQLArgument(GraphQLInt),
-}
+connection_args = OrderedDict((
+    ('before', GraphQLArgument(GraphQLString)),
+    ('after', GraphQLArgument(GraphQLString)),
+    ('first', GraphQLArgument(GraphQLInt)),
+    ('last', GraphQLArgument(GraphQLInt)),
+))
 
 
 def connection_definitions(name, node_type, resolve_node=None, resolve_cursor=None, edge_fields=None, connection_fields=None):
-    edge_fields = edge_fields or {}
-    connection_fields = connection_fields or {}
+    edge_fields = edge_fields or OrderedDict()
+    connection_fields = connection_fields or OrderedDict()
     edge_type = GraphQLObjectType(
         name + 'Edge',
         description='An edge in a connection.',
-        fields=lambda: dict({
-            'node': GraphQLField(
+        fields=lambda: OrderedDict((
+            ('node', GraphQLField(
                 node_type,
                 resolver=resolve_node,
                 description='The item at the end of the edge',
-            ),
-            'cursor': GraphQLField(
+            )),
+            ('cursor', GraphQLField(
                 GraphQLNonNull(GraphQLString),
                 resolver=resolve_cursor,
                 description='A cursor for use in pagination',
-            )
-        }, **resolve_maybe_thunk(edge_fields))
+            )),
+        ), **resolve_maybe_thunk(edge_fields))
     )
 
     connection_type = GraphQLObjectType(
         name + 'Connection',
         description='A connection to a list of items.',
-        fields=lambda: dict({
-            'pageInfo': GraphQLField(
+        fields=lambda: OrderedDict((
+            ('pageInfo', GraphQLField(
                 GraphQLNonNull(page_info_type),
                 description='The Information to aid in pagination',
-            ),
-            'edges': GraphQLField(
+            )),
+            ('edges', GraphQLField(
                 GraphQLList(edge_type),
                 description='A list of edges.',
-            )
-        }, **resolve_maybe_thunk(connection_fields))
+            )),
+        ), **resolve_maybe_thunk(connection_fields))
     )
 
     return edge_type, connection_type
@@ -61,22 +63,22 @@ def connection_definitions(name, node_type, resolve_node=None, resolve_cursor=No
 page_info_type = GraphQLObjectType(
     'PageInfo',
     description='Information about pagination in a connection.',
-    fields=lambda: {
-        'hasNextPage': GraphQLField(
+    fields=lambda: OrderedDict((
+        ('hasNextPage', GraphQLField(
             GraphQLNonNull(GraphQLBoolean),
             description='When paginating forwards, are there more items?',
-        ),
-        'hasPreviousPage': GraphQLField(
+        )),
+        ('hasPreviousPage', GraphQLField(
             GraphQLNonNull(GraphQLBoolean),
             description='When paginating backwards, are there more items?',
-        ),
-        'startCursor': GraphQLField(
+        )),
+        ('startCursor', GraphQLField(
             GraphQLString,
             description='When paginating backwards, the cursor to continue.',
-        ),
-        'endCursor': GraphQLField(
+        )),
+        ('endCursor', GraphQLField(
             GraphQLString,
             description='When paginating forwards, the cursor to continue.',
-        ),
-    }
+        )),
+    ))
 )

graphql_relay/mutation/mutation.py

@@ -1,3 +1,4 @@
+from collections import OrderedDict
 from promise import Promise
 from graphql.type import (
     GraphQLArgument,
@@ -13,14 +14,19 @@
 
 
 def mutation_with_client_mutation_id(name, input_fields, output_fields, mutate_and_get_payload):
-    augmented_input_fields = dict(resolve_maybe_thunk(input_fields),
-                                  clientMutationId=GraphQLInputObjectField(
-                                      GraphQLNonNull(GraphQLString))
-                                  )
-    augmented_output_fields = dict(resolve_maybe_thunk(output_fields),
-                                   clientMutationId=GraphQLField(
-                                       GraphQLNonNull(GraphQLString))
-                                   )
+    augmented_input_fields = OrderedDict(
+        resolve_maybe_thunk(input_fields),
+        clientMutationId=GraphQLInputObjectField(
+            GraphQLNonNull(GraphQLString)
+        )
+    )
+    augmented_output_fields = OrderedDict(
+        resolve_maybe_thunk(output_fields),
+        clientMutationId=GraphQLField(
+            GraphQLNonNull(GraphQLString)
+        )
+    )
+
     input_type = GraphQLInputObjectType(
         name + 'Input',
         fields=augmented_input_fields,
@@ -44,8 +50,8 @@ def on_resolve(payload):
 
     return GraphQLField(
         output_type,
-        args={
-            'input': GraphQLArgument(GraphQLNonNull(input_type)),
-        },
+        args=OrderedDict((
+            ('input', GraphQLArgument(GraphQLNonNull(input_type))),
+        )),
         resolver=resolver
     )

graphql_relay/node/node.py

@@ -1,3 +1,4 @@
+from collections import OrderedDict
 from graphql_relay.utils import base64, unbase64
 
 from graphql.type import (
@@ -23,24 +24,24 @@ def node_definitions(id_fetcher, type_resolver=None, id_resolver=None):
     node_interface = GraphQLInterfaceType(
         'Node',
         description='An object with an ID',
-        fields=lambda: {
-            'id': GraphQLField(
+        fields=lambda: OrderedDict((
+            ('id', GraphQLField(
                 GraphQLNonNull(GraphQLID),
                 description='The id of the object.',
                 resolver=id_resolver,
-            ),
-        },
+            )),
+        )),
         resolve_type=type_resolver
     )
     node_field = GraphQLField(
         node_interface,
         description='Fetches an object given its ID',
-        args={
-            'id': GraphQLArgument(
+        args=OrderedDict((
+            ('id', GraphQLArgument(
                 GraphQLNonNull(GraphQLID),
                 description='The ID of an object'
-            )
-        },
+            )),
+        )),
         resolver=lambda obj, args, *_: id_fetcher(args.get('id'), *_)
     )
     return node_interface, node_field

graphql_relay/node/plural.py

@@ -1,3 +1,4 @@
+from collections import OrderedDict
 from promise import Promise
 from graphql.type import (
     GraphQLArgument,
@@ -8,7 +9,7 @@
 
 
 def plural_identifying_root_field(arg_name, input_type, output_type, resolve_single_input, description=None):
-    input_args = {}
+    input_args = OrderedDict()
     input_args[arg_name] = GraphQLArgument(
         GraphQLNonNull(
             GraphQLList(