fix: create special enum filters. Code pending refactor.

Author: erikwrede

graphene_sqlalchemy/filters.py

@@ -49,7 +49,6 @@ def __init_subclass_with_meta__(
         logic_functions = _get_functions_by_regex(".+_logic$", "_logic$", cls)
 
         new_filter_fields = {}
-        print(f"Generating Filter for {cls.__name__} with model {model} ")
         # Generate Graphene Fields from the filter functions based on type hints
         for field_name, _annotations in logic_functions:
             assert (
@@ -70,9 +69,6 @@ def __init_subclass_with_meta__(
             _meta.fields = filter_fields
         _meta.fields.update(new_filter_fields)
 
-        for field in _meta.fields:
-            print(f"Added field {field} of type {_meta.fields[field].type}")
-
         _meta.model = model
 
         super(BaseTypeFilter, cls).__init_subclass_with_meta__(_meta=_meta, **options)
@@ -289,6 +285,48 @@ def execute_filters(
 
         return query, clauses
 
+class SQLEnumFilter(FieldFilter):
+    """Basic Filter for Scalars in Graphene.
+    We want this filter to use Dynamic fields so it provides the base
+    filtering methods ("eq, nEq") for different types of scalars.
+    The Dynamic fields will resolve to Meta.filtered_type"""
+    class Meta:
+        graphene_type = graphene.Enum
+
+    # Abstract methods can be marked using ScalarFilterInputType. See comment on the init method
+    @classmethod
+    def eq_filter(
+        cls, query, field, val: ScalarFilterInputType
+    ) -> Union[Tuple[Query, Any], Any]:
+        return field == val.value
+
+    @classmethod
+    def n_eq_filter(
+        cls, query, field, val: ScalarFilterInputType
+    ) -> Union[Tuple[Query, Any], Any]:
+        return not_(field == val.value)
+
+class PyEnumFilter(FieldFilter):
+    """Basic Filter for Scalars in Graphene.
+    We want this filter to use Dynamic fields so it provides the base
+    filtering methods ("eq, nEq") for different types of scalars.
+    The Dynamic fields will resolve to Meta.filtered_type"""
+    class Meta:
+        graphene_type = graphene.Enum
+
+    # Abstract methods can be marked using ScalarFilterInputType. See comment on the init method
+    @classmethod
+    def eq_filter(
+        cls, query, field, val: ScalarFilterInputType
+    ) -> Union[Tuple[Query, Any], Any]:
+        return field == val
+
+    @classmethod
+    def n_eq_filter(
+        cls, query, field, val: ScalarFilterInputType
+    ) -> Union[Tuple[Query, Any], Any]:
+        return not_(field == val)
+
 
 class StringFilter(FieldFilter):
     class Meta:

graphene_sqlalchemy/registry.py

@@ -1,18 +1,16 @@
 from collections import defaultdict
 from typing import TYPE_CHECKING, List, Type
 
-from sqlalchemy.types import Enum as SQLAlchemyEnumType
-
 import graphene
 from graphene import Enum
 from graphene.types.base import BaseType
+from sqlalchemy.types import Enum as SQLAlchemyEnumType
 
 if TYPE_CHECKING:  # pragma: no_cover
     from graphene_sqlalchemy.filters import (
         FieldFilter,
         BaseTypeFilter,
-        RelationshipFilter,
-    )
+        RelationshipFilter, )
 
 
 class Registry(object):
@@ -81,7 +79,7 @@ def register_sort_enum(self, obj_type, sort_enum: Enum):
         from .types import SQLAlchemyObjectType
 
         if not isinstance(obj_type, type) or not issubclass(
-            obj_type, SQLAlchemyObjectType
+                obj_type, SQLAlchemyObjectType
         ):
             raise TypeError(
                 "Expected SQLAlchemyObjectType, but got: {!r}".format(obj_type)
@@ -94,7 +92,7 @@ def get_sort_enum_for_object_type(self, obj_type: graphene.ObjectType):
         return self._registry_sort_enums.get(obj_type)
 
     def register_union_type(
-        self, union: Type[graphene.Union], obj_types: List[Type[graphene.ObjectType]]
+            self, union: Type[graphene.Union], obj_types: List[Type[graphene.ObjectType]]
     ):
         if not issubclass(union, graphene.Union):
             raise TypeError("Expected graphene.Union, but got: {!r}".format(union))
@@ -112,7 +110,7 @@ def get_union_for_object_types(self, obj_types: List[Type[graphene.ObjectType]])
 
     # Filter Scalar Fields of Object Types
     def register_filter_for_scalar_type(
-        self, scalar_type: Type[graphene.Scalar], filter_obj: Type["FieldFilter"]
+            self, scalar_type: Type[graphene.Scalar], filter_obj: Type["FieldFilter"]
     ):
         from .filters import FieldFilter
 
@@ -123,21 +121,49 @@ def register_filter_for_scalar_type(
             raise TypeError("Expected ScalarFilter, but got: {!r}".format(filter_obj))
         self._registry_scalar_filters[scalar_type] = filter_obj
 
+    def get_filter_for_sql_enum_type(
+            self, enum_type: Type[graphene.Enum]
+    ) -> Type["FieldFilter"]:
+        from .filters import SQLEnumFilter
+
+        filter_type = self._registry_scalar_filters.get(enum_type)
+        if not filter_type:
+            filter_type = SQLEnumFilter.create_type(
+                f"Default{enum_type.__name__}EnumFilter", graphene_type=enum_type
+            )
+            self._registry_scalar_filters[enum_type] = filter_type
+        return filter_type
+
+    def get_filter_for_py_enum_type(
+            self, enum_type: Type[graphene.Enum]
+    ) -> Type["FieldFilter"]:
+        from .filters import PyEnumFilter
+
+        filter_type = self._registry_scalar_filters.get(enum_type)
+        if not filter_type:
+            filter_type = PyEnumFilter.create_type(
+                f"Default{enum_type.__name__}EnumFilter", graphene_type=enum_type
+            )
+            self._registry_scalar_filters[enum_type] = filter_type
+        return filter_type
+
     def get_filter_for_scalar_type(
-        self, scalar_type: Type[graphene.Scalar]
+            self, scalar_type: Type[graphene.Scalar]
     ) -> Type["FieldFilter"]:
         from .filters import FieldFilter
 
         filter_type = self._registry_scalar_filters.get(scalar_type)
         if not filter_type:
-            return FieldFilter.create_type(
+            filter_type = FieldFilter.create_type(
                 f"Default{scalar_type.__name__}ScalarFilter", graphene_type=scalar_type
             )
+            self._registry_scalar_filters[scalar_type] = filter_type
+
         return filter_type
 
     # TODO register enums automatically
     def register_filter_for_enum_type(
-        self, enum_type: Type[graphene.Enum], filter_obj: Type["FieldFilter"]
+            self, enum_type: Type[graphene.Enum], filter_obj: Type["FieldFilter"]
     ):
         from .filters import FieldFilter
 
@@ -148,16 +174,11 @@ def register_filter_for_enum_type(
             raise TypeError("Expected FieldFilter, but got: {!r}".format(filter_obj))
         self._registry_scalar_filters[enum_type] = filter_obj
 
-    def get_filter_for_enum_type(
-        self, enum_type: Type[graphene.Enum]
-    ) -> Type["FieldFilter"]:
-        return self._registry_enum_type_filters.get(enum_type)
-
     # Filter Base Types
     def register_filter_for_base_type(
-        self,
-        base_type: Type[BaseType],
-        filter_obj: Type["BaseTypeFilter"],
+            self,
+            base_type: Type[BaseType],
+            filter_obj: Type["BaseTypeFilter"],
     ):
         from .filters import BaseTypeFilter
 
@@ -175,7 +196,7 @@ def get_filter_for_base_type(self, base_type: Type[BaseType]):
 
     # Filter Relationships between base types
     def register_relationship_filter_for_base_type(
-        self, base_type: BaseType, filter_obj: Type["RelationshipFilter"]
+            self, base_type: BaseType, filter_obj: Type["RelationshipFilter"]
     ):
         from .filters import RelationshipFilter
 
@@ -189,7 +210,7 @@ def register_relationship_filter_for_base_type(
         self._registry_relationship_filters[base_type] = filter_obj
 
     def get_relationship_filter_for_base_type(
-        self, base_type: Type[BaseType]
+            self, base_type: Type[BaseType]
     ) -> "RelationshipFilter":
         return self._registry_relationship_filters.get(base_type)
 

graphene_sqlalchemy/tests/conftest.py

@@ -1,14 +1,15 @@
+from typing import Literal
+
+import graphene
 import pytest
 import pytest_asyncio
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
-import graphene
 from graphene_sqlalchemy.utils import SQL_VERSION_HIGHER_EQUAL_THAN_1_4
-
+from .models import Base, CompositeFullName
 from ..converter import convert_sqlalchemy_composite
 from ..registry import reset_global_registry
-from .models import Base, CompositeFullName
 
 if SQL_VERSION_HIGHER_EQUAL_THAN_1_4:
     from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
@@ -25,23 +26,32 @@ def convert_composite_class(composite, registry):
         return graphene.Field(graphene.Int)
 
 
-@pytest.fixture(params=[False, True])
-def async_session(request):
+# make a typed literal for session one is sync and one is async
+SESSION_TYPE = Literal["sync", "session_factory"]
+
+
+@pytest.fixture(params=["sync", "async"])
+def session_type(request) -> SESSION_TYPE:
     return request.param
 
 
 @pytest.fixture
-def test_db_url(async_session: bool):
-    if async_session:
+def async_session(session_type):
+    return session_type == "async"
+
+
+@pytest.fixture
+def test_db_url(session_type: SESSION_TYPE):
+    if session_type == "async":
         return "sqlite+aiosqlite://"
     else:
         return "sqlite://"
 
 
 @pytest.mark.asyncio
 @pytest_asyncio.fixture(scope="function")
-async def session_factory(async_session: bool, test_db_url: str):
-    if async_session:
+async def session_factory(session_type: SESSION_TYPE, test_db_url: str):
+    if session_type == "async":
         if not SQL_VERSION_HIGHER_EQUAL_THAN_1_4:
             pytest.skip("Async Sessions only work in sql alchemy 1.4 and above")
         engine = create_async_engine(test_db_url)

graphene_sqlalchemy/tests/test_filters.py

@@ -218,20 +218,21 @@ async def test_filter_enum(session):
     query = """
         query {
           reporters (filter: {
-            favoritePetKind: {eq: "dog"}
+            favoritePetKind: {eq: DOG}
         }
           ) {
             edges {
                 node {
                     firstName
                     lastName
+                    favoritePetKind
                 }
             }
           }
         }
     """
     expected = {
-        "pets": {"edges": [{"node": {"firstName": "Jane", "lastName": "Roe"}}]},
+        "reporters": {"edges": [{"node": {"firstName": "Jane", "lastName": "Roe", "favoritePetKind": "DOG"}}]},
     }
     schema = graphene.Schema(query=Query)
     result = await schema.execute_async(query, context_value={"session": session})
@@ -243,7 +244,7 @@ async def test_filter_enum(session):
           pets (filter: {
             and: [
               { hairKind: {eq: LONG} },
-              { petKind: {eq: "dog"} }
+              { petKind: {eq: DOG} }
           ]}) {
             edges {
                 node {
@@ -842,7 +843,7 @@ async def test_filter_logic_and(session):
           reporters (filter: {
             and: [
                 { firstName: { eq: "John" } },
-                { favoritePetKind: { eq: "cat" } },
+                { favoritePetKind: { eq: CAT } },
             ]
         }) {
             edges {
@@ -874,13 +875,14 @@ async def test_filter_logic_or(session):
           reporters (filter: {
             or: [
                 { lastName: { eq: "Woe" } },
-                { favoritePetKind: { eq: "dog" } },
+                { favoritePetKind: { eq: DOG } },
             ]
         }) {
             edges {
                 node {
                     firstName
                     lastName
+                    favoritePetKind
                 }
             }
           }
@@ -889,8 +891,8 @@ async def test_filter_logic_or(session):
     expected = {
         "reporters": {
             "edges": [
-                {"node": {"firstName": "John", "lastName": "Woe"}},
-                # {"node": {"firstName": "Jane", "lastName": "Roe"}},
+                {"node": {"firstName": "John", "lastName": "Woe", "favoritePetKind": "CAT"}},
+                {"node": {"firstName": "Jane", "lastName": "Roe", "favoritePetKind": "DOG"}},
             ]
         }
     }