Allow subclassing of SQLAlchemyObjectType without major API changes

README.md

@@ -68,6 +68,38 @@ query = '''
 result = schema.execute(query, context_value={'session': db_session})
 ```
 
+You may also subclass SQLAlchemyObjectType by providing `abstract = True` in
+your subclasses Meta:
+```python
+from graphene_sqlalchemy import SQLAlchemyObjectType
+
+class ActiveSQLAlchemyObjectType(SQLAlchemyObjectType):
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def get_node(cls, id, context, info):
+        return cls.get_query(context).\
+            filter(and_(
+                cls._meta.model.deleted_at==None,
+                cls._meta.model.id==id,
+            )).\
+            first()
+
+class User(ActiveSQLAlchemyObjectType):
+    class Meta:
+        model = UserModel
+
+class Query(graphene.ObjectType):
+    users = graphene.List(User)
+
+    def resolve_users(self, args, context, info):
+        query = User.get_query(context) # SQLAlchemy query
+        return query.all()
+
+schema = graphene.Schema(query=Query)
+```
+
 To learn more check out the following [examples](examples/):
 
 * **Full example**: [Flask SQLAlchemy example](examples/flask_sqlalchemy)

graphene_sqlalchemy/registry.py

@@ -6,10 +6,11 @@ def __init__(self):
         self._registry_composites = {}
 
     def register(self, cls):
-        from .types import SQLAlchemyObjectType
-        assert issubclass(
-            cls, SQLAlchemyObjectType), 'Only SQLAlchemyObjectType can be registered, received "{}"'.format(
-            cls.__name__)
+        from .types import SQLAlchemyObjectTypeMeta
+        assert issubclass(type(cls), SQLAlchemyObjectTypeMeta), (
+            'Only classes of type SQLAlchemyObjectTypeMeta can be registered, ',
+            'received "{}"'
+        ).format(cls.__name__)
         assert cls._meta.registry == self, 'Registry for a Model have to match.'
         # assert self.get_type_for_model(cls._meta.model) in [None, cls], (
         #     'SQLAlchemy model "{}" already associated with '

graphene_sqlalchemy/tests/test_types.py

@@ -1,9 +1,10 @@
 
 from graphene import Field, Int, Interface, ObjectType
 from graphene.relay import Node, is_node
+import six
 
 from ..registry import Registry
-from ..types import SQLAlchemyObjectType
+from ..types import SQLAlchemyObjectType, SQLAlchemyObjectTypeMeta
 from .models import Article, Reporter
 
 registry = Registry()
@@ -74,3 +75,31 @@ def test_object_type():
     assert issubclass(Human, ObjectType)
     assert list(Human._meta.fields.keys()) == ['id', 'headline', 'reporter_id', 'reporter', 'pub_date']
     assert is_node(Human)
+
+
+
+# Test Custom SQLAlchemyObjectType Implementation
+class CustomSQLAlchemyObjectType(SQLAlchemyObjectType):
+    class Meta:
+        abstract = True
+
+
+class CustomCharacter(CustomSQLAlchemyObjectType):
+    '''Character description'''
+    class Meta:
+        model = Reporter
+        registry = registry
+
+
+def test_custom_objecttype_registered():
+    assert issubclass(CustomCharacter, ObjectType)
+    assert CustomCharacter._meta.model == Reporter
+    assert list(
+        CustomCharacter._meta.fields.keys()) == [
+        'id',
+        'first_name',
+        'last_name',
+        'email',
+        'pets',
+        'articles',
+        'favorite_article']

graphene_sqlalchemy/types.py

@@ -82,9 +82,15 @@ def __new__(cls, name, bases, attrs):
             exclude_fields=(),
             id='id',
             interfaces=(),
-            registry=None
+            registry=None,
+            abstract=False,
         )
 
+        cls = ObjectTypeMeta.__new__(cls, name, bases, dict(attrs, _meta=options))
+
+        if options.abstract:
+            return cls
+
         if not options.registry:
             options.registry = get_global_registry()
         assert isinstance(options.registry, Registry), (
@@ -96,8 +102,6 @@ def __new__(cls, name, bases, attrs):
             '{}.Meta, received "{}".'
         ).format(name, options.model)
 
-        cls = ObjectTypeMeta.__new__(cls, name, bases, dict(attrs, _meta=options))
-
         options.registry.register(cls)
 
         options.sqlalchemy_fields = yank_fields_from_attrs(
@@ -115,6 +119,8 @@ def __new__(cls, name, bases, attrs):
 
 
 class SQLAlchemyObjectType(six.with_metaclass(SQLAlchemyObjectTypeMeta, ObjectType)):
+    class Meta:
+        abstract = True
 
     @classmethod
     def is_type_of(cls, root, context, info):

setup.cfg

@@ -7,3 +7,20 @@ omit = */tests/*
 
 [isort]
 known_first_party=graphene,graphene_sqlalchemy
+
+[tool:pytest]
+testpaths = graphene_sqlalchemy/
+addopts =
+    -s
+    ; --cov graphene-sqlalchemy
+norecursedirs =
+    __pycache__
+    *.egg-info
+    .cache
+    .git
+    .tox
+    appdir
+    docs
+filterwarnings =
+    error
+    ignore::DeprecationWarning