fix[connection-filter]: connection filter generation error for the following types is fixed.

ListField(EmbeddedDocumentListField(...))
ListField(GenericEmbeddedDocumentField(...))
ListField(GenericLazyReferenceField(...))

Author: mak626

graphene_mongo/fields.py

@@ -163,16 +163,16 @@ def is_filterable(k):
                 ),
             ):
                 return False
-            if (
-                getattr(converted, "type", None)
-                and getattr(converted.type, "_of_type", None)
-                and issubclass((get_type(converted.type.of_type)), graphene.Union)
-            ):
-                return False
-            if isinstance(converted, (graphene.List)) and issubclass(
-                getattr(converted, "_of_type", None), graphene.Union
-            ):
-                return False
+
+            if isinstance(converted, (graphene.List)):
+                sub_type = getattr(converted, "_of_type", None)
+                if hasattr(sub_type, "of_type"):  # graphene.NonNull
+                    sub_type = sub_type.of_type
+                if issubclass(sub_type, graphene.Union) or issubclass(
+                    sub_type, graphene.ObjectType
+                ):
+                    return False
+
             # below if condition: workaround for DB filterable field redefined as custom graphene type
             if (
                 hasattr(field_, "type")

graphene_mongo/tests/models.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from enum import Enum
 
 import mongoengine
 import mongomock
@@ -177,3 +178,38 @@ class Bar(mongoengine.EmbeddedDocument):
 
 class Foo(mongoengine.Document):
     bars = mongoengine.EmbeddedDocumentListField(Bar)
+
+
+class GradeEnum(Enum):
+    A = "A"
+    B = "B"
+
+
+class Student(mongoengine.EmbeddedDocument):
+    name = mongoengine.StringField()
+
+
+class Teacher(mongoengine.EmbeddedDocument):
+    name = mongoengine.StringField()
+
+
+class Bench(mongoengine.Document):
+    size = mongoengine.IntField()
+
+
+class Exam(mongoengine.Document):
+    size = mongoengine.IntField()
+
+
+class SchoolClass(mongoengine.Document):
+    allowed_grades = mongoengine.ListField(mongoengine.EnumField(GradeEnum))
+    subjects = mongoengine.ListField(mongoengine.StringField())
+    students = mongoengine.ListField(mongoengine.EmbeddedDocumentListField(Student))
+    members = mongoengine.ListField(
+        mongoengine.GenericEmbeddedDocumentField(choices=[Student, Teacher])
+    )
+    records = mongoengine.ListField(mongoengine.GenericLazyReferenceField(choices=[Bench, Exam]))
+
+
+class School(mongoengine.Document):
+    classes = mongoengine.ListField(mongoengine.ReferenceField(SchoolClass))

graphene_mongo/tests/test_types.py

@@ -1,13 +1,22 @@
-from pytest import raises
-
 from graphene import Field, Int, Interface, ObjectType
 from graphene.relay import Node, is_node
+from pytest import raises
 
+from .models import (
+    Article,
+    Bench,
+    Child,
+    EmbeddedArticle,
+    Exam,
+    Parent,
+    Reporter,
+    School,
+    SchoolClass,
+    Student,
+)
+from .utils import with_local_registry
 from .. import registry
 from ..types import MongoengineObjectType, MongoengineObjectTypeOptions
-from .models import Article, EmbeddedArticle, Reporter
-from .models import Parent, Child
-from .utils import with_local_registry
 
 registry.reset_global_registry()
 
@@ -83,7 +92,13 @@ def test_node_replacedfield():
 def test_object_type():
     assert issubclass(Human, ObjectType)
     assert set(Human._meta.fields.keys()) == set(
-        ["id", "headline", "pub_date", "editor", "reporter"]
+        [
+            "id",
+            "headline",
+            "pub_date",
+            "editor",
+            "reporter",
+        ]
     )
     assert is_node(Human)
 
@@ -176,3 +191,47 @@ class Meta:
 
     assert hasattr(B._meta, "some_subclass_attr")
     assert B._meta.some_subclass_attr == "someval"
+
+
+@with_local_registry
+def test_filter_list_types():
+    """
+    Test to check filter args should not be generated the following type of fields
+
+    ListField(EmbeddedDocumentListField(...))
+    ListField(GenericEmbeddedDocumentField(...))
+    ListField(GenericLazyReferenceField(...))
+    """
+
+    class ExamType(MongoengineObjectType):
+        class Meta:
+            model = Exam
+
+    class BenchType(MongoengineObjectType):
+        class Meta:
+            model = Bench
+
+    class StudentType(MongoengineObjectType):
+        class Meta:
+            model = Student
+
+    class SchoolClassType(MongoengineObjectType):
+        class Meta:
+            model = SchoolClass
+            interfaces = (Node,)
+
+    class SchoolType(MongoengineObjectType):
+        class Meta:
+            model = School
+            interfaces = (Node,)
+
+    class_type_filter_args = SchoolType._meta.fields["classes"].args
+    assert class_type_filter_args.keys() == {
+        "before",
+        "after",
+        "first",
+        "last",
+        "allowed_grades",
+        "id",
+        "subjects",
+    }

graphene_mongo/utils.py

@@ -235,7 +235,9 @@ def get_queried_union_types(info, valid_gql_types):
                     # This is done to avoid UnionFragments coming in fragments_queries as
                     # we actually need its children types and not the UnionFragments itself
                     fragments_queries.update(sub_query_fields)
-                    fragments_queries.pop('__typename', None)  # cannot resolve __typename for a union type
+                    fragments_queries.pop(
+                        "__typename", None
+                    )  # cannot resolve __typename for a union type
                 else:
                     fragments_queries[fragment_name] = sub_query_fields
             elif leaf.kind == "inline_fragment":