drf-react-by-schema 0.28.0__tar.gz → 0.28.2__tar.gz

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drf_react_by_schema
-Version: 0.28.0
+Version: 0.28.2
 Summary: A Django app to easily integrate with React from models.
 Home-page: https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django
 Author: Cooperativa EITA
@@ -115,6 +115,43 @@ single release line. The supported combinations are exercised in CI (see
        drf-react-by-schema
        drf-excel<2.6
 
+Django 3.2 is kept as **legacy support**: the 3.2-only pin above and its CI job
+will be dropped when the supported floor moves to 4.2. New code should target
+4.2-5.2; Django-3.2-only branches must stay isolated so the migration is a single
+clean-up pass.
+
+Accent-insensitive search
+-------------------------
+On PostgreSQL with the ``unaccent`` extension enabled (and
+``django.contrib.postgres`` in ``INSTALLED_APPS``), replace DRF's search filter
+with the package's::
+
+    REST_FRAMEWORK = {
+        "DEFAULT_FILTER_BACKENDS": [
+            "drf_react_by_schema.filters.DRFReactBySchemaSearchFilter",
+            "drf_react_by_schema.filters.DRFReactBySchemaOrderingFilter",
+        ],
+    }
+
+``unaccent`` is applied only to text fields; dates, numbers and booleans keep
+DRF's default lookup, because ``unaccent`` raises on them.
+
+The filter is **opt-in**: apps that keep DRF's ``SearchFilter`` are unaffected
+and do not need the extension. It probes the backend, ``INSTALLED_APPS`` and the
+database extension once per connection alias. If the extension is missing — or
+the database is not PostgreSQL, or ``django.contrib.postgres`` is not installed
+— it falls back to DRF's normal lookups: search keeps working (accent-sensitive)
+instead of raising ``FieldError``. Call
+``drf_react_by_schema.filters.reset_unaccent_cache()`` if the extension is
+installed while the process is running.
+
+To create the extension, add a migration in the consuming app::
+
+    from django.contrib.postgres.operations import UnaccentExtension
+
+    class Migration(migrations.Migration):
+        operations = [UnaccentExtension()]
+
 Optional Dependencies
 ---------------------
 For enhanced caching capabilities in the automatically generated viewsets, you can install optional dependencies:
@@ -252,6 +289,39 @@ Quick start
 
 You can customize ``viewsets`` and ``serializers`` to annotate other attributes.
 
+List vs. detail serializers
+---------------------------
+The generated ``XSerializer`` is the canonical serializer and serves both ``retrieve``
+and ``list``/``excel``. When a detail-only field would be expensive in lists, declare it
+in ``Meta.list_exclude`` on the app's general serializer:
+
+.. code-block:: python
+
+    from drf_react_by_schema.serializers import (
+        ClienteSerializer as BaseClienteSerializer,
+    )
+
+    class ClienteSerializer(BaseClienteSerializer):
+        contratacao = drf_serializers.SerializerMethodField()   # detail only
+        nome = drf_serializers.CharField(read_only=True)        # both
+
+        class Meta(BaseClienteSerializer.Meta):
+            list_exclude = ("contratacao",)
+
+The package derives (and caches) a list projection that keeps every other field,
+including future additions to the general serializer. ``list_exclude`` takes serializer
+field names, not model ``source`` paths; ``()`` means "the list is identical to the
+detail response". An explicit list serializer remains available as an escape hatch:
+
+.. code-block:: python
+
+    class ClienteViewSet(GenericViewSet):
+        serializer_class = ClienteSerializer
+        serializer_list_class = ClienteListSerializer   # optional, full override
+
+``XListSerializer`` classes are no longer generated automatically: the default is the
+general serializer, so app-added fields can never silently disappear from lists.
+
 Global permission-aware queryset filtering
 ------------------------------------------
 Every generated viewset already supports a ``filter_by_callback`` (and a list-only

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/README.rst

@@ -83,6 +83,43 @@ single release line. The supported combinations are exercised in CI (see
        drf-react-by-schema
        drf-excel<2.6
 
+Django 3.2 is kept as **legacy support**: the 3.2-only pin above and its CI job
+will be dropped when the supported floor moves to 4.2. New code should target
+4.2-5.2; Django-3.2-only branches must stay isolated so the migration is a single
+clean-up pass.
+
+Accent-insensitive search
+-------------------------
+On PostgreSQL with the ``unaccent`` extension enabled (and
+``django.contrib.postgres`` in ``INSTALLED_APPS``), replace DRF's search filter
+with the package's::
+
+    REST_FRAMEWORK = {
+        "DEFAULT_FILTER_BACKENDS": [
+            "drf_react_by_schema.filters.DRFReactBySchemaSearchFilter",
+            "drf_react_by_schema.filters.DRFReactBySchemaOrderingFilter",
+        ],
+    }
+
+``unaccent`` is applied only to text fields; dates, numbers and booleans keep
+DRF's default lookup, because ``unaccent`` raises on them.
+
+The filter is **opt-in**: apps that keep DRF's ``SearchFilter`` are unaffected
+and do not need the extension. It probes the backend, ``INSTALLED_APPS`` and the
+database extension once per connection alias. If the extension is missing — or
+the database is not PostgreSQL, or ``django.contrib.postgres`` is not installed
+— it falls back to DRF's normal lookups: search keeps working (accent-sensitive)
+instead of raising ``FieldError``. Call
+``drf_react_by_schema.filters.reset_unaccent_cache()`` if the extension is
+installed while the process is running.
+
+To create the extension, add a migration in the consuming app::
+
+    from django.contrib.postgres.operations import UnaccentExtension
+
+    class Migration(migrations.Migration):
+        operations = [UnaccentExtension()]
+
 Optional Dependencies
 ---------------------
 For enhanced caching capabilities in the automatically generated viewsets, you can install optional dependencies:
@@ -220,6 +257,39 @@ Quick start
 
 You can customize ``viewsets`` and ``serializers`` to annotate other attributes.
 
+List vs. detail serializers
+---------------------------
+The generated ``XSerializer`` is the canonical serializer and serves both ``retrieve``
+and ``list``/``excel``. When a detail-only field would be expensive in lists, declare it
+in ``Meta.list_exclude`` on the app's general serializer:
+
+.. code-block:: python
+
+    from drf_react_by_schema.serializers import (
+        ClienteSerializer as BaseClienteSerializer,
+    )
+
+    class ClienteSerializer(BaseClienteSerializer):
+        contratacao = drf_serializers.SerializerMethodField()   # detail only
+        nome = drf_serializers.CharField(read_only=True)        # both
+
+        class Meta(BaseClienteSerializer.Meta):
+            list_exclude = ("contratacao",)
+
+The package derives (and caches) a list projection that keeps every other field,
+including future additions to the general serializer. ``list_exclude`` takes serializer
+field names, not model ``source`` paths; ``()`` means "the list is identical to the
+detail response". An explicit list serializer remains available as an escape hatch:
+
+.. code-block:: python
+
+    class ClienteViewSet(GenericViewSet):
+        serializer_class = ClienteSerializer
+        serializer_list_class = ClienteListSerializer   # optional, full override
+
+``XListSerializer`` classes are no longer generated automatically: the default is the
+general serializer, so app-added fields can never silently disappear from lists.
+
 Global permission-aware queryset filtering
 ------------------------------------------
 Every generated viewset already supports a ``filter_by_callback`` (and a list-only

drf_react_by_schema-0.28.2/drf_react_by_schema/filters.py

@@ -0,0 +1,112 @@
+from django.apps import apps
+from django.db import connections
+from django.db.models import CharField, TextField
+from rest_framework.filters import OrderingFilter, SearchFilter
+
+from . import utils
+
+# Only these field types support the unaccent lookup.
+TEXT_FIELD_CLASSES = (CharField, TextField)
+
+# DRF lookups the filter converts to their unaccent-aware counterparts.
+UNACCENT_LOOKUPS = ("icontains", "istartswith", "iexact")
+
+# Per-database result of the unaccent probe (one query per alias per process).
+_UNACCENT_AVAILABLE = {}
+
+
+def reset_unaccent_cache():
+    """Forget the unaccent probe, e.g. after installing the extension."""
+    _UNACCENT_AVAILABLE.clear()
+
+
+def unaccent_available(connection):
+    """Whether ``connection`` can run the ``unaccent`` lookup.
+
+    False on non-PostgreSQL backends, without ``django.contrib.postgres`` (which
+    registers the lookup), or when the extension is missing from the database.
+    """
+    if connection.vendor != "postgresql":
+        return False
+    if not apps.is_installed("django.contrib.postgres"):
+        return False
+    alias = connection.alias
+    if alias not in _UNACCENT_AVAILABLE:
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute(
+                    "SELECT 1 FROM pg_extension WHERE extname = 'unaccent'"
+                )
+                _UNACCENT_AVAILABLE[alias] = cursor.fetchone() is not None
+        except Exception:
+            _UNACCENT_AVAILABLE[alias] = False
+    return _UNACCENT_AVAILABLE[alias]
+
+
+class DRFReactBySchemaSearchFilter(SearchFilter):
+    """``SearchFilter`` with accent-insensitive matches on text fields.
+
+    Non-text fields keep DRF's default lookup: ``unaccent`` only accepts text,
+    so applying it to a date, number or boolean raises ``FieldError``.
+
+    Accent-insensitive search needs PostgreSQL with the ``unaccent`` extension
+    enabled and ``django.contrib.postgres`` in ``INSTALLED_APPS``. When either
+    is missing (or the database is not PostgreSQL), the filter silently falls
+    back to DRF's lookups, so search still works (accent-sensitive).
+    """
+
+    # Resolved per request by ``filter_queryset``; None on direct calls.
+    _unaccent_enabled = None
+
+    def filter_queryset(self, request, queryset, view):
+        self._unaccent_enabled = unaccent_available(connections[queryset.db])
+        return super().filter_queryset(request, queryset, view)
+
+    def construct_search(self, field_name, queryset):
+        lookup = super().construct_search(field_name, queryset)
+        unaccent_enabled = self._unaccent_enabled
+        if unaccent_enabled is None:
+            unaccent_enabled = unaccent_available(connections[queryset.db])
+        if not unaccent_enabled:
+            return lookup
+        if not self._is_text_field(queryset.model, field_name):
+            return lookup
+        for standard_lookup in UNACCENT_LOOKUPS:
+            if lookup.endswith(f"__{standard_lookup}"):
+                return lookup[: -len(standard_lookup)] + f"unaccent__{standard_lookup}"
+        return lookup
+
+    @staticmethod
+    def _is_text_field(model, field_path):
+        """Whether the terminal field in ``field_path`` is a text field."""
+        # Strip DRF prefix modifiers: ^, =, @, $
+        parts = str(field_path).lstrip("^=@$").split("__")
+        try:
+            for part in parts[:-1]:
+                model = model._meta.get_field(part).related_model
+            return isinstance(model._meta.get_field(parts[-1]), TEXT_FIELD_CLASSES)
+        except Exception:
+            # Unknown paths and non-relational lookups keep the standard lookup.
+            return False
+
+
+class DRFReactBySchemaOrderingFilter(OrderingFilter):
+    def get_ordering(self, request, queryset, view):
+        """
+        Ordering is set by a comma delimited ?ordering=... query parameter.
+
+        The `ordering` query parameter can be overridden by setting
+        the `ordering_param` value on the OrderingFilter or by
+        specifying an `ORDERING_PARAM` value in the API settings.
+        """
+        params = request.query_params.get(self.ordering_param)
+        if params:
+            fields_raw = [param.strip() for param in params.split(",")]
+            fields = utils.serializer_to_model_fields(view, fields_raw)
+            if fields is not None:
+                ordering = self.remove_invalid_fields(queryset, fields, view, request)
+                if ordering:
+                    return ordering
+
+        # No ordering was included, or all the ordering fields were invalid
+        return self.get_default_ordering(view)

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/drf_react_by_schema/metadata.py

@@ -15,7 +15,8 @@ class _PinnedSerializerClass:
 
     ``SimpleMetadata.determine_metadata`` derives the POST fields from
     ``view.get_serializer()``, which is action-dependent (``list``/``excel``
-    use ``serializer_list_class``). Pinning keeps the schema canonical.
+    may use an explicit list serializer or a ``Meta.list_exclude`` projection).
+    Pinning keeps the schema canonical.
     """
 
     def __init__(self, view, serializer_class):

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/drf_react_by_schema/schema_bundle.py

@@ -53,6 +53,7 @@ from .utils import (
     DATE_FILTER_OPERATORS,
     GRID_FILTER_OPERATORS,
     camel_to_snake,
+    is_searchable_model_field,
     sum_rows_capabilities,
 )
 
@@ -543,7 +544,11 @@ def _search_ordering_fields(view_instance) -> tuple[list, list]:
     except Exception:
         return [], []
     return (
-        [str(field) for field in (view_instance.search_fields or [])],
+        [
+            str(field)
+            for field in (view_instance.search_fields or [])
+            if is_searchable_model_field(view_instance, str(field))
+        ],
         [str(field) for field in (view_instance.ordering_fields or [])],
     )
 

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/drf_react_by_schema/serializers.py

@@ -1,8 +1,11 @@
 import traceback
+from functools import lru_cache
+
 from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.contrib.auth import password_validation
 from django.contrib.auth.tokens import default_token_generator
+from django.core.exceptions import ImproperlyConfigured
 from django.core.exceptions import ValidationError as DjangoValidationError
 from django.utils.encoding import force_str
 from django.utils.http import urlsafe_base64_decode
@@ -148,6 +151,11 @@ class GenericSerializerMetaclass(SerializerMetaclass):
         # First, let DRF's SerializerMetaclass do its work
         new_class = super().__new__(mcs, name, bases, attrs)
 
+        # List projections inherit the detail serializer's related-field setup;
+        # re-running it would rebuild update_related/model_fields unnecessarily.
+        if attrs.get("_drbs_projection"):
+            return new_class
+
         # Only process if this class has a Meta with a model
         if hasattr(new_class, "Meta") and hasattr(new_class.Meta, "model"):
             mcs._populate_related_fields(new_class)
@@ -494,6 +502,88 @@ class GenericSerializer(
         fields = "__all__"
 
 
+class _ListProjectionMixin:
+    """Drop the detail-only fields from a projected list serializer."""
+
+    def get_fields(self):
+        fields = super().get_fields()
+        for name in getattr(self.Meta, "list_exclude", ()) or ():
+            fields.pop(name, None)
+        return fields
+
+
+def _known_serializer_field_names(detail_class):
+    """Field names that ``Meta.list_exclude`` may legitimately reference."""
+    known = set(getattr(detail_class, "_declared_fields", {}) or {})
+    meta = getattr(detail_class, "Meta", None)
+    model = getattr(meta, "model", None)
+    if model is not None:
+        known.update(field.name for field in model._meta.get_fields())
+    meta_fields = getattr(meta, "fields", None)
+    if isinstance(meta_fields, (list, tuple)):
+        known.update(meta_fields)
+    elif isinstance(meta_fields, dict):
+        known.update(meta_fields)
+    return known
+
+
+def _list_serializer_class_name(detail_class):
+    suffix = "Serializer"
+    name = detail_class.__name__
+    base = name[: -len(suffix)] if name.endswith(suffix) else name
+    return f"{base}ListSerializer"
+
+
+@lru_cache(maxsize=None)
+def _build_list_projection(detail_class, excludes):
+    meta = type("Meta", (detail_class.Meta,), {"list_exclude": excludes})
+    return type(
+        _list_serializer_class_name(detail_class),
+        (_ListProjectionMixin, detail_class),
+        {
+            "Meta": meta,
+            "__module__": detail_class.__module__,
+            "_drbs_projection": True,
+        },
+    )
+
+
+def list_serializer_for(detail_class):
+    """List serializer derived from ``detail_class``, or ``None``.
+
+    The general serializer is the canonical shape and is used for list/excel by
+    default. Setting ``Meta.list_exclude`` opts into a lighter list that keeps
+    every other field (including app-added ones) and drops the listed names.
+    """
+    if detail_class is None:
+        return None
+    meta = getattr(detail_class, "Meta", None)
+    excludes = getattr(meta, "list_exclude", None)
+    if excludes is None:
+        return None
+    if isinstance(excludes, str) or not isinstance(
+        excludes, (list, tuple, set, frozenset)
+    ):
+        raise ImproperlyConfigured(
+            f"{detail_class.__name__}.Meta.list_exclude must be a list or tuple "
+            "of serializer field names."
+        )
+    if isinstance(excludes, (set, frozenset)):
+        excludes = tuple(sorted(excludes))
+    else:
+        excludes = tuple(excludes)
+    if not excludes:
+        return None
+
+    unknown = set(excludes) - _known_serializer_field_names(detail_class)
+    if unknown:
+        raise ImproperlyConfigured(
+            f"{detail_class.__name__}.Meta.list_exclude references unknown "
+            f"field(s): {', '.join(sorted(unknown))}."
+        )
+    return _build_list_projection(detail_class, excludes)
+
+
 ######################
 
 
@@ -501,19 +591,9 @@ for app in settings["APPS"]:
     for name, model in apps.all_models[app].items():
         model_name = model.__name__
         if isinstance(model, type):
-            serializer_list_name = f"{model_name}ListSerializer"
             serializer_name = f"{model_name}Serializer"
             if not serializer_name in dir():
                 meta = type("Meta", (), {"fields": "__all__", "model": model})
-                generated_class = type(
-                    serializer_list_name,
-                    (GenericSerializer,),
-                    {
-                        "Meta": meta,
-                    },
-                )
-                globals()[serializer_list_name] = generated_class
-
                 generated_class = type(
                     serializer_name, (GenericSerializer,), {"Meta": meta}
                 )

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/drf_react_by_schema/utils.py

@@ -159,6 +159,17 @@ def to_pascal_case(s):
     return s.replace("_", " ").title().replace(" ", "")
 
 
+def list_serializer_name(serializer_name):
+    """Conventional list-serializer name for a detail serializer class name."""
+    suffix = "Serializer"
+    base = (
+        serializer_name[: -len(suffix)]
+        if serializer_name.endswith(suffix)
+        else serializer_name
+    )
+    return f"{base}ListSerializer"
+
+
 def get_target_field(view, field, prefix=None):
     field_name = getattr(field, "name", None)
     related_model = getattr(field, "related_model", None)
@@ -321,6 +332,17 @@ def _resolve_model_field(view, path):
     return field
 
 
+def is_searchable_model_field(view, path):
+    """Whether ``path`` accepts DRF's default ``icontains`` search lookup.
+
+    A path ending on a relation (FK, reverse or m2m) has no ``icontains``
+    lookup: putting it in ``search_fields`` makes every ``?search=`` request
+    raise ``FieldError``. Unknown paths (e.g. annotations) are left untouched.
+    """
+    field = _resolve_model_field(view, path)
+    return field is None or not field.is_relation
+
+
 def _is_non_string_field(view, target_field, column_field_serializer):
     """Whether the grid filter must treat the target as non-string.
 

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/drf_react_by_schema/viewsets.py

@@ -78,53 +78,66 @@ class DRFReactBySchemaBaseModelViewSet(
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        if not self.model:
+        if not self.model and self.model_name:
             self.model = utils.get_model(self.app, self.model_name)
         if self.app and self.serializer_class is not None:
-            threshold = 2 if self.serializer_list_class else 1
-            found = 0
+            module_name = (
+                "autocomplete_serializers"
+                if self.is_autocomplete
+                else "serializers"
+            )
             try:
                 app_serializers = importlib.import_module(
-                    f"{self.app}.serializers"
-                    if not self.is_autocomplete
-                    else f"{self.app}.autocomplete_serializers"
+                    f"{self.app}.{module_name}"
                 )
-            except:
+            except ImportError:
                 return
 
-            for app_serializer_name, app_serializer in inspect.getmembers(
-                app_serializers, predicate=inspect.isclass
-            ):
-                if app_serializer_name == self.serializer_class.__name__:
-                    self.serializer_class = app_serializer
-                    found += 1
-
-                if (
-                    self.serializer_list_class
-                    and app_serializer_name == self.serializer_list_class.__name__
-                ):
-                    self.serializer_list_class = app_serializer
-                    found += 1
+            self.serializer_class = getattr(
+                app_serializers,
+                self.serializer_class.__name__,
+                self.serializer_class,
+            )
 
-                if found == threshold:
-                    break
+            # The list serializer is optional: list/excel default to the general
+            # serializer, and an app-defined ``XListSerializer`` is honored when
+            # the viewset does not point at one explicitly.
+            list_name = (
+                self.serializer_list_class.__name__
+                if self.serializer_list_class is not None
+                else utils.list_serializer_name(self.serializer_class.__name__)
+            )
+            resolved_list_class = getattr(app_serializers, list_name, None)
+            if resolved_list_class is not None:
+                self.serializer_list_class = resolved_list_class
 
     def get_schema_serializer_class(self):
         """Serializer describing the model shape (OPTIONS/TS generation).
 
         Always the canonical ``serializer_class``: ``get_serializer_class`` may
-        return the lighter ``serializer_list_class`` for ``list``/``excel``,
-        but the schema must not change with the action.
+        return an explicit list serializer or a ``Meta.list_exclude`` projection
+        for ``list``/``excel``, but the schema must not change with the action.
         """
         return self.serializer_class
 
-    def get_serializer_class(self):
-        """Use ``serializer_list_class`` for ``list``/``excel``, if defined."""
-        if (
-            getattr(self, "action", None) in ("list", "excel")
-            and self.serializer_list_class
-        ):
+    def get_list_serializer_class(self):
+        """Serializer used by ``list``/``excel``.
+
+        An explicit ``serializer_list_class`` wins; otherwise a
+        ``Meta.list_exclude`` projection of the general serializer is used; when
+        neither exists the general serializer itself serves the list.
+        """
+        if self.serializer_list_class is not None:
             return self.serializer_list_class
+        return (
+            serializers.list_serializer_for(self.serializer_class)
+            or self.serializer_class
+        )
+
+    def get_serializer_class(self):
+        """Use the list serializer for ``list``/``excel``, if one applies."""
+        if getattr(self, "action", None) in ("list", "excel"):
+            return self.get_list_serializer_class()
         return super().get_serializer_class()
 
     def resolve_filter_callback(self, callback_attr):
@@ -537,8 +550,14 @@ class DRFReactBySchemaBaseModelViewSet(
                 self, list(serializer_fields.keys())
             )
 
-            if not self.search_fields:
-                self.search_fields = target_fields
+            if not self.search_fields and target_fields:
+                # Relation-terminated paths have no ``icontains`` lookup; DRF
+                # would raise on every ``?search=``. Ordering them is valid.
+                self.search_fields = [
+                    target_field
+                    for target_field in target_fields
+                    if utils.is_searchable_model_field(self, target_field)
+                ]
             if not self.ordering_fields:
                 self.ordering_fields = target_fields
 
@@ -791,9 +810,6 @@ for app in settings["APPS"]:
                         "serializer_class": getattr(
                             serializers, f"{model_name}Serializer"
                         ),
-                        "serializer_list_class": getattr(
-                            serializers, f"{model_name}ListSerializer"
-                        ),
                     },
                 )
                 globals()[viewset_name] = generated_class
@@ -824,11 +840,6 @@ for app in settings["APPS"]:
                                     "serializer_class": getattr(
                                         serializers, f"{related_model_name}Serializer"
                                     ),
-                                    "serializer_list_class": getattr(
-                                        serializers,
-                                        f"{related_model_name}ListSerializer",
-                                        None,
-                                    ),
                                     "related_name": field.name,
                                     "many": True,
                                     "parent_model": model,

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/drf_react_by_schema.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drf-react-by-schema
-Version: 0.28.0
+Version: 0.28.2
 Summary: A Django app to easily integrate with React from models.
 Home-page: https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django
 Author: Cooperativa EITA
@@ -115,6 +115,43 @@ single release line. The supported combinations are exercised in CI (see
        drf-react-by-schema
        drf-excel<2.6
 
+Django 3.2 is kept as **legacy support**: the 3.2-only pin above and its CI job
+will be dropped when the supported floor moves to 4.2. New code should target
+4.2-5.2; Django-3.2-only branches must stay isolated so the migration is a single
+clean-up pass.
+
+Accent-insensitive search
+-------------------------
+On PostgreSQL with the ``unaccent`` extension enabled (and
+``django.contrib.postgres`` in ``INSTALLED_APPS``), replace DRF's search filter
+with the package's::
+
+    REST_FRAMEWORK = {
+        "DEFAULT_FILTER_BACKENDS": [
+            "drf_react_by_schema.filters.DRFReactBySchemaSearchFilter",
+            "drf_react_by_schema.filters.DRFReactBySchemaOrderingFilter",
+        ],
+    }
+
+``unaccent`` is applied only to text fields; dates, numbers and booleans keep
+DRF's default lookup, because ``unaccent`` raises on them.
+
+The filter is **opt-in**: apps that keep DRF's ``SearchFilter`` are unaffected
+and do not need the extension. It probes the backend, ``INSTALLED_APPS`` and the
+database extension once per connection alias. If the extension is missing — or
+the database is not PostgreSQL, or ``django.contrib.postgres`` is not installed
+— it falls back to DRF's normal lookups: search keeps working (accent-sensitive)
+instead of raising ``FieldError``. Call
+``drf_react_by_schema.filters.reset_unaccent_cache()`` if the extension is
+installed while the process is running.
+
+To create the extension, add a migration in the consuming app::
+
+    from django.contrib.postgres.operations import UnaccentExtension
+
+    class Migration(migrations.Migration):
+        operations = [UnaccentExtension()]
+
 Optional Dependencies
 ---------------------
 For enhanced caching capabilities in the automatically generated viewsets, you can install optional dependencies:
@@ -252,6 +289,39 @@ Quick start
 
 You can customize ``viewsets`` and ``serializers`` to annotate other attributes.
 
+List vs. detail serializers
+---------------------------
+The generated ``XSerializer`` is the canonical serializer and serves both ``retrieve``
+and ``list``/``excel``. When a detail-only field would be expensive in lists, declare it
+in ``Meta.list_exclude`` on the app's general serializer:
+
+.. code-block:: python
+
+    from drf_react_by_schema.serializers import (
+        ClienteSerializer as BaseClienteSerializer,
+    )
+
+    class ClienteSerializer(BaseClienteSerializer):
+        contratacao = drf_serializers.SerializerMethodField()   # detail only
+        nome = drf_serializers.CharField(read_only=True)        # both
+
+        class Meta(BaseClienteSerializer.Meta):
+            list_exclude = ("contratacao",)
+
+The package derives (and caches) a list projection that keeps every other field,
+including future additions to the general serializer. ``list_exclude`` takes serializer
+field names, not model ``source`` paths; ``()`` means "the list is identical to the
+detail response". An explicit list serializer remains available as an escape hatch:
+
+.. code-block:: python
+
+    class ClienteViewSet(GenericViewSet):
+        serializer_class = ClienteSerializer
+        serializer_list_class = ClienteListSerializer   # optional, full override
+
+``XListSerializer`` classes are no longer generated automatically: the default is the
+general serializer, so app-added fields can never silently disappear from lists.
+
 Global permission-aware queryset filtering
 ------------------------------------------
 Every generated viewset already supports a ``filter_by_callback`` (and a list-only

{drf_react_by_schema-0.28.0 → drf_react_by_schema-0.28.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = drf_react_by_schema
-version = 0.28.0
+version = 0.28.2
 description = A Django app to easily integrate with React from models.
 long_description = file: README.rst
 url = https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django

drf_react_by_schema-0.28.0/drf_react_by_schema/filters.py

@@ -1,24 +0,0 @@
-from rest_framework.filters import OrderingFilter, SearchFilter
-from . import utils
-
-
-class DRFReactBySchemaOrderingFilter(OrderingFilter):
-    def get_ordering(self, request, queryset, view):
-        """
-        Ordering is set by a comma delimited ?ordering=... query parameter.
-
-        The `ordering` query parameter can be overridden by setting
-        the `ordering_param` value on the OrderingFilter or by
-        specifying an `ORDERING_PARAM` value in the API settings.
-        """
-        params = request.query_params.get(self.ordering_param)
-        if params:
-            fields_raw = [param.strip() for param in params.split(",")]
-            fields = utils.serializer_to_model_fields(view, fields_raw)
-            if fields is not None:
-                ordering = self.remove_invalid_fields(queryset, fields, view, request)
-                if ordering:
-                    return ordering
-
-        # No ordering was included, or all the ordering fields were invalid
-        return self.get_default_ordering(view)