Updated SQLAlchemy integration in graphene

Author: syrusakbary

.travis.yml

@@ -25,6 +25,7 @@ install:
   if [ "$TEST_TYPE" = build ]; then
     pip install --download-cache $HOME/.cache/pip/ pytest pytest-cov coveralls six pytest-django django-filter
     pip install --download-cache $HOME/.cache/pip/ -e .[django]
+    pip install --download-cache $HOME/.cache/pip/ -e .[sqlalchemy]
     pip install django==$DJANGO_VERSION
     python setup.py develop
   elif [ "$TEST_TYPE" = build_website ]; then

graphene/contrib/sqlalchemy/__init__.py

@@ -1,12 +1,11 @@
 from graphene.contrib.sqlalchemy.types import (
     SQLAlchemyObjectType,
-    SQLAlchemyInterface,
     SQLAlchemyNode
 )
 from graphene.contrib.sqlalchemy.fields import (
     SQLAlchemyConnectionField,
     SQLAlchemyModelField
 )
 
-__all__ = ['SQLAlchemyObjectType', 'SQLAlchemyInterface', 'SQLAlchemyNode',
+__all__ = ['SQLAlchemyObjectType', 'SQLAlchemyNode',
            'SQLAlchemyConnectionField', 'SQLAlchemyModelField']

graphene/contrib/sqlalchemy/converter.py

@@ -1,8 +1,9 @@
+from singledispatch import singledispatch
+
 from sqlalchemy import types
 from sqlalchemy.orm import interfaces
-from singledispatch import singledispatch
 
-from ...core.types.scalars import Boolean, Float, ID, Int, String
+from ...core.types.scalars import ID, Boolean, Float, Int, String
 from .fields import ConnectionOrListField, SQLAlchemyModelField
 
 

graphene/contrib/sqlalchemy/fields.py

@@ -1,31 +1,32 @@
-from sqlalchemy.orm import Query
 from ...core.exceptions import SkipField
 from ...core.fields import Field
 from ...core.types.base import FieldType
 from ...core.types.definitions import List
 from ...relay import ConnectionField
 from ...relay.utils import is_node
-from ...utils import LazyMap
-
 from .utils import get_type_for_model
 
 
 class SQLAlchemyConnectionField(ConnectionField):
 
-    def wrap_resolved(self, value, instance, args, info):
-        if isinstance(value, Query):
-            return LazyMap(value, self.type)
-        return value
+    def __init__(self, *args, **kwargs):
+        self.session = kwargs.pop('session', None)
+        return super(SQLAlchemyConnectionField, self).__init__(*args, **kwargs)
 
+    @property
+    def model(self):
+        return self.type._meta.model
 
-class LazyListField(Field):
+    def get_session(self, args, info):
+        return self.session
 
-    def get_type(self, schema):
-        return List(self.type)
+    def get_query(self, resolved_query, args, info):
+        self.get_session(args, info)
+        return resolved_query
 
-    def resolver(self, instance, args, info):
-        resolved = super(LazyListField, self).resolver(instance, args, info)
-        return LazyMap(resolved, self.type)
+    def from_list(self, connection_type, resolved, args, info):
+        qs = self.get_query(resolved, args, info)
+        return super(SQLAlchemyConnectionField, self).from_list(connection_type, qs, args, info)
 
 
 class ConnectionOrListField(Field):
@@ -38,7 +39,7 @@ def internal_type(self, schema):
         if is_node(field_object_type):
             field = SQLAlchemyConnectionField(field_object_type)
         else:
-            field = LazyListField(field_object_type)
+            field = Field(List(field_object_type))
         field.contribute_to_class(self.object_type, self.attname)
         return schema.T(field)
 

graphene/contrib/sqlalchemy/options.py

@@ -1,37 +1,23 @@
-import inspect
-
-from sqlalchemy.ext.declarative.api import DeclarativeMeta
-
-from ...core.options import Options
+from ...core.classtypes.objecttype import ObjectTypeOptions
 from ...relay.types import Node
 from ...relay.utils import is_node
 
 VALID_ATTRS = ('model', 'only_fields', 'exclude_fields')
 
 
-def is_base(cls):
-    from graphene.contrib.sqlalchemy.types import SQLAlchemyObjectType
-    return SQLAlchemyObjectType in cls.__bases__
-
-
-class SQLAlchemyOptions(Options):
+class SQLAlchemyOptions(ObjectTypeOptions):
 
     def __init__(self, *args, **kwargs):
-        self.model = None
         super(SQLAlchemyOptions, self).__init__(*args, **kwargs)
+        self.model = None
         self.valid_attrs += VALID_ATTRS
         self.only_fields = None
         self.exclude_fields = []
+        self.filter_fields = None
+        self.filter_order_by = None
 
     def contribute_to_class(self, cls, name):
         super(SQLAlchemyOptions, self).contribute_to_class(cls, name)
         if is_node(cls):
-            self.exclude_fields = list(self.exclude_fields)
+            self.exclude_fields = list(self.exclude_fields) + ['id']
             self.interfaces.append(Node)
-        if not is_node(cls) and not is_base(cls):
-            return
-        if not self.model:
-            raise Exception(
-                'SQLAlchemy ObjectType %s must have a model in the Meta class attr' % cls)
-        elif not inspect.isclass(self.model) or not isinstance(self.model, DeclarativeMeta):
-            raise Exception('Provided model in %s is not a SQLAlchemy model' % cls)

graphene/contrib/sqlalchemy/tests/models.py

@@ -1,15 +1,14 @@
 from __future__ import absolute_import
 
-from sqlalchemy import Table, Column, Integer, String, Date, ForeignKey
+from sqlalchemy import Column, Date, ForeignKey, Integer, String, Table
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import relationship
 
-
 Base = declarative_base()
 
 association_table = Table('association', Base.metadata,
-    Column('pet_id', Integer, ForeignKey('pets.id')),
-    Column('reporter_id', Integer, ForeignKey('reporters.id')))
+                          Column('pet_id', Integer, ForeignKey('pets.id')),
+                          Column('reporter_id', Integer, ForeignKey('reporters.id')))
 
 
 class Pet(Base):

