sqlspec 0.46.0__tar.gz → 0.46.2__tar.gz

{sqlspec-0.46.0 → sqlspec-0.46.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.46.0
+Version: 0.46.2
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.46.0 → sqlspec-0.46.2}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.46.0"
+version = "0.46.2"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -264,7 +264,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.46.0"
+current_version = "0.46.2"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

sqlspec-0.46.2/sqlspec/extensions/_filter_aliases.py

@@ -0,0 +1,112 @@
+"""Shared filter alias helpers for framework extensions."""
+
+from collections.abc import Mapping
+from typing import NamedTuple
+
+from sqlspec.utils.text import camelize
+
+__all__ = ("SortField", "SortFieldResolution", "resolve_sort_field_aliases")
+
+SortField = str | set[str] | list[str]
+
+
+class SortFieldResolution(NamedTuple):
+    """Resolved sort-field alias metadata.
+
+    Args:
+        default_field: Internal SQL-facing field used when no query value is supplied.
+        default_query_value: API-facing default value exposed on the query parameter.
+        allowed_fields: Internal SQL-facing allowlist.
+        inbound_aliases: API-facing query values mapped to internal field names.
+        field_display_names: Internal field names mapped to their preferred API-facing display names.
+        allowed_display_names: Display names ordered to match the configured sort fields.
+    """
+
+    default_field: str
+    default_query_value: str
+    allowed_fields: frozenset[str]
+    inbound_aliases: dict[str, str]
+    field_display_names: dict[str, str]
+    allowed_display_names: tuple[str, ...]
+
+    def normalize(self, value: str | None) -> str | None:
+        """Normalize a query value to an internal field name.
+
+        Args:
+            value: API-facing query value, or ``None`` to request the default field.
+
+        Returns:
+            The internal field name if the value is configured, otherwise ``None``.
+        """
+        if value is None:
+            return self.default_field
+        return self.inbound_aliases.get(value)
+
+
+def resolve_sort_field_aliases(
+    sort_field: SortField, sort_field_aliases: Mapping[str, str] | None = None, sort_field_camelize: bool = True
+) -> SortFieldResolution:
+    """Resolve sort-field aliases to a closed allowlist map.
+
+    Args:
+        sort_field: Configured SQL-facing sort field or fields.
+        sort_field_aliases: Optional API-facing alias to SQL-facing field mapping.
+        sort_field_camelize: Whether to generate camel-case aliases for configured fields. Defaults to ``True``.
+
+    Returns:
+        Precomputed alias metadata for framework filter providers.
+
+    Raises:
+        ValueError: If an alias targets an unknown field or collides with a different field.
+    """
+    fields = _coerce_fields(sort_field)
+    allowed_fields = frozenset(fields)
+    inbound_aliases: dict[str, str] = {}
+    field_display_names = {field: field for field in fields}
+
+    for field in fields:
+        _add_alias(inbound_aliases, alias=field, field=field)
+
+    if sort_field_camelize:
+        for field in fields:
+            alias = camelize(field)
+            _add_alias(inbound_aliases, alias=alias, field=field)
+            field_display_names[field] = alias
+
+    if sort_field_aliases:
+        for alias, field in sort_field_aliases.items():
+            if field not in allowed_fields:
+                msg = f"sort field alias '{alias}' targets unknown sort field '{field}'"
+                raise ValueError(msg)
+            _add_alias(inbound_aliases, alias=alias, field=field)
+            field_display_names[field] = alias
+
+    allowed_display_names = tuple(field_display_names[field] for field in fields)
+    return SortFieldResolution(
+        default_field=fields[0],
+        default_query_value=field_display_names[fields[0]],
+        allowed_fields=allowed_fields,
+        inbound_aliases=inbound_aliases,
+        field_display_names=field_display_names,
+        allowed_display_names=allowed_display_names,
+    )
+
+
+def _coerce_fields(sort_field: SortField) -> tuple[str, ...]:
+    if isinstance(sort_field, str):
+        return (sort_field,)
+    fields = tuple(sorted(sort_field)) if isinstance(sort_field, set) else tuple(sort_field)
+    if not fields:
+        msg = "sort_field must include at least one field"
+        raise ValueError(msg)
+    return fields
+
+
+def _add_alias(inbound_aliases: dict[str, str], *, alias: str, field: str) -> None:
+    existing_field = inbound_aliases.get(alias)
+    if existing_field is None or existing_field == field:
+        inbound_aliases[alias] = field
+        return
+
+    msg = f"ambiguous sort field alias '{alias}' maps to both '{existing_field}' and '{field}'"
+    raise ValueError(msg)

