Add sort enum cache to avoid name clash.

Author: CaselIT

examples/flask_sqlalchemy/schema.py

@@ -34,10 +34,10 @@ class Meta:
 
 class Query(graphene.ObjectType):
     node = relay.Node.Field()
-    # Supports sorting only over one field
+    # Allow only single column sorting
     all_employees = SQLAlchemyConnectionField(Employee, sort=graphene.Argument(SortEnumEmployee,
             default_value=utils.EnumValue('id_asc', EmployeeModel.id.asc())))
-    # Add sort over multiple fields, sorting by default over the primary key
+    # Add sort over multiple columns, sorting by default over the primary key
     all_roles = SQLAlchemyConnectionField(Role)
     # Disable sorting over this field
     all_departments = SQLAlchemyConnectionField(Department, sort=None)

graphene_sqlalchemy/fields.py

@@ -9,7 +9,7 @@
 from .utils import get_query, sort_argument_for_model
 
 
-class _UnsortedSQLAlchemyConnectionField(ConnectionField):
+class UnsortedSQLAlchemyConnectionField(ConnectionField):
 
     @property
     def model(self):
@@ -20,9 +20,9 @@ def get_query(cls, model, info, sort=None, **args):
         query = get_query(model, info.context)
         if sort is not None:
             if isinstance(sort, str):
-                query = query.order_by(sort.order)
+                query = query.order_by(sort.value)
             else:
-                query = query.order_by(*(value.order for value in sort))
+                query = query.order_by(*(col.value for col in sort))
         return query
 
     @property
@@ -62,7 +62,7 @@ def get_resolver(self, parent_resolver):
         return partial(self.connection_resolver, parent_resolver, self.type, self.model)
 
 
-class SQLAlchemyConnectionField(_UnsortedSQLAlchemyConnectionField):
+class SQLAlchemyConnectionField(UnsortedSQLAlchemyConnectionField):
 
     def __init__(self, type, *args, **kwargs):
         if 'sort' not in kwargs:
@@ -72,7 +72,7 @@ def __init__(self, type, *args, **kwargs):
         super(SQLAlchemyConnectionField, self).__init__(type, *args, **kwargs)
 
 
-__connectionFactory = _UnsortedSQLAlchemyConnectionField
+__connectionFactory = UnsortedSQLAlchemyConnectionField
 
 
 def createConnectionField(_type):
@@ -86,4 +86,4 @@ def registerConnectionFieldFactory(factoryMethod):
 
 def unregisterConnectionFieldFactory():
     global __connectionFactory
-    __connectionFactory = _UnsortedSQLAlchemyConnectionField
+    __connectionFactory = UnsortedSQLAlchemyConnectionField

graphene_sqlalchemy/tests/test_converter.py

@@ -16,7 +16,7 @@
 from ..converter import (convert_sqlalchemy_column,
                          convert_sqlalchemy_composite,
                          convert_sqlalchemy_relationship)
-from ..fields import _UnsortedSQLAlchemyConnectionField
+from ..fields import UnsortedSQLAlchemyConnectionField
 from ..registry import Registry
 from ..types import SQLAlchemyObjectType
 from .models import Article, Pet, Reporter
@@ -205,7 +205,7 @@ class Meta:
 
     dynamic_field = convert_sqlalchemy_relationship(Reporter.pets.property, A._meta.registry)
     assert isinstance(dynamic_field, graphene.Dynamic)
-    assert isinstance(dynamic_field.get_type(), _UnsortedSQLAlchemyConnectionField)
+    assert isinstance(dynamic_field.get_type(), UnsortedSQLAlchemyConnectionField)
 
 
 def test_should_manytoone_convert_connectionorlist():

graphene_sqlalchemy/utils.py

@@ -43,17 +43,24 @@ def _symbol_name(column_name, is_asc):
 
 
 class EnumValue(str):
-    '''Subclass of str that stores a string value and the sort order of the column'''
-    def __new__(cls, str_value, order):
+    '''Subclass of str that stores a string and an arbitrary value in the "value" property'''
+
+    def __new__(cls, str_value, value):
         return super(EnumValue, cls).__new__(cls, str_value)
 
-    def __init__(self, str_value, order):
+    def __init__(self, str_value, value):
         super(EnumValue, self).__init__()
-        self.order = order
+        self.value = value
+
+
+# Cache for the generated enums, to avoid name clash
+_ENUM_CACHE = {}
 
 
 def _sort_enum_for_model(cls, name=None, symbol_name=_symbol_name):
     name = name or cls.__name__ + 'SortEnum'
+    if name in _ENUM_CACHE:
+        return _ENUM_CACHE[name]
     items = []
     default = []
     for column in inspect(cls).columns.values():
@@ -64,7 +71,9 @@ def _sort_enum_for_model(cls, name=None, symbol_name=_symbol_name):
         if column.primary_key:
             default.append(asc_value)
         items.extend(((asc_name, asc_value), (desc_name, desc_value)))
-    return Enum(name, items), default
+    enum = Enum(name, items)
+    _ENUM_CACHE[name] = (enum, default)
+    return enum, default
 
 
 def sort_enum_for_model(cls, name=None, symbol_name=_symbol_name):
@@ -89,7 +98,7 @@ def sort_enum_for_model(cls, name=None, symbol_name=_symbol_name):
 
 
 def sort_argument_for_model(cls, has_default=True):
-    '''Returns an Graphene argument for the sort field that accepts a list of sorting directions for a model.
+    '''Returns a Graphene argument for the sort field that accepts a list of sorting directions for a model.
     If `has_default` is True (the default) it will sort the result by the primary key(s)
     '''
     enum, default = _sort_enum_for_model(cls)