graphene/contrib/sqlalchemy/tests/test_converter.py

@@ -1,11 +1,13 @@
-from sqlalchemy import types, Column
 from py.test import raises
 
 import graphene
-from graphene.contrib.sqlalchemy.converter import convert_sqlalchemy_column, convert_sqlalchemy_relationship
-from graphene.contrib.sqlalchemy.fields import ConnectionOrListField, SQLAlchemyModelField
+from graphene.contrib.sqlalchemy.converter import (convert_sqlalchemy_column,
+                                                   convert_sqlalchemy_relationship)
+from graphene.contrib.sqlalchemy.fields import (ConnectionOrListField,
+                                                SQLAlchemyModelField)
+from sqlalchemy import Column, types
 
-from .models import Article, Reporter, Pet
+from .models import Article, Pet, Reporter
 
 
 def assert_column_conversion(sqlalchemy_type, graphene_field, **kwargs):
@@ -72,7 +74,7 @@ def test_should_integer_convert_id():
 
 
 def test_should_boolean_convert_boolean():
-    field = assert_column_conversion(types.Boolean(), graphene.Boolean)
+    assert_column_conversion(types.Boolean(), graphene.Boolean)
 
 
 def test_should_float_convert_float():

graphene/contrib/sqlalchemy/tests/test_query.py

@@ -1,139 +1,82 @@
-from py.test import raises
+import pytest
 
 import graphene
-from graphene import relay
-from graphene.contrib.sqlalchemy import SQLAlchemyNode, SQLAlchemyObjectType
-from .models import Article, Reporter
+from graphene.contrib.sqlalchemy import SQLAlchemyObjectType
+from sqlalchemy import create_engine
+from sqlalchemy.orm import scoped_session, sessionmaker
 
+from .models import Base, Reporter
 
-def test_should_query_only_fields():
-    with raises(Exception):
-        class ReporterType(SQLAlchemyObjectType):
+db = create_engine('sqlite:///test_sqlalchemy.sqlite3')
 
-            class Meta:
-                model = Reporter
-                only_fields = ('articles', )
 
