Merge remote-tracking branch 'github/master' into sortable_field

Author: CaselIT

docs/requirements.txt

@@ -1,2 +1,2 @@
 # Docs template
-https://github.com/graphql-python/graphene-python.org/archive/docs.zip
+http://graphene-python.org/sphinx_graphene_theme.zip

graphene_sqlalchemy/converter.py

@@ -36,7 +36,7 @@ def dynamic_type():
             return Field(_type)
         elif direction in (interfaces.ONETOMANY, interfaces.MANYTOMANY):
             if _type._meta.connection:
-                return createConnectionField(_type)
+                return createConnectionField(_type._meta.connection)
             return Field(List(_type))
 
     return Dynamic(dynamic_type)
@@ -92,6 +92,8 @@ def convert_sqlalchemy_type(type, column, registry=None):
 @convert_sqlalchemy_type.register(types.Unicode)
 @convert_sqlalchemy_type.register(types.UnicodeText)
 @convert_sqlalchemy_type.register(postgresql.UUID)
+@convert_sqlalchemy_type.register(postgresql.INET)
+@convert_sqlalchemy_type.register(postgresql.CIDR)
 @convert_sqlalchemy_type.register(TSVectorType)
 def convert_column_to_string(type, column, registry=None):
     return String(description=get_column_doc(column),

graphene_sqlalchemy/fields.py

@@ -1,5 +1,5 @@
 from functools import partial
-
+from promise import is_thenable, Promise
 from sqlalchemy.orm.query import Query
 
 from graphene.relay import ConnectionField
@@ -25,39 +25,38 @@ def get_query(cls, model, info, sort=None, **args):
                 query = query.order_by(*(col.value for col in sort))
         return query
 
-    @property
-    def type(self):
-        from .types import SQLAlchemyObjectType
-        _type = super(ConnectionField, self).type
-        assert issubclass(_type, SQLAlchemyObjectType), (
-            "SQLAlchemyConnectionField only accepts SQLAlchemyObjectType types"
-        )
-        assert _type._meta.connection, "The type {} doesn't have a connection".format(_type.__name__)
-        return _type._meta.connection
-
     @classmethod
-    def connection_resolver(cls, resolver, connection, model, root, info, **args):
-        iterable = resolver(root, info, **args)
-        if iterable is None:
-            iterable = cls.get_query(model, info, **args)
-        if isinstance(iterable, Query):
-            _len = iterable.count()
+    def resolve_connection(cls, connection_type, model, info, args, resolved):
+        if resolved is None:
+            resolved = cls.get_query(model, info, **args)
+        if isinstance(resolved, Query):
+            _len = resolved.count()
         else:
-            _len = len(iterable)
+            _len = len(resolved)
         connection = connection_from_list_slice(
-            iterable,
+            resolved,
             args,
             slice_start=0,
             list_length=_len,
             list_slice_length=_len,
-            connection_type=connection,
+            connection_type=connection_type,
             pageinfo_type=PageInfo,
-            edge_type=connection.Edge,
+            edge_type=connection_type.Edge,
         )
-        connection.iterable = iterable
+        connection.iterable = resolved
         connection.length = _len
         return connection
 
+    @classmethod
+    def connection_resolver(cls, resolver, connection_type, model, root, info, **args):
+        resolved = resolver(root, info, **args)
+
+        on_resolve = partial(cls.resolve_connection, connection_type, model, info, args)
+        if is_thenable(resolved):
+            return Promise.resolve(resolved).then(on_resolve)
+
+        return on_resolve(resolved)
+
     def get_resolver(self, parent_resolver):
         return partial(self.connection_resolver, parent_resolver, self.type, self.model)
 

graphene_sqlalchemy/tests/test_connectionfactory.py

@@ -22,7 +22,10 @@ def LXResolver(root, args, context, info):
             return SQLAlchemyConnectionField.connection_resolver(LXResolver, connection, model, root, args, context, info)
 
     def createLXConnectionField(table):
-        return LXConnectionField(table, filter=table.filter(), order_by=graphene.List(of_type=table.order_by))
+        class LXConnection(graphene.relay.Connection):
+            class Meta:
+                node = table
+        return LXConnectionField(LXConnection, filter=table.filter(), order_by=graphene.List(of_type=table.order_by))
 
     registerConnectionFieldFactory(createLXConnectionField)
     unregisterConnectionFieldFactory()

graphene_sqlalchemy/tests/test_query.py

@@ -140,7 +140,7 @@ class Meta:
             interfaces = (Node, )
 
         @classmethod
-        def get_node(cls, id, info):
+        def get_node(cls, info, id):
             return Reporter(id=2, first_name='Cookie Monster')
 
     class ArticleNode(SQLAlchemyObjectType):
@@ -153,11 +153,15 @@ class Meta:
         # def get_node(cls, id, info):
         #     return Article(id=1, headline='Article node')
 
+    class ArticleConnection(graphene.relay.Connection):
+        class Meta:
+            node = ArticleNode
+
     class Query(graphene.ObjectType):
         node = Node.Field()
         reporter = graphene.Field(ReporterNode)
         article = graphene.Field(ArticleNode)
-        all_articles = SQLAlchemyConnectionField(ArticleNode)
+        all_articles = SQLAlchemyConnectionField(ArticleConnection)
 
         def resolve_reporter(self, *args, **kwargs):
             return session.query(Reporter).first()
@@ -239,9 +243,13 @@ class Meta:
             model = Editor
             interfaces = (Node, )
 
+    class EditorConnection(graphene.relay.Connection):
+        class Meta:
+            node = EditorNode
+
     class Query(graphene.ObjectType):
         node = Node.Field()
-        all_editors = SQLAlchemyConnectionField(EditorNode)
+        all_editors = SQLAlchemyConnectionField(EditorConnection)
 
     query = '''
         query EditorQuery {

graphene_sqlalchemy/tests/test_types.py

@@ -1,11 +1,13 @@
-
+from collections import OrderedDict
 from graphene import Field, Int, Interface, ObjectType
-from graphene.relay import Node, is_node
+from graphene.relay import Node, is_node, Connection
 import six
+from promise import Promise
 
 from ..registry import Registry
-from ..types import SQLAlchemyObjectType
+from ..types import SQLAlchemyObjectType, SQLAlchemyObjectTypeOptions
 from .models import Article, Reporter
+from ..fields import SQLAlchemyConnectionField
 
 registry = Registry()
 
@@ -116,3 +118,55 @@ def test_custom_objecttype_registered():
         'pets',
         'articles',
         'favorite_article']
+
+
+# Test Custom SQLAlchemyObjectType with Custom Options
+class CustomOptions(SQLAlchemyObjectTypeOptions):
+    custom_option = None
+    custom_fields = None
+
+
+class SQLAlchemyObjectTypeWithCustomOptions(SQLAlchemyObjectType):
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def __init_subclass_with_meta__(cls, custom_option=None, custom_fields=None, **options):
+        _meta = CustomOptions(cls)
+        _meta.custom_option = custom_option
+        _meta.fields = custom_fields
+        super(SQLAlchemyObjectTypeWithCustomOptions, cls).__init_subclass_with_meta__(_meta=_meta, **options)
+
+
+class ReporterWithCustomOptions(SQLAlchemyObjectTypeWithCustomOptions):
+    class Meta:
+        model = Reporter
+        custom_option = 'custom_option'
+        custom_fields = OrderedDict([('custom_field', Field(Int()))])
+
+
+def test_objecttype_with_custom_options():
+    assert issubclass(ReporterWithCustomOptions, ObjectType)
+    assert ReporterWithCustomOptions._meta.model == Reporter
+    assert list(
+        ReporterWithCustomOptions._meta.fields.keys()) == [
+               'custom_field',
+               'id',
+               'first_name',
+               'last_name',
+               'email',
+               'pets',
+               'articles',
+               'favorite_article']
+    assert ReporterWithCustomOptions._meta.custom_option == 'custom_option'
+    assert isinstance(ReporterWithCustomOptions._meta.fields['custom_field'].type, Int)
+
+
+def test_promise_connection_resolver():
+    class TestConnection(Connection):
+        class Meta:
+            node = ReporterWithCustomOptions
+
+    resolver = lambda *args, **kwargs: Promise.resolve([])
+    result = SQLAlchemyConnectionField.connection_resolver(resolver, TestConnection, ReporterWithCustomOptions, None, None)
+    assert result is not None

graphene_sqlalchemy/types.py

@@ -90,7 +90,7 @@ class SQLAlchemyObjectType(ObjectType):
     @classmethod
     def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=False,
                                     only_fields=(), exclude_fields=(), connection=None,
-                                    use_connection=None, interfaces=(), id=None, **options):
+                                    use_connection=None, interfaces=(), id=None, _meta=None, **options):
         assert is_mapped_class(model), (
             'You need to pass a valid SQLAlchemy Model in '
             '{}.Meta, received "{}".'
@@ -121,10 +121,17 @@ def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=Fa
                 "The connection must be a Connection. Received {}"
             ).format(connection.__name__)
 
-        _meta = SQLAlchemyObjectTypeOptions(cls)
+        if not _meta:
+            _meta = SQLAlchemyObjectTypeOptions(cls)
+
         _meta.model = model
         _meta.registry = registry
-        _meta.fields = sqla_fields
+
+        if _meta.fields:
+            _meta.fields.update(sqla_fields)
+        else:
+            _meta.fields = sqla_fields
+
         _meta.connection = connection
         _meta.id = id or 'id'