sqlspec 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

sqlspec/extensions/litestar/plugin.py

@@ -3,31 +3,26 @@ from typing import TYPE_CHECKING, Any, Union
 from litestar.di import Provide
 from litestar.plugins import InitPluginProtocol
 
-from sqlspec.base import (
-    AsyncConfigT,
-    DatabaseConfigProtocol,
-    DriverT,
-    SyncConfigT,
-)
 from sqlspec.base import SQLSpec as SQLSpecBase
+from sqlspec.config import AsyncConfigT, DatabaseConfigProtocol, DriverT, SyncConfigT
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.litestar.config import DatabaseConfig
 from sqlspec.typing import ConnectionT, PoolT
+from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
     from click import Group
     from litestar.config.app import AppConfig
 
+logger = get_logger("extensions.litestar")
+
 
 class SQLSpec(InitPluginProtocol, SQLSpecBase):
     """SQLSpec plugin."""
 
     __slots__ = ("_config", "_plugin_configs")
 
-    def __init__(
-        self,
-        config: Union["SyncConfigT", "AsyncConfigT", "DatabaseConfig", list["DatabaseConfig"]],
-    ) -> None:
+    def __init__(self, config: Union["SyncConfigT", "AsyncConfigT", "DatabaseConfig", list["DatabaseConfig"]]) -> None:
         """Initialize ``SQLSpecPlugin``.
 
         Args:
@@ -62,32 +57,32 @@ class SQLSpec(InitPluginProtocol, SQLSpecBase):
         Returns:
             The updated :class:`AppConfig <.config.app.AppConfig>` instance.
         """
+
         self._validate_dependency_keys()
 
         def store_sqlspec_in_state() -> None:
             app_config.state.sqlspec = self
 
         app_config.on_startup.append(store_sqlspec_in_state)
-
         # Register types for injection
         app_config.signature_types.extend(
-            [
-                SQLSpec,
-                ConnectionT,
-                PoolT,
-                DriverT,
-                DatabaseConfig,
-                DatabaseConfigProtocol,
-                SyncConfigT,
-                AsyncConfigT,
-            ]
+            [SQLSpec, ConnectionT, PoolT, DriverT, DatabaseConfig, DatabaseConfigProtocol, SyncConfigT, AsyncConfigT]
         )
 
+        # Create signature namespace for connection types
+        signature_namespace = {}
+
         for c in self._plugin_configs:
             c.annotation = self.add_config(c.config)
             app_config.signature_types.append(c.annotation)
             app_config.signature_types.append(c.config.connection_type)  # type: ignore[union-attr]
             app_config.signature_types.append(c.config.driver_type)  # type: ignore[union-attr]
+
+            # Get signature namespace from the config
+            if hasattr(c.config, "get_signature_namespace"):
+                config_namespace = c.config.get_signature_namespace()  # type: ignore[attr-defined]
+                signature_namespace.update(config_namespace)
+
             app_config.before_send.append(c.before_send_handler)
             app_config.lifespan.append(c.lifespan_handler)  # pyright: ignore[reportUnknownMemberType]
             app_config.dependencies.update(
@@ -95,9 +90,13 @@ class SQLSpec(InitPluginProtocol, SQLSpecBase):
                     c.connection_key: Provide(c.connection_provider),
                     c.pool_key: Provide(c.pool_provider),
                     c.session_key: Provide(c.session_provider),
-                },
+                }
             )
 
+        # Update app config with signature namespace
+        if signature_namespace:
+            app_config.signature_namespace.update(signature_namespace)
+
         return app_config
 
     def get_annotations(self) -> "list[type[Union[SyncConfigT, AsyncConfigT]]]":  # pyright: ignore[reportInvalidTypeVarUse]