{sqlspec-0.46.0 → sqlspec-0.46.2}/sqlspec/extensions/fastapi/extension.py

@@ -374,7 +374,7 @@ class SQLSpecPlugin(_StarlettePlugin):
                         "search": "name,email",
                         "search_ignore_case": True,
                         "pagination_type": "limit_offset",
-                        "sort_field": "created_at",
+                        "sort_field": ["created_at", "uploaded_collections"],
                     })
                 ),
             ):

{sqlspec-0.46.0 → sqlspec-0.46.2}/sqlspec/extensions/fastapi/providers.py

@@ -24,6 +24,7 @@ from sqlspec.core import (
     OrderByFilter,
     SearchFilter,
 )
+from sqlspec.extensions._filter_aliases import resolve_sort_field_aliases
 from sqlspec.utils.singleton import SingletonMeta
 from sqlspec.utils.text import camelize
 
@@ -88,36 +89,45 @@ class FieldNameType(NamedTuple):
 
 
 class FilterConfig(TypedDict):
-    """Configuration for generating dynamic filters for FastAPI."""
+    """Configuration for generated FastAPI filter dependencies.
+
+    All keys are optional. A filter dependency is created only for each enabled
+    key. Field names are SQL-facing allowlist values; generated query parameter
+    names and order-by aliases remain API-facing.
+    """
 
     id_filter: NotRequired[type[UUID | int | str]]
-    """Type of ID filter to enable (UUID, int, or str). When set, enables collection filtering by IDs."""
+    """Type of ID filter to enable. When set, creates an ``ids`` collection filter."""
     id_field: NotRequired[str]
-    """Field name for ID filtering. Defaults to 'id'."""
+    """SQL-facing field name for ID filtering. Defaults to ``"id"``."""
     sort_field: NotRequired[SortField]
-    """Allowed field(s) to use for sorting."""
+    """Allowed SQL-facing field or fields for ``orderBy`` sorting."""
+    sort_field_aliases: NotRequired[dict[str, str]]
+    """Additional API-facing ``orderBy`` aliases mapped to configured ``sort_field`` values."""
+    sort_field_camelize: NotRequired[bool]
+    """Whether to accept camel-case aliases for configured sort fields. Defaults to ``True``."""
     sort_order: NotRequired[SortOrder]
-    """Default sort order ('asc' or 'desc'). Defaults to 'desc'."""
+    """Default sort order. Defaults to ``"desc"``."""
     pagination_type: NotRequired[Literal["limit_offset"]]
-    """When set to 'limit_offset', enables pagination with page size and current page parameters."""
+    """Pagination strategy to enable. Currently supports ``"limit_offset"``."""
     pagination_size: NotRequired[int]
-    """Default pagination page size. Defaults to DEFAULT_PAGINATION_SIZE (20)."""
+    """Default page size for limit/offset pagination."""
     search: NotRequired[str | set[str]]
-    """Field(s) to enable search filtering on. Can be comma-separated string or set of field names."""
+    """SQL-facing field or fields to search. Strings may be comma-separated."""
     search_ignore_case: NotRequired[bool]
-    """When True, search is case-insensitive. Defaults to False."""
+    """Whether search filtering is case-insensitive. Defaults to ``False``."""
     created_at: NotRequired[bool]
