Fixing it up to use the declarative API

Author: jfeinstein10

graphene/contrib/sqlalchemy/converter.py

@@ -2,60 +2,62 @@
 from sqlalchemy.orm import interfaces
 from singledispatch import singledispatch
 
-from graphene.contrib.sqlalchemy.fields import ConnectionOrListField, SQLAlchemyModelField
-from graphene.core.fields import BooleanField, FloatField, IDField, IntField, StringField
+from ...core.types.scalars import Boolean, Float, ID, Int, String
+from .fields import ConnectionOrListField, SQLAlchemyModelField
 
 
 def convert_sqlalchemy_relationship(relationship):
-    model_field = SQLAlchemyModelField(field.table, description=relationship.key)
-    if relationship.direction == interfaces.ONETOMANY:
+    direction = relationship.direction
+    model = relationship.mapper.entity
+    model_field = SQLAlchemyModelField(model, description=relationship.doc)
+    if direction == interfaces.MANYTOONE:
         return model_field
-    elif (relationship.direction == interfaces.MANYTOONE or
-          relationship.direction == interfaces.MANYTOMANY):
+    elif (direction == interfaces.ONETOMANY or
+          direction == interfaces.MANYTOMANY):
         return ConnectionOrListField(model_field)
 
 
 def convert_sqlalchemy_column(column):
     try:
         return convert_sqlalchemy_type(column.type, column)
     except Exception:
-        raise
+        raise Exception(
+            "Don't know how to convert the SQLAlchemy field %s (%s)" % (column, column.__class__))
 
 
 @singledispatch
-def convert_sqlalchemy_type():
-    raise Exception(
-        "Don't know how to convert the SQLAlchemy column %s (%s)" % (column, column.__class__))
+def convert_sqlalchemy_type(type, column):
+    raise Exception()
 
 
 @convert_sqlalchemy_type.register(types.Date)
 @convert_sqlalchemy_type.register(types.DateTime)
 @convert_sqlalchemy_type.register(types.Time)
-@convert_sqlalchemy_type.register(types.Text)
 @convert_sqlalchemy_type.register(types.String)
+@convert_sqlalchemy_type.register(types.Text)
 @convert_sqlalchemy_type.register(types.Unicode)
 @convert_sqlalchemy_type.register(types.UnicodeText)
 @convert_sqlalchemy_type.register(types.Enum)
 def convert_column_to_string(type, column):
-    return StringField(description=column.description)
+    return String(description=column.doc)
 
 
 @convert_sqlalchemy_type.register(types.SmallInteger)
 @convert_sqlalchemy_type.register(types.BigInteger)
 @convert_sqlalchemy_type.register(types.Integer)
-def convert_column_to_int_or_id(column):
+def convert_column_to_int_or_id(type, column):
     if column.primary_key:
-        return IDField(description=column.description)
+        return ID(description=column.doc)
     else:
-        return IntField(description=column.description)
+        return Int(description=column.doc)
 
 
 @convert_sqlalchemy_type.register(types.Boolean)
-def convert_column_to_boolean(column):
-    return BooleanField(description=column.description)
+def convert_column_to_boolean(type, column):
+    return Boolean(description=column.doc)
 
 
 @convert_sqlalchemy_type.register(types.Float)
 @convert_sqlalchemy_type.register(types.Numeric)
-def convert_column_to_float(column):
-    return FloatField(description=column.description)
+def convert_column_to_float(type, column):
+    return Float(description=column.doc)

graphene/contrib/sqlalchemy/fields.py

@@ -1,67 +1,69 @@
-from graphene import relay
-from graphene.contrib.sqlalchemy.utils import get_type_for_model, lazy_map
-from graphene.core.fields import Field, LazyField, ListField
-from graphene.relay.utils import is_node
+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(relay.ConnectionField):
+
+class SQLAlchemyConnectionField(ConnectionField):
 
     def wrap_resolved(self, value, instance, args, info):
-        schema = info.schema.graphene_schema
-        return lazy_map(value, self.get_object_type(schema))
+        if isinstance(value, Query):
+            return LazyMap(value, self.type)
+        return value
+
 
+class LazyListField(Field):
 
-class LazyListField(ListField):
+    def get_type(self, schema):
+        return List(self.type)
 
