Merge pull request #1 from devind-team/develop

Basic functionality

Author: Victor

.flake8

@@ -1,8 +1,9 @@
 [flake8]
+max-line-length = 100
 per-file-ignores =
     __init__.py:F401
     connection_field.py:A002
-ignore = ANN101,ANN102,D107
+ignore = ANN002,ANN003,ANN101,ANN102,D106,D107
 
 import-order-style = pycharm
 dictionaries=en_US,python,technical,django

.pre-commit-config.yaml

@@ -25,7 +25,6 @@ repos:
             - flake8-comprehensions
             - flake8-eradicate
             - flake8-simplify
-            - flake8-spellcheck
             - pep8-naming
             - flake8-use-fstring
             - flake8-annotations

README.md

@@ -1,2 +1,133 @@
-# graphene-django-filter
-Advanced filters for Graphene.
+# Graphene-Django-Filter
+[![CI](https://github.com/devind-team/graphene-django-filter/workflows/CI/badge.svg)](https://github.com/devind-team/graphene-django-filter/actions) [![PyPI version](https://badge.fury.io/py/graphene-django-filter.svg)](https://badge.fury.io/py/graphene-django-filter)
+
+This package contains advanced filters for [graphene-django](https://github.com/graphql-python/graphene-django). The standard filtering feature in Graphene-Django relies on the Django-Filter library and therefore provides a flat API without the ability to use `and` and `or` expressions. This library makes the API nested and adds the `and` and `or` composition by extension of the `DjangoFilterConnectionField` field and the `FilterSet` class.
+# Requirements
+* Python (3.6, 3.7, 3.8, 3.9, 3.10)
+* Graphene-Django (2.15)
+# Features
+## Nested API with the ability to use `and` and `or` expressions
+To use, simply replace all `DjangoFilterConnectionField` fields with `AdvancedDjangoFilterConnectionField` fields in your queries. Also, if you create custom FilterSets, replace the inheritance from the `FilterSet` class with the inheritance from the `AdvancedFilterSet` class. For example, the following task query exposes an old flat API.
+```python
+import graphene
+from django_filters import FilterSet
+from graphene_django import DjangoObjectType
+from graphene_django.filter import DjangoFilterConnectionField
+
+class TaskFilter(FilterSet)
+    class Meta:
+        model = Task
+        fields = {
+            'name': ('exact', 'contains'),
+            'user__email': ('exact', 'contains'),
+            'user__last_name': ('exact', 'contains'),
+        }
+ 
+class UserType(DjangoObjectType):
+    class Meta:
+        model = User
+        interfaces = (graphene.relay.Node,)
+        fields = '__all__'
+        
+class TaskType(DjangoObjectType):
+    user = graphene.Field(UserType)
+
+    class Meta:
+        model = Task
+        interfaces = (graphene.relay.Node,)
+        fields = '__all__'
+        filterset_class = TaskFilter
+        
+class Query(graphene.ObjectType):
+    tasks = DjangoFilterConnectionField(TaskType)
+```
+The flat API in which all filters are applied using the "and" operator looks like this.
+```graphql
+{
+  tasks(
+    name_Contains: "important"
+    user_Email_Contains: "john"
+    user_LastName: "Dou"
+  ){
+    edges {
+      node {
+        id
+        name
+      }
+    }
+  }
+}
+```
+After replacing the field class with the `AdvancedDjangoFilterConnectionField` and the `FilterSet` class with the `AdvancedFilterSet` the API becomes nested with support for `and` and `or` expressions.
+```python
+from graphene_django_filter import AdvancedDjangoFilterConnectionField, AdvancedFilterSet
+
+class TaskFilter(AdvancedFilterSet)
+    class Meta:
+        model = Task
+        fields = {
+            'name': ('exact', 'contains'),
+            'user__email': ('exact', 'contains'),
+            'user__last_name': ('exact', 'contains'),
+        }
+
+class Query(graphene.ObjectType):
+    tasks = AdvancedDjangoFilterConnectionField(TaskType)
+```
+For example, the following query returns tasks whose names contain the word "important" or the user's email address contains the word "john" and the user's last name is "Dou". Note that the operators are applied to lookups such as `contains`, `exact`, etc. at the last level of nesting.
+```graphql
+{
+  tasks(
+    filter: {
+      or: [
+        {name: {contains: "important"}}
+        and: [
+          {user: email: {contains: "john"}}
+          {user: lastName: {exact: "Dou"}}
+        ]
+      ]
+    }
+  ){
+    edges {
+      node {
+        id
+        name
+      }
+    }
+  }
+}
+```
+The same result can be achieved with an alternative query structure because within the same object the `and` operator is always used.
+```graphql
+{
+  tasks(
+    filter: {
+      or: [
+        {name: {contains: "important"}}
+        {
+          user: {
+            email: {contains: "john"}
+            lastName: {exact: "Dou"}
+          }
+        }
+      ]
+    }
+  ){
+    edges {
+      node {
+        id
+        name
+      }
+    }
+  }
+}
+```
+The filter input type has the following structure.
+```graphql
+input FilterInputType {
+  and: [FilterInputType]
+  or: [FilterInputType]
+  ...FieldLookups
+}
+```
+For more examples, see tests.

graphene_django_filter/__init__.py

@@ -2,4 +2,5 @@
 
 __version__ = '0.3.0'
 
-from .connection_field import DjangoFilterConnectionField
+from .connection_field import AdvancedDjangoFilterConnectionField
+from .filterset import AdvancedFilterSet

graphene_django_filter/connection_field.py

@@ -1,13 +1,88 @@
-"""DjangoFilterConnectionField module.
+"""`AdvancedDjangoFilterConnectionField` class module.
 
-Use DjangoFilterConnectionField class from this
-module instead of graphene_django one.
+Use the `AdvancedDjangoFilterConnectionField` class from this
+module instead of the `DjangoFilterConnectionField` from graphene-django.
 """
 
-from graphene_django import DjangoConnectionField
+from typing import Any, Dict, Iterable, Optional, Type
 
+import graphene
+from django.core.exceptions import ValidationError
+from django.db import models
+from django_filters import FilterSet
+from graphene_django import DjangoObjectType
+from graphene_django.filter import DjangoFilterConnectionField
 
-class DjangoFilterConnectionField(DjangoConnectionField):
-    """Allow to use advanced filters provided by this library."""
+from .filterset import AdvancedFilterSet, tree_input_type_to_data
+from .filterset_factories import get_filterset_class
+from .input_type_factories import get_filtering_args_from_filterset
 
-    pass
+
+class AdvancedDjangoFilterConnectionField(DjangoFilterConnectionField):
+    """Allow you to use advanced filters provided by this library."""
+
+    def __init__(
+        self,
+        type: Type[DjangoObjectType],
+        fields: Optional[Dict[str, list]] = None,
+        order_by: Any = None,
+        extra_filter_meta: Optional[dict] = None,
+        filterset_class: Optional[Type[AdvancedFilterSet]] = None,
+        *args,
+        **kwargs
+    ) -> None:
+        assert filterset_class is None or issubclass(filterset_class, AdvancedFilterSet), \
+            'Use the `AdvancedFilterSet` class with the `AdvancedDjangoFilterConnectionField`'
+        super().__init__(
+            type,
+            fields,
+            order_by,
+            extra_filter_meta,
+            filterset_class,
+            *args,
+            **kwargs
+        )
+
+    @property
+    def filterset_class(self) -> Type[AdvancedFilterSet]:
+        """Return a AdvancedFilterSet instead of a FilterSet."""
+        if not self._filterset_class:
+            fields = self._fields or self.node_type._meta.filter_fields
+            meta = {'model': self.model, 'fields': fields}
+            if self._extra_filter_meta:
+                meta.update(self._extra_filter_meta)
+            filterset_class = self._provided_filterset_class or (
+                self.node_type._meta.filterset_class
+            )
+            self._filterset_class = get_filterset_class(filterset_class, **meta)
+        return self._filterset_class
+
+    @property
+    def filtering_args(self) -> dict:
+        """Return filtering args from the filterset."""
+        if not self._filtering_args:
+            self._filtering_args = get_filtering_args_from_filterset(
+                self.filterset_class, self.node_type,
+            )
+        return self._filtering_args
+
+    @classmethod
+    def resolve_queryset(
+        cls,
+        connection: object,
+        iterable: Iterable,
+        info: graphene.ResolveInfo,
+        args: Dict[str, Any],
+        filtering_args: Dict[str, graphene.InputField],
+        filterset_class: Type[FilterSet],
+    ) -> models.QuerySet:
+        """Return a filtered QuerySet."""
+        qs = super(DjangoFilterConnectionField, cls).resolve_queryset(
+            connection, iterable, info, args,
+        )
+        filterset = filterset_class(
+            data=tree_input_type_to_data(args['filter']), queryset=qs, request=info.context,
+        )
+        if filterset.form.is_valid():
+            return filterset.qs
+        raise ValidationError(filterset.form.errors.as_json())