-    """When True, enables created_at date range filtering. Uses 'created_at' field by default."""
+    """Whether to enable ``created_at`` before/after range filtering."""
     updated_at: NotRequired[bool]
-    """When True, enables updated_at date range filtering. Uses 'updated_at' field by default."""
+    """Whether to enable ``updated_at`` before/after range filtering."""
     not_in_fields: NotRequired[FieldNameType | set[FieldNameType] | list[str | FieldNameType]]
-    """Fields that support not-in collection filtering. Can be single field or set of fields with type info."""
+    """Field or fields that support ``NOT IN`` collection filtering."""
     in_fields: NotRequired[FieldNameType | set[FieldNameType] | list[str | FieldNameType]]
-    """Fields that support in-collection filtering. Can be single field or set of fields with type info."""
+    """Field or fields that support ``IN`` collection filtering."""
     null_fields: NotRequired[str | set[str]]
-    """Fields that support IS NULL filtering. Can be single field name or set of field names."""
+    """Field or fields that support ``IS NULL`` filtering."""
     not_null_fields: NotRequired[str | set[str]]
-    """Fields that support IS NOT NULL filtering. Can be single field name or set of field names."""
+    """Field or fields that support ``IS NOT NULL`` filtering."""
 
 
 class DependencyCache(metaclass=SingletonMeta):
@@ -154,13 +164,6 @@ def _empty_filter_list() -> "list[FilterTypes]":
     return []
 
 
-def _resolve_sort_fields(sort_field: SortField) -> tuple[str, set[str]]:
-    if isinstance(sort_field, str):
-        return sort_field, {sort_field}
-    fields = tuple(sorted(sort_field)) if isinstance(sort_field, set) else tuple(sort_field)
-    return fields[0], set(fields)
-
-
 def provide_filters(
     config: FilterConfig, dep_defaults: DependencyDefaults = DEPENDENCY_DEFAULTS
 ) -> "Callable[..., list[FilterTypes]]":