-    def resolve(self, instance, args, info):
-        schema = info.schema.graphene_schema
-        resolved = super(LazyListField, self).resolve(instance, args, info)
-        return lazy_map(resolved, self.get_object_type(schema))
+    def resolver(self, instance, args, info):
+        resolved = super(LazyListField, self).resolver(instance, args, info)
+        return LazyMap(resolved, self.type)
 
 
-class ConnectionOrListField(LazyField):
+class ConnectionOrListField(Field):
 
-    def get_field(self, schema):
-        model_field = self.field_type
+    def internal_type(self, schema):
+        model_field = self.type
         field_object_type = model_field.get_object_type(schema)
+        if not field_object_type:
+            raise SkipField()
         if is_node(field_object_type):
-            field = SQLAlchemyConnectionField(model_field)
+            field = SQLAlchemyConnectionField(field_object_type)
         else:
-            field = LazyListField(model_field)
-        field.contribute_to_class(self.object_type, self.name)
-        return field
+            field = LazyListField(field_object_type)
+        field.contribute_to_class(self.object_type, self.attname)
+        return schema.T(field)
 
 
-class SQLAlchemyModelField(Field):
+class SQLAlchemyModelField(FieldType):
 
     def __init__(self, model, *args, **kwargs):
-        super(SQLAlchemyModelField, self).__init__(None, *args, **kwargs)
         self.model = model
-
-    def resolve(self, instance, args, info):
-        resolved = super(SQLAlchemyModelField, self).resolve(instance, args, info)
-        schema = info.schema.graphene_schema
-        _type = self.get_object_type(schema)
-        assert _type, ("Field %s cannot be retrieved as the "
-                       "ObjectType is not registered by the schema" % (
-                           self.attname
-                       ))
-        return _type(resolved)
+        super(SQLAlchemyModelField, self).__init__(*args, **kwargs)
 
     def internal_type(self, schema):
         _type = self.get_object_type(schema)