@@ -109,8 +108,7 @@ class SQLSpec(InitPluginProtocol, SQLSpecBase):
         return [c.annotation for c in self.config]
 
     def get_annotation(
-        self,
-        key: "Union[str, SyncConfigT, AsyncConfigT, type[Union[SyncConfigT, AsyncConfigT]]]",
+        self, key: "Union[str, SyncConfigT, AsyncConfigT, type[Union[SyncConfigT, AsyncConfigT]]]"
     ) -> "type[Union[SyncConfigT, AsyncConfigT]]":
         """Return the annotation for the given configuration.
 

sqlspec/extensions/litestar/providers.py

@@ -9,28 +9,20 @@ You should not have modify this module very often and should only be invoked und
 import datetime
 import inspect
 from collections.abc import Callable
-from typing import (
-    Any,
-    Literal,
-    NamedTuple,
-    Optional,
-    TypedDict,
-    Union,
-    cast,
-)
+from typing import Any, Literal, NamedTuple, Optional, TypedDict, Union, cast
 from uuid import UUID
 
 from litestar.di import Provide
 from litestar.params import Dependency, Parameter
 from typing_extensions import NotRequired
 
-from sqlspec.filters import (
-    BeforeAfter,
-    CollectionFilter,
+from sqlspec.statement.filters import (
+    BeforeAfterFilter,
     FilterTypes,
-    LimitOffset,
+    InCollectionFilter,
+    LimitOffsetFilter,
     NotInCollectionFilter,
-    OrderBy,
+    OrderByFilter,
     SearchFilter,
 )
 from sqlspec.utils.singleton import SingletonMeta
@@ -214,8 +206,8 @@ def _create_statement_filters(
 
         def provide_id_filter(  # pyright: ignore[reportUnknownParameterType]
             ids: Optional[list[str]] = Parameter(query="ids", default=None, required=False),
-        ) -> CollectionFilter:  # pyright: ignore[reportMissingTypeArgument]
-            return CollectionFilter(field_name=config.get("id_field", "id"), values=ids)
+        ) -> InCollectionFilter:  # pyright: ignore[reportMissingTypeArgument]
+            return InCollectionFilter(field_name=config.get("id_field", "id"), values=ids)
 
         filters[dep_defaults.ID_FILTER_DEPENDENCY_KEY] = Provide(provide_id_filter, sync_to_thread=False)  # pyright: ignore[reportUnknownArgumentType]
 
@@ -224,8 +216,8 @@ def _create_statement_filters(
         def provide_created_filter(
             before: DTorNone = Parameter(query="createdBefore", default=None, required=False),
             after: DTorNone = Parameter(query="createdAfter", default=None, required=False),
-        ) -> BeforeAfter:
-            return BeforeAfter("created_at", before, after)
+        ) -> BeforeAfterFilter:
+            return BeforeAfterFilter("created_at", before, after)
 
         filters[dep_defaults.CREATED_FILTER_DEPENDENCY_KEY] = Provide(provide_created_filter, sync_to_thread=False)
 
@@ -234,8 +226,8 @@ def _create_statement_filters(
         def provide_updated_filter(
             before: DTorNone = Parameter(query="updatedBefore", default=None, required=False),
             after: DTorNone = Parameter(query="updatedAfter", default=None, required=False),
-        ) -> BeforeAfter:
-            return BeforeAfter("updated_at", before, after)
+        ) -> BeforeAfterFilter:
+            return BeforeAfterFilter("updated_at", before, after)
 
         filters[dep_defaults.UPDATED_FILTER_DEPENDENCY_KEY] = Provide(provide_updated_filter, sync_to_thread=False)
 
@@ -249,8 +241,8 @@ def _create_statement_filters(
                 default=config.get("pagination_size", dep_defaults.DEFAULT_PAGINATION_SIZE),
                 required=False,
             ),
-        ) -> LimitOffset:
-            return LimitOffset(page_size, page_size * (current_page - 1))
+        ) -> LimitOffsetFilter:
+            return LimitOffsetFilter(page_size, page_size * (current_page - 1))
 
         filters[dep_defaults.LIMIT_OFFSET_FILTER_DEPENDENCY_KEY] = Provide(
             provide_limit_offset_pagination, sync_to_thread=False
@@ -260,10 +252,7 @@ def _create_statement_filters(
 
         def provide_search_filter(
             search_string: StringOrNone = Parameter(
-                title="Field to search",
-                query="searchString",
-                default=None,
-                required=False,
+                title="Field to search", query="searchString", default=None, required=False
             ),
             ignore_case: BooleanOrNone = Parameter(
                 title="Search should be case sensitive",
@@ -287,19 +276,13 @@ def _create_statement_filters(
 
         def provide_order_by(
             field_name: StringOrNone = Parameter(
-                title="Order by field",
-                query="orderBy",
-                default=sort_field,
-                required=False,
+                title="Order by field", query="orderBy", default=sort_field, required=False
             ),
             sort_order: SortOrderOrNone = Parameter(
-                title="Field to search",
-                query="sortOrder",
-                default=config.get("sort_order", "desc"),
-                required=False,
+                title="Field to search", query="sortOrder", default=config.get("sort_order", "desc"), required=False
             ),
-        ) -> OrderBy:
-            return OrderBy(field_name=field_name, sort_order=sort_order)  # type: ignore[arg-type]
+        ) -> OrderByFilter:
+            return OrderByFilter(field_name=field_name, sort_order=sort_order)  # type: ignore[arg-type]
 
         filters[dep_defaults.ORDER_BY_FILTER_DEPENDENCY_KEY] = Provide(provide_order_by, sync_to_thread=False)
 
@@ -340,14 +323,14 @@ def _create_statement_filters(
 
             def create_in_filter_provider(  # pyright: ignore
                 field_name: FieldNameType,
-            ) -> Callable[..., Optional[CollectionFilter[field_def.type_hint]]]:  # type: ignore # pyright: ignore
+            ) -> Callable[..., Optional[InCollectionFilter[field_def.type_hint]]]:  # type: ignore # pyright: ignore
                 def provide_in_filter(  # pyright: ignore
                     values: Optional[list[field_name.type_hint]] = Parameter(  # type: ignore # pyright: ignore
                         query=camelize(f"{field_name.name}_in"), default=None, required=False
                     ),
-                ) -> Optional[CollectionFilter[field_name.type_hint]]:  # type: ignore # pyright: ignore
+                ) -> Optional[InCollectionFilter[field_name.type_hint]]:  # type: ignore # pyright: ignore
                     return (
-                        CollectionFilter[field_name.type_hint](field_name=field_name.name, values=values)  # type: ignore  # pyright: ignore
+                        InCollectionFilter[field_name.type_hint](field_name=field_name.name, values=values)  # type: ignore  # pyright: ignore
                         if values
                         else None
                     )
@@ -365,7 +348,7 @@ def _create_statement_filters(
     return filters
 
 
-def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., list[FilterTypes]]:  # noqa: PLR0915
+def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., list[FilterTypes]]:
     """Create a filter function based on the provided configuration.
 
     Args:
@@ -384,27 +367,27 @@ def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., lis
             name="id_filter",
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
             default=Dependency(skip_validation=True),
-            annotation=CollectionFilter[cls],  # type: ignore[valid-type]
+            annotation=InCollectionFilter[cls],  # type: ignore[valid-type]
         )
-        annotations["id_filter"] = CollectionFilter[cls]  # type: ignore[valid-type]
+        annotations["id_filter"] = InCollectionFilter[cls]  # type: ignore[valid-type]
 
     if config.get("created_at"):
         parameters["created_filter"] = inspect.Parameter(
             name="created_filter",
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
             default=Dependency(skip_validation=True),
-            annotation=BeforeAfter,
+            annotation=BeforeAfterFilter,
         )
-        annotations["created_filter"] = BeforeAfter
+        annotations["created_filter"] = BeforeAfterFilter
 
     if config.get("updated_at"):
         parameters["updated_filter"] = inspect.Parameter(
             name="updated_filter",
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
             default=Dependency(skip_validation=True),
-            annotation=BeforeAfter,
+            annotation=BeforeAfterFilter,
         )
-        annotations["updated_filter"] = BeforeAfter
+        annotations["updated_filter"] = BeforeAfterFilter
 
     if config.get("search"):
         parameters["search_filter"] = inspect.Parameter(
@@ -420,18 +403,18 @@ def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., lis
             name="limit_offset_filter",
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
             default=Dependency(skip_validation=True),
-            annotation=LimitOffset,
+            annotation=LimitOffsetFilter,
         )
-        annotations["limit_offset_filter"] = LimitOffset
+        annotations["limit_offset_filter"] = LimitOffsetFilter
 
     if config.get("sort_field"):
         parameters["order_by_filter"] = inspect.Parameter(
             name="order_by_filter",
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
             default=Dependency(skip_validation=True),
-            annotation=OrderBy,
+            annotation=OrderByFilter,
         )
-        annotations["order_by_filter"] = OrderBy
+        annotations["order_by_filter"] = OrderByFilter
 
     # Add parameters for not_in filters
     if not_in_fields := config.get("not_in_fields"):
@@ -453,9 +436,9 @@ def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., lis
                 name=f"{field_def.name}_in_filter",
                 kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
                 default=Dependency(skip_validation=True),
-                annotation=CollectionFilter[field_def.type_hint],  # type: ignore
+                annotation=InCollectionFilter[field_def.type_hint],  # type: ignore
             )
-            annotations[f"{field_def.name}_in_filter"] = CollectionFilter[field_def.type_hint]  # type: ignore
+            annotations[f"{field_def.name}_in_filter"] = InCollectionFilter[field_def.type_hint]  # type: ignore
 
     def provide_filters(**kwargs: FilterTypes) -> list[FilterTypes]:
         """Provide filter dependencies based on configuration.
@@ -483,7 +466,7 @@ def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., lis
         ):
             filters.append(search_filter)
         if (
-            (order_by := cast("Optional[OrderBy]", kwargs.get("order_by_filter")))
+            (order_by := cast("Optional[OrderByFilter]", kwargs.get("order_by_filter")))
             and order_by is not None  # pyright: ignore[reportUnnecessaryComparison]
             and order_by.field_name is not None  # pyright: ignore[reportUnnecessaryComparison]
         ):
@@ -512,8 +495,7 @@ def _create_filter_aggregate_function(config: FilterConfig) -> Callable[..., lis
 
     # Set both signature and annotations
     provide_filters.__signature__ = inspect.Signature(  # type: ignore
-        parameters=list(parameters.values()),
-        return_annotation=list[FilterTypes],
+        parameters=list(parameters.values()), return_annotation=list[FilterTypes]
     )
     provide_filters.__annotations__ = annotations
     provide_filters.__annotations__["return"] = list[FilterTypes]