-        schema = graphene.Schema(query=ReporterType)
-        query = '''
-            query ReporterQuery {
-              articles
-            }
-        '''
-        result = schema.execute(query)
-        assert not result.errors
+@pytest.yield_fixture(scope='function')
+def session():
+    connection = db.engine.connect()
+    transaction = connection.begin()
+    Base.metadata.create_all(connection)
 
+    # options = dict(bind=connection, binds={})
+    session_factory = sessionmaker(bind=connection)
+    session = scoped_session(session_factory)
 
-def test_should_query_well():
-    class ReporterType(SQLAlchemyObjectType):
+    yield session
 
-        class Meta:
-            model = Reporter
+    # Finalize test here
+    transaction.rollback()
+    connection.close()
+    session.remove()
 
-    class Query(graphene.ObjectType):
-        reporter = graphene.Field(ReporterType)
 
-        def resolve_reporter(self, *args, **kwargs):
-            return ReporterType(Reporter(first_name='ABA', last_name='X'))
+def setup_fixtures(session):
+    reporter = Reporter(first_name='ABA', last_name='X')
+    session.add(reporter)
+    reporter2 = Reporter(first_name='ABO', last_name='Y')
+    session.add(reporter2)
+    session.commit()
 
-    query = '''
-        query ReporterQuery {
-          reporter {
-            firstName,
-            lastName,
-            email
-          }
-        }
-    '''
-    expected = {
-        'reporter': {
-            'firstName': 'ABA',
-            'lastName': 'X',
-            'email': None
-        }
-    }
-    schema = graphene.Schema(query=Query)
-    result = schema.execute(query)
-    assert not result.errors
-    assert result.data == expected
 
+def test_should_query_well(session):
+    setup_fixtures(session)
 
-def test_should_node():
-    class ReporterNode(SQLAlchemyNode):
+    class ReporterType(SQLAlchemyObjectType):
 
         class Meta:
             model = Reporter
-            exclude_fields = ('id', )
-
-        @classmethod
-        def get_node(cls, id, info):
-            return ReporterNode(Reporter(id=2, first_name='Cookie Monster'))
-
-        def resolve_articles(self, *args, **kwargs):
-            return [ArticleNode(Article(headline='Hi!'))]
-
-    class ArticleNode(SQLAlchemyNode):
-
-        class Meta:
-            model = Article
-            exclude_fields = ('id', )
-
-        @classmethod
-        def get_node(cls, id, info):
-            return ArticleNode(Article(id=1, headline='Article node'))
 
     class Query(graphene.ObjectType):
-        node = relay.NodeField()
-        reporter = graphene.Field(ReporterNode)
-        article = graphene.Field(ArticleNode)
+        reporter = graphene.Field(ReporterType)
+        reporters = ReporterType.List()
 
         def resolve_reporter(self, *args, **kwargs):
-            return ReporterNode(Reporter(id=1, first_name='ABA', last_name='X'))
+            return session.query(Reporter).first()
+
+        def resolve_reporters(self, *args, **kwargs):
+            return session.query(Reporter)
 
     query = '''
         query ReporterQuery {
           reporter {
-            id,
             firstName,
-            articles {
-              edges {
-                node {
-                  headline
-                }
-              }
-            }
             lastName,
             email
           }
-          myArticle: node(id:"QXJ0aWNsZU5vZGU6MQ==") {
-            id
-            ... on ReporterNode {
-                firstName
-            }
-            ... on ArticleNode {
-                headline
-            }
+          reporters {
+            firstName
           }
         }
     '''
     expected = {
         'reporter': {
-            'id': 'UmVwb3J0ZXJOb2RlOjE=',
             'firstName': 'ABA',
             'lastName': 'X',
-            'email': None,
-            'articles': {
-                'edges': [{
-                  'node': {
-                      'headline': 'Hi!'
-                  }
-                }]
-            },
+            'email': None
         },
-        'myArticle': {
-            'id': 'QXJ0aWNsZU5vZGU6MQ==',
-            'headline': 'Article node'
-        }
+        'reporters': [{
+            'firstName': 'ABA',
+        }, {
+            'firstName': 'ABO',
+        }]
     }
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)