-        if not _type and self.object_type._meta.only_fields:
+        if not _type and self.parent._meta.only_fields:
             raise Exception(
-                "Model %r is not accessible by the schema. "
+                "Table %r is not accessible by the schema. "
                 "You can either register the type manually "
                 "using @schema.register. "
-                "Or disable the field %s in %s" % (
+                "Or disable the field in %s" % (
                     self.model,
-                    self.attname,
-                    self.object_type
+                    self.parent,
                 )
             )
-        return schema.T(_type) or Field.SKIP
+        if not _type:
+            raise SkipField()
+        return schema.T(_type)
 
     def get_object_type(self, schema):
         return get_type_for_model(schema, self.model)

graphene/contrib/sqlalchemy/options.py

@@ -1,23 +1,23 @@
 import inspect
 
-from sqlalchemy import Table
+from sqlalchemy.ext.declarative.api import DeclarativeMeta
 
-from graphene.core.options import Options
-from graphene.relay.types import Node
-from graphene.relay.utils import is_node
+from ...core.options import Options
+from ...relay.types import Node
+from ...relay.utils import is_node
 
-VALID_ATTRS = ('table', 'only_columns', 'exclude_columns')
+VALID_ATTRS = ('model', 'only_fields', 'exclude_fields')
 
 
 def is_base(cls):
-    from graphene.contrib.SQLAlchemy.types import SQLAlchemyObjectType
+    from graphene.contrib.sqlalchemy.types import SQLAlchemyObjectType
     return SQLAlchemyObjectType in cls.__bases__
 
 
 class SQLAlchemyOptions(Options):
 
     def __init__(self, *args, **kwargs):
-        self.table = None
+        self.model = None
         super(SQLAlchemyOptions, self).__init__(*args, **kwargs)
         self.valid_attrs += VALID_ATTRS
         self.only_fields = None
@@ -30,8 +30,8 @@ def contribute_to_class(self, cls, name):
             self.interfaces.append(Node)
         if not is_node(cls) and not is_base(cls):
             return
-        if not self.table:
+        if not self.model:
             raise Exception(
-                'SQLAlchemy ObjectType %s must have a table in the Meta class attr' % cls)
-        elif not inspect.isclass(self.table) or not issubclass(self.table, Table):
-            raise Exception('Provided table in %s is not a SQLAlchemy table' % cls)
+                '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/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import absolute_import
+
+from sqlalchemy import Table, Column, Integer, String, Date, ForeignKey
+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')))
+
+
+class Pet(Base):
+    __tablename__ = 'pets'
+    id = Column(Integer(), primary_key=True)
+    name = Column(String(30))
+    reporter_id = Column(Integer(), ForeignKey('reporters.id'))
+
+
+class Reporter(Base):
+    __tablename__ = 'reporters'
+    id = Column(Integer(), primary_key=True)
+    first_name = Column(String(30))
+    last_name = Column(String(30))
+    email = Column(String())
+    pets = relationship('Pet', secondary=association_table, backref='reporters')
+    articles = relationship('Article', backref='reporter')
+
+
+class Article(Base):
+    __tablename__ = 'articles'
+    id = Column(Integer(), primary_key=True)
+    headline = Column(String(100))
+    pub_date = Column(Date())
+    reporter_id = Column(Integer(), ForeignKey('reporters.id'))

graphene/contrib/sqlalchemy/tests/models.py

@@ -0,0 +1,103 @@
+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 .models import Article, Reporter, Pet
+
+
+def assert_column_conversion(sqlalchemy_type, graphene_field, **kwargs):
+    column = Column(sqlalchemy_type, doc='Custom Help Text', **kwargs)
+    graphene_type = convert_sqlalchemy_column(column)
+    assert isinstance(graphene_type, graphene_field)
+    field = graphene_type.as_field()
+    assert field.description == 'Custom Help Text'
+    return field
+
+
+def test_should_unknown_sqlalchemy_field_raise_exception():
+    with raises(Exception) as excinfo:
+        convert_sqlalchemy_column(None)
+    assert 'Don\'t know how to convert the SQLAlchemy field' in str(excinfo.value)
+
+
+def test_should_date_convert_string():
+    assert_column_conversion(types.Date(), graphene.String)
+
+
+def test_should_datetime_convert_string():
+    assert_column_conversion(types.DateTime(), graphene.String)
+
+
+def test_should_time_convert_string():
+    assert_column_conversion(types.Time(), graphene.String)
+
+
+def test_should_string_convert_string():
+    assert_column_conversion(types.String(), graphene.String)
+
+
+def test_should_text_convert_string():
+    assert_column_conversion(types.Text(), graphene.String)
+
+
+def test_should_unicode_convert_string():
+    assert_column_conversion(types.Unicode(), graphene.String)
+
+
+def test_should_unicodetext_convert_string():
+    assert_column_conversion(types.UnicodeText(), graphene.String)
+
+
+def test_should_enum_convert_string():
+    assert_column_conversion(types.Enum(), graphene.String)
+
+
+def test_should_small_integer_convert_int():
+    assert_column_conversion(types.SmallInteger(), graphene.Int)
+
+
+def test_should_big_integer_convert_int():
+    assert_column_conversion(types.BigInteger(), graphene.Int)
+
+
+def test_should_integer_convert_int():
+    assert_column_conversion(types.Integer(), graphene.Int)
+
+
+def test_should_integer_convert_id():
+    assert_column_conversion(types.Integer(), graphene.ID, primary_key=True)
+
+
+def test_should_boolean_convert_boolean():
+    field = assert_column_conversion(types.Boolean(), graphene.Boolean)
+
+
+def test_should_float_convert_float():
+    assert_column_conversion(types.Float(), graphene.Float)
+
+
+def test_should_numeric_convert_float():
+    assert_column_conversion(types.Numeric(), graphene.Float)
+
+
+def test_should_manytomany_convert_connectionorlist():
+    graphene_type = convert_sqlalchemy_relationship(Reporter.pets.property)
+    assert isinstance(graphene_type, ConnectionOrListField)
+    assert isinstance(graphene_type.type, SQLAlchemyModelField)
+    assert graphene_type.type.model == Pet
+
+
+def test_should_manytoone_convert_connectionorlist():
+    field = convert_sqlalchemy_relationship(Article.reporter.property)
+    assert isinstance(field, SQLAlchemyModelField)
+    assert field.model == Reporter
+
+
+def test_should_onetomany_convert_model():
+    graphene_type = convert_sqlalchemy_relationship(Reporter.articles.property)
+    assert isinstance(graphene_type, ConnectionOrListField)
+    assert isinstance(graphene_type.type, SQLAlchemyModelField)
+    assert graphene_type.type.model == Article