@@ -456,19 +459,26 @@ def _create_filter_aggregate_function_fastapi(  # noqa: C901
 
     if sort_field := config.get("sort_field"):
         sort_order_default = config.get("sort_order", "desc")
-        default_field, allowed_fields = _resolve_sort_fields(sort_field)
-        allowed_field_names = ", ".join(sorted(allowed_fields))
+        sort_resolution = resolve_sort_field_aliases(
+            sort_field,
+            sort_field_aliases=config.get("sort_field_aliases"),
+            sort_field_camelize=config.get("sort_field_camelize", True),
+        )
+        allowed_field_names = ", ".join(sort_resolution.allowed_display_names)
 
         def provide_order_by(
-            field_name: Annotated[str, Query(alias="orderBy", description="Field to order by.")] = default_field,
+            field_name: Annotated[str, Query(alias="orderBy", description="Field to order by.")] = (
+                sort_resolution.default_query_value
+            ),
             sort_order: Annotated[
                 SortOrder | None, Query(alias="sortOrder", description="Sort order ('asc' or 'desc').")
             ] = sort_order_default,
         ) -> OrderByFilter:
-            if field_name not in allowed_fields:
+            resolved_field = sort_resolution.normalize(field_name)
+            if resolved_field is None:
                 msg = f"Invalid orderBy field '{field_name}'. Allowed fields: {allowed_field_names}"
                 raise RequestValidationError(errors=[{"loc": ("query", "orderBy"), "msg": msg, "type": "value_error"}])
-            return OrderByFilter(field_name=field_name, sort_order=sort_order or sort_order_default)
+            return OrderByFilter(field_name=resolved_field, sort_order=sort_order or sort_order_default)
 
         param_name = dep_defaults.ORDER_BY_FILTER_DEPENDENCY_KEY
         params.append(

{sqlspec-0.46.0 → sqlspec-0.46.2}/sqlspec/extensions/litestar/providers.py

@@ -26,6 +26,7 @@ from sqlspec.core import (
     OrderByFilter,
     SearchFilter,
 )
+from sqlspec.extensions._filter_aliases import resolve_sort_field_aliases
 from sqlspec.utils.singleton import SingletonMeta
 from sqlspec.utils.text import camelize
 
@@ -85,24 +86,45 @@ class FieldNameType(NamedTuple):
 
 
 class FilterConfig(TypedDict):
-    """Configuration for generating dynamic filters."""
+    """Configuration for generated Litestar filter dependencies.
+
+    All keys are optional. A filter dependency is created only for each enabled
+    key. Field names are SQL-facing allowlist values; generated query parameter
+    names and order-by aliases remain API-facing.
+    """
 
     id_filter: NotRequired[type[UUID | int | str]]
+    """Type of ID filter to enable. When set, creates an ``ids`` collection filter."""
     id_field: NotRequired[str]
+    """SQL-facing field name for ID filtering. Defaults to ``"id"``."""
     sort_field: NotRequired[SortField]
+    """Allowed SQL-facing field or fields for ``orderBy`` sorting."""
+    sort_field_aliases: NotRequired[dict[str, str]]
+    """Additional API-facing ``orderBy`` aliases mapped to configured ``sort_field`` values."""
+    sort_field_camelize: NotRequired[bool]
+    """Whether to accept camel-case aliases for configured sort fields. Defaults to ``True``."""
     sort_order: NotRequired[SortOrder]
+    """Default sort order. Defaults to ``"desc"``."""
     pagination_type: NotRequired[Literal["limit_offset"]]
+    """Pagination strategy to enable. Currently supports ``"limit_offset"``."""
     pagination_size: NotRequired[int]
+    """Default page size for limit/offset pagination."""
     search: NotRequired[str | set[str] | list[str]]
+    """SQL-facing field or fields to search. Strings may be comma-separated."""
     search_ignore_case: NotRequired[bool]
+    """Whether search filtering is case-insensitive. Defaults to ``False``."""
     created_at: NotRequired[bool]
+    """Whether to enable ``created_at`` before/after range filtering."""
     updated_at: NotRequired[bool]
+    """Whether to enable ``updated_at`` before/after range filtering."""
     not_in_fields: NotRequired[FieldNameType | set[FieldNameType] | list[str | FieldNameType]]
+    """Field or fields that support ``NOT IN`` collection filtering."""
     in_fields: NotRequired[FieldNameType | set[FieldNameType] | list[str | FieldNameType]]
+    """Field or fields that support ``IN`` collection filtering."""
     null_fields: NotRequired[str | set[str] | list[str]]
-    """Fields that support IS NULL filtering."""
+    """Field or fields that support ``IS NULL`` filtering."""
     not_null_fields: NotRequired[str | set[str] | list[str]]
-    """Fields that support IS NOT NULL filtering."""
+    """Field or fields that support ``IS NOT NULL`` filtering."""
 
 
 class DependencyCache(metaclass=SingletonMeta):
@@ -164,14 +186,103 @@ def _make_hashable(value: Any) -> HashableType:
     return str(value)
 
 
-def _resolve_sort_fields(sort_field: SortField) -> tuple[str, set[str]]:
-    if isinstance(sort_field, str):
-        return sort_field, {sort_field}
-    fields = tuple(sorted(sort_field)) if isinstance(sort_field, set) else tuple(sort_field)
-    return fields[0], set(fields)
+def _build_in_collection_provider(field: FieldNameType, *, negated: bool) -> Callable[..., Any]:
+    """Build a per-field `IN` / `NOT IN` filter provider with a unique parameter name.
+
+    Litestar's dependency resolver collapses parameters across distinct ``Provide()``
+    instances by Python parameter name, ignoring per-instance ``Parameter(query=...)``
+    aliases. Giving each provider a unique parameter name (via ``__signature__``)
+    prevents siblings in the same family from cross-binding (issue #435).
+    """
+    type_hint = field.type_hint
+    field_name = field.name
+    param_name = f"{field_name}_values"
+    alias = camelize(f"{field_name}_{'not_in' if negated else 'in'}")
+    filter_cls: Any = NotInCollectionFilter if negated else InCollectionFilter
+    annotation = list[type_hint] | None  # type: ignore[valid-type]
+    return_annotation = filter_cls[type_hint] | None
+
+    def provide(**kwargs: Any) -> Any:
+        values = kwargs.get(param_name)
+        return filter_cls[type_hint](field_name=field_name, values=values) if values else None
+
+    provide.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                param_name,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=alias, default=None, required=False),
+                annotation=annotation,
+            )
+        ],
+        return_annotation=return_annotation,
+    )
+    provide.__annotations__ = {param_name: annotation, "return": return_annotation}
+    return provide
+
+
+def _build_null_provider(field_name: str, *, negated: bool) -> Callable[..., Any]:
+    """Build a per-field ``IS NULL`` / ``IS NOT NULL`` provider with a unique parameter name (issue #435)."""
+    suffix = "is_not_null" if negated else "is_null"
+    param_name = f"{field_name}_{suffix}"
+    alias = camelize(f"{field_name}_{suffix}")
+    filter_cls: type[Any] = NotNullFilter if negated else NullFilter
+    annotation = bool | None
+    return_annotation = filter_cls | None
+
+    def provide(**kwargs: Any) -> Any:
+        flag = kwargs.get(param_name)
+        return filter_cls(field_name=field_name) if flag else None
+
+    provide.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                param_name,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=alias, default=None, required=False),
+                annotation=annotation,
+            )
+        ],
+        return_annotation=return_annotation,
+    )
+    provide.__annotations__ = {param_name: annotation, "return": return_annotation}
+    return provide
+
 
