Add support for AND/OR filters to be lists (#762)

Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Thiago Bellini Ribeiro <[email protected]>

Author: 4 people

docs/guide/filters.md

@@ -63,6 +63,44 @@ To every filter `AND`, `OR`, `NOT` & `DISTINCT` fields are added to allow more c
 }
 ```
 
+## List-based AND/OR/NOT Filters
+
+The `AND`, `OR`, and `NOT` operators can also be declared as lists, allowing for more complex combinations of conditions. This is particularly useful when you need to combine multiple conditions in a single operation.
+
+```python title="types.py"
+@strawberry_django.filter_type(models.Vegetable, lookups=True)
+class VegetableFilter:
+    id: auto
+    name: auto
+    AND: Optional[list[Self]] = strawberry.UNSET
+    OR: Optional[list[Self]] = strawberry.UNSET
+    NOT: Optional[list[Self]] = strawberry.UNSET
+```
+
+This enables queries like:
+
+```graphql
+{
+  vegetables(
+    filters: {
+      AND: [{ name: { contains: "blue" } }, { name: { contains: "squash" } }]
+    }
+  ) {
+    id
+  }
+}
+```
+
+The list-based filtering system differs from the single object filter in a few ways:
+
+1. It allows combining multiple conditions in a single `AND`, `OR`, or `NOT` operation
+2. The conditions in a list are evaluated together as a group
+3. When using `AND`, all conditions in the list must be satisfied
+4. When using `OR`, any condition in the list can be satisfied
+5. When using `NOT`, none of the conditions in the list should be satisfied
+
+This is particularly useful for complex queries where you need to have multiple conditions against the same field.
+
 ## Lookups
 
 Lookups can be added to all fields with `lookups=True`, which will

strawberry_django/filters.py

@@ -2,6 +2,7 @@
 
 import functools
 import inspect
+import operator
 import warnings
 from enum import Enum
 from types import FunctionType
@@ -194,19 +195,33 @@ def process_filters(
             if field_value:
                 queryset = queryset.distinct()
         elif field_name in ("AND", "OR", "NOT"):  # noqa: PLR6201
-            assert has_object_definition(field_value)
-
-            queryset, sub_q = process_filters(
-                cast("WithStrawberryObjectDefinition", field_value),
-                queryset,
-                info,
-                prefix,
-            )
+            values = field_value if isinstance(field_value, list) else [field_value]
+            all_q = [Q()]
+            for value in values:
+                assert has_object_definition(value)
+
+                queryset, sub_q_for_value = process_filters(
+                    cast("WithStrawberryObjectDefinition", value),
+                    queryset,
+                    info,
+                    prefix,
+                )
+                all_q.append(sub_q_for_value)
             if field_name == "AND":
+                sub_q = functools.reduce(operator.and_, all_q)
                 q &= sub_q
             elif field_name == "OR":
-                q |= sub_q
+                sub_q = functools.reduce(operator.or_, all_q)
+                if isinstance(field_value, list):
+                    # The behavior of AND/OR/NOT with a list of values means AND/OR/NOT
+                    # with respect to the list members but AND with respect to other
+                    # filters
+                    q &= sub_q
+                else:
+                    q |= sub_q
             elif field_name == "NOT":
+                # Whether this is an AND or OR operation is undefined in the spec and implementation specific
+                sub_q = functools.reduce(operator.or_, all_q)
                 q &= ~sub_q
             else:
                 assert_never(field_name)

strawberry_django/type.py

@@ -119,10 +119,18 @@ def _process_type(
     if is_filter:
         cls_annotations.update(
             {
-                "AND": Optional[Self],  # type: ignore
-                "OR": Optional[Self],  # type: ignore
-                "NOT": Optional[Self],  # type: ignore
-                "DISTINCT": Optional[bool],
+                "AND": existing_annotations.get("AND").annotation  # type: ignore
+                if existing_annotations.get("AND")
+                else Optional[Self],  # type: ignore
+                "OR": existing_annotations.get("OR").annotation  # type: ignore
+                if existing_annotations.get("OR")
+                else Optional[Self],  # type: ignore
+                "NOT": existing_annotations.get("NOT").annotation  # type: ignore
+                if existing_annotations.get("NOT")
+                else Optional[Self],  # type: ignore
+                "DISTINCT": existing_annotations.get("DISTINCT").annotation  # type: ignore
+                if existing_annotations.get("DISTINCT")
+                else Optional[bool],
             },
         )
 

tests/filters/test_filters_v2.py

@@ -10,6 +10,7 @@
 from strawberry.relay import GlobalID
 from strawberry.types import ExecutionResult, get_object_definition
 from strawberry.types.base import WithStrawberryObjectDefinition, get_object_definition
+from typing_extensions import Self
 
 import strawberry_django
 from strawberry_django.exceptions import (
@@ -25,7 +26,7 @@
 )
 from strawberry_django.filters import process_filters, resolve_value
 from tests import models, utils
-from tests.types import Fruit, FruitType
+from tests.types import Fruit, FruitType, Vegetable
 
 
 @strawberry.enum
@@ -35,6 +36,15 @@ class Version(Enum):
     THREE = "third"
 
 
+@strawberry_django.filter_type(models.Vegetable, lookups=True)
+class VegetableFilter:
+    id: auto
+    name: auto
+    AND: Optional[list[Self]] = strawberry.UNSET
+    OR: Optional[list[Self]] = strawberry.UNSET
+    NOT: Optional[list[Self]] = strawberry.UNSET
+
+
 @strawberry_django.filter_type(models.Color, lookups=True)
 class ColorFilter:
     id: auto
@@ -106,6 +116,7 @@ def filter(self, info, queryset: QuerySet, prefix):
 class Query:
     types: list[FruitType] = strawberry_django.field(filters=FruitTypeFilter)
     fruits: list[Fruit] = strawberry_django.field(filters=FruitFilter)
+    vegetables: list[Vegetable] = strawberry_django.field(filters=VegetableFilter)
 
 
 @pytest.fixture
@@ -423,6 +434,87 @@ def test_filter_distinct(query, db, fruits):
     assert len(result.data["fruits"]) == 1
 
 
+def test_filter_and_or_not(query, db):
+    v1 = models.Vegetable.objects.create(
+        name="v1", description="d1", world_production=100
+    )
+    v2 = models.Vegetable.objects.create(
+        name="v2", description="d2", world_production=200
+    )
+    v3 = models.Vegetable.objects.create(
+        name="v3", description="d3", world_production=300
+    )
+
+    # Test impossible AND
+    result = query("""
+    {
+        vegetables(filters: { AND: [{ name: { exact: "v1" } }, { name: { exact: "v2" } }] }) { id }
+    }
+    """)
+    assert not result.errors
+    assert len(result.data["vegetables"]) == 0
+
+    # Test AND with contains
+    result = query("""
+    {
+        vegetables(filters: { AND: [{ name: { contains: "v" } }, { name: { contains: "2" } }] }) { id }
+    }
+    """)
+    assert not result.errors
+    assert len(result.data["vegetables"]) == 1
+    assert result.data["vegetables"][0]["id"] == str(v2.pk)
+
+    # Test OR
+    result = query("""
+    {
+        vegetables(filters: { OR: [{ name: { exact: "v1" } }, { name: { exact: "v3" } }] }) { id }
+    }
+    """)
+    assert not result.errors
+    assert len(result.data["vegetables"]) == 2
+    assert {
+        result.data["vegetables"][0]["id"],
+        result.data["vegetables"][1]["id"],
+    } == {str(v1.pk), str(v3.pk)}
+
+    # Test NOT
+    result = query("""
+    {
+        vegetables(filters: { NOT: [{ name: { exact: "v1" } }, { name: { exact: "v2" } }] }) { id }
+    }
+    """)
+    assert not result.errors
+    assert len(result.data["vegetables"]) == 1
+    assert result.data["vegetables"][0]["id"] == str(v3.pk)
+
+    # Test interaction with simple filters. No matches due to AND logic relative to simple filters.
+    result = query(
+        """
+    {
+        vegetables(filters: { id: { exact: """
+        + str(v1.pk)
+        + """ }, AND: [{ name: { exact: "v2" } }] }) { id }
+    }
+    """
+    )
+    assert not result.errors
+    assert len(result.data["vegetables"]) == 0
+
+    # Test interaction with simple filters. Match on same record
+    result = query(
+        """
+    {
+        vegetables(filters: { id: { exact: """
+        + str(v1.pk)
+        + """ }, AND: [{ name: { exact: "v1" } }] }) { id }
+    }
+    """
+    )
+    assert not result.errors
+    assert len(result.data["vegetables"]) == 1
+    assert result.data["vegetables"][0]["id"] == str(v1.pk)
+
+
 def test_filter_none(query, db):
     yellow = models.Color.objects.create(name="yellow")
     models.Fruit.objects.create(name="banana", color=yellow)

tests/types.py

@@ -32,6 +32,12 @@ class FruitType:
     fruits: list[Fruit]
 
 
+@strawberry_django.type(models.Vegetable)
+class Vegetable:
+    id: auto
+    name: auto
+
+
 @strawberry_django.type(models.TomatoWithRequiredPicture, fields="__all__")
 class TomatoWithRequiredPictureType:
     pass