+def _build_before_after_provider(field_name: str, before_alias: str, after_alias: str) -> Callable[..., Any]:
+    """Build a ``BeforeAfterFilter`` provider with unique ``before``/``after`` parameter names (issue #435).
 
-def _create_statement_filters(  # noqa: C901
+    ``created_at`` and ``updated_at`` providers both used ``before``/``after``, so when
+    enabled together they cross-bound to whichever query alias Litestar resolved first.
+    """
+    before_param = f"{field_name}_before"
+    after_param = f"{field_name}_after"
+
+    def provide(**kwargs: Any) -> BeforeAfterFilter:
+        return BeforeAfterFilter(field_name, kwargs.get(before_param), kwargs.get(after_param))
+
+    provide.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                before_param,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=before_alias, default=None, required=False),
+                annotation=DTorNone,
+            ),
+            inspect.Parameter(
+                after_param,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=after_alias, default=None, required=False),
+                annotation=DTorNone,
+            ),
+        ],
+        return_annotation=BeforeAfterFilter,
+    )
+    provide.__annotations__ = {before_param: DTorNone, after_param: DTorNone, "return": BeforeAfterFilter}
+    return provide
+
+
+def _create_statement_filters(
     config: FilterConfig, dep_defaults: DependencyDefaults = DEPENDENCY_DEFAULTS
 ) -> dict[str, Provide]:
     """Create filter dependencies based on configuration.
@@ -195,24 +306,14 @@ def _create_statement_filters(  # noqa: C901
         filters[dep_defaults.ID_FILTER_DEPENDENCY_KEY] = Provide(provide_id_filter, sync_to_thread=False)  # pyright: ignore[reportUnknownArgumentType]
 
     if config.get("created_at", False):
-
-        def provide_created_filter(
-            before: DTorNone = Parameter(query="createdBefore", default=None, required=False),
-            after: DTorNone = Parameter(query="createdAfter", default=None, required=False),
-        ) -> BeforeAfterFilter:
-            return BeforeAfterFilter("created_at", before, after)
-
-        filters[dep_defaults.CREATED_FILTER_DEPENDENCY_KEY] = Provide(provide_created_filter, sync_to_thread=False)
+        filters[dep_defaults.CREATED_FILTER_DEPENDENCY_KEY] = Provide(
+            _build_before_after_provider("created_at", "createdBefore", "createdAfter"), sync_to_thread=False
+        )
 
     if config.get("updated_at", False):
-
-        def provide_updated_filter(
-            before: DTorNone = Parameter(query="updatedBefore", default=None, required=False),
-            after: DTorNone = Parameter(query="updatedAfter", default=None, required=False),
-        ) -> BeforeAfterFilter:
-            return BeforeAfterFilter("updated_at", before, after)
-
-        filters[dep_defaults.UPDATED_FILTER_DEPENDENCY_KEY] = Provide(provide_updated_filter, sync_to_thread=False)
+        filters[dep_defaults.UPDATED_FILTER_DEPENDENCY_KEY] = Provide(
+            _build_before_after_provider("updated_at", "updatedBefore", "updatedAfter"), sync_to_thread=False
+        )
 
     if config.get("pagination_type") == "limit_offset":
 
@@ -252,21 +353,25 @@ def _create_statement_filters(  # noqa: C901
         filters[dep_defaults.SEARCH_FILTER_DEPENDENCY_KEY] = Provide(provide_search_filter, sync_to_thread=False)
 
     if sort_field := config.get("sort_field"):
-        default_field, allowed_fields = _resolve_sort_fields(sort_field)
-        allowed_field_names = ", ".join(sorted(allowed_fields))
+        sort_resolution = resolve_sort_field_aliases(
+            sort_field,
+            sort_field_aliases=config.get("sort_field_aliases"),
+            sort_field_camelize=config.get("sort_field_camelize", True),
+        )
+        allowed_field_names = ", ".join(sort_resolution.allowed_display_names)
         sort_order_default = config.get("sort_order", "desc")
 
         def provide_order_by(
             field_name: StringOrNone = Parameter(
-                title="Order by field", query="orderBy", default=default_field, required=False
+                title="Order by field", query="orderBy", default=sort_resolution.default_query_value, required=False
             ),
             sort_order: SortOrderOrNone = Parameter(
                 title="Field to search", query="sortOrder", default=sort_order_default, required=False
             ),
         ) -> OrderByFilter:
-            resolved_field = field_name or default_field
-            if resolved_field not in allowed_fields:
-                msg = f"Invalid orderBy field '{resolved_field}'. Allowed fields: {allowed_field_names}"
+            resolved_field = sort_resolution.normalize(field_name) if field_name else sort_resolution.default_field
+            if resolved_field is None:
+                msg = f"Invalid orderBy field '{field_name}'. Allowed fields: {allowed_field_names}"
                 raise ValidationException(detail=msg)
             return OrderByFilter(field_name=resolved_field, sort_order=sort_order or sort_order_default)
 
@@ -276,85 +381,33 @@ def _create_statement_filters(  # noqa: C901
         not_in_fields = {not_in_fields} if isinstance(not_in_fields, (str, FieldNameType)) else not_in_fields
 
         for field_def in not_in_fields:
-            field_def = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
-
-            def create_not_in_filter_provider(  # pyright: ignore
-                field_name: FieldNameType,
-            ) -> Callable[..., NotInCollectionFilter[field_def.type_hint] | None]:  # type: ignore
-                def provide_not_in_filter(  # pyright: ignore
-                    values: list[field_name.type_hint] | None = Parameter(  # type: ignore
-                        query=camelize(f"{field_name.name}_not_in"), default=None, required=False
-                    ),
-                ) -> NotInCollectionFilter[field_name.type_hint] | None:  # type: ignore
-                    return (
-                        NotInCollectionFilter[field_name.type_hint](field_name=field_name.name, values=values)  # type: ignore
-                        if values
-                        else None
-                    )
-
-                return provide_not_in_filter  # pyright: ignore
-
-            provider = create_not_in_filter_provider(field_def)  # pyright: ignore
-            filters[f"{field_def.name}_not_in_filter"] = Provide(provider, sync_to_thread=False)  # pyright: ignore
+            resolved = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
+            filters[f"{resolved.name}_not_in_filter"] = Provide(
+                _build_in_collection_provider(resolved, negated=True), sync_to_thread=False
+            )
 
     if in_fields := config.get("in_fields"):
         in_fields = {in_fields} if isinstance(in_fields, (str, FieldNameType)) else in_fields
 
         for field_def in in_fields:
-            field_def = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
-
-            def create_in_filter_provider(  # pyright: ignore
-                field_name: FieldNameType,
-            ) -> Callable[..., InCollectionFilter[field_def.type_hint] | None]:  # type: ignore # pyright: ignore
-                def provide_in_filter(  # pyright: ignore
-                    values: list[field_name.type_hint] | None = Parameter(  # type: ignore # pyright: ignore
-                        query=camelize(f"{field_name.name}_in"), default=None, required=False
-                    ),
-                ) -> InCollectionFilter[field_name.type_hint] | None:  # type: ignore # pyright: ignore
-                    return (
-                        InCollectionFilter[field_name.type_hint](field_name=field_name.name, values=values)  # type: ignore  # pyright: ignore
-                        if values
-                        else None
-                    )
-
-                return provide_in_filter  # pyright: ignore
-
-            provider = create_in_filter_provider(field_def)  # type: ignore
-            filters[f"{field_def.name}_in_filter"] = Provide(provider, sync_to_thread=False)  # pyright: ignore
+            resolved = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
+            filters[f"{resolved.name}_in_filter"] = Provide(
+                _build_in_collection_provider(resolved, negated=False), sync_to_thread=False
+            )
 
     if null_fields := config.get("null_fields"):
         null_fields = {null_fields} if isinstance(null_fields, str) else set(null_fields)
-
         for field_name in null_fields:
-
-            def create_null_filter_provider(fname: str) -> Callable[..., NullFilter | None]:
-                def provide_null_filter(
-                    is_null: bool | None = Parameter(query=camelize(f"{fname}_is_null"), default=None, required=False),
-                ) -> NullFilter | None:
-                    return NullFilter(field_name=fname) if is_null else None
-
-                return provide_null_filter
-
-            null_provider = create_null_filter_provider(field_name)
-            filters[f"{field_name}_null_filter"] = Provide(null_provider, sync_to_thread=False)
+            filters[f"{field_name}_null_filter"] = Provide(
+                _build_null_provider(field_name, negated=False), sync_to_thread=False
+            )
 
     if not_null_fields := config.get("not_null_fields"):
         not_null_fields = {not_null_fields} if isinstance(not_null_fields, str) else set(not_null_fields)
-
         for field_name in not_null_fields:
-
-            def create_not_null_filter_provider(fname: str) -> Callable[..., NotNullFilter | None]:
-                def provide_not_null_filter(
-                    is_not_null: bool | None = Parameter(
-                        query=camelize(f"{fname}_is_not_null"), default=None, required=False
-                    ),
-                ) -> NotNullFilter | None:
-                    return NotNullFilter(field_name=fname) if is_not_null else None
-
-                return provide_not_null_filter
-
-            not_null_provider = create_not_null_filter_provider(field_name)
-            filters[f"{field_name}_not_null_filter"] = Provide(not_null_provider, sync_to_thread=False)
+            filters[f"{field_name}_not_null_filter"] = Provide(
+                _build_null_provider(field_name, negated=True), sync_to_thread=False
+            )
 
     if filters:
         filters[dep_defaults.FILTERS_DEPENDENCY_KEY] = Provide(