fastapi-rtk 2.3.2__tar.gz → 2.3.4__tar.gz

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.3.2
+Version: 2.3.4
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.3.4/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.3.4"

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.4}/fastapi_rtk/api/base_api.py

@@ -1,14 +1,14 @@
+import collections.abc
 import typing
-from typing import TYPE_CHECKING, Any, Dict
 
-from fastapi import APIRouter, Depends
+import fastapi
 
 from ..const import PERMISSION_PREFIX, logger
 from ..registry import APIRouteRegistry
 from ..utils import T, lazy_self, update_signature
 from ..utils import lazy as o_lazy
 
-if TYPE_CHECKING:
+if typing.TYPE_CHECKING:
     from ..fastapi_react_toolkit import FastAPIReactToolkit
 
 __all__ = ["BaseApi"]
@@ -88,9 +88,9 @@ class BaseApi:
     """
     routes_to_register: list[
         tuple[
-            typing.Callable,
+            collections.abc.Callable,
             dict[str, typing.Any],
-            typing.Callable,
+            collections.abc.Callable,
             dict[str, typing.Any],
         ]
     ] = lazy(lambda self: [])
@@ -103,14 +103,14 @@ class BaseApi:
     """
     The FastAPIReactToolkit object. Automatically set when the API is added to the toolkit.
     """
-    cache: Dict[str, Any] = lazy(lambda self: dict())
+    cache: dict[str, typing.Any] = lazy(lambda self: dict())
     """
     The cache for the API.
     
     DO NOT MODIFY.
     """
     router = lazy(
-        lambda self: APIRouter(
+        lambda self: fastapi.APIRouter(
             prefix=f"/api/{self.version}/{self.resource_name}",
             tags=[self.__class__.__name__],
         )
@@ -139,7 +139,7 @@ class BaseApi:
         """
         pass
 
-    def integrate_router(self, app: APIRouter):
+    def integrate_router(self, app: fastapi.APIRouter):
         """
         Integrates the router into the FastAPI app.
 
@@ -157,7 +157,7 @@ class BaseApi:
             if self.toolkit.global_user_dependency and not ignore_g_user:
                 from ..dependencies import set_global_user
 
-                rest_data["dependencies"] = [Depends(set_global_user())] + (
+                rest_data["dependencies"] = [fastapi.Depends(set_global_user())] + (
                     rest_data.get("dependencies") or []
                 )
 
@@ -213,10 +213,10 @@ class BaseApi:
                                 else:
                                     resolved_kwargs[key] = val
                             resolved_dependencies.append(
-                                Depends(func(**resolved_kwargs))
+                                fastapi.Depends(func(**resolved_kwargs))
                             )
                         else:
-                            resolved_dependencies.append(Depends(func))
+                            resolved_dependencies.append(fastapi.Depends(func))
 
                     path, methods, rest_data = (
                         data["path"],

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.4}/fastapi_rtk/api/model_rest_api/__init__.py

@@ -22,13 +22,12 @@ remain on the composed class so they can be overridden in subclasses with
 the usual ``class MyApi(ModelRestApi): list_columns = [...]`` idiom.
 """
 
+import collections.abc
 import enum
 import typing
 
 import fastapi
 import pydantic
-from fastapi import Depends
-from pydantic import BaseModel, Field
 
 from ...backends.sqla.filters import BaseFilter, BaseOprFilter
 from ...backends.sqla.interface import SQLAInterface
@@ -52,7 +51,7 @@ from ...utils import T, lazy_self, merge_schema
 from ..base_api import BaseApi
 from ._add_mixin import AddMixin
 from ._bulk_mixin import BulkMixin
-from ._columns import ColumnsMixin
+from ._columns_mixin import ColumnsMixin
 from ._delete_mixin import DeleteMixin
 from ._download_mixin import DownloadMixin
 from ._edit_mixin import EditMixin
@@ -172,17 +171,17 @@ class ModelRestApi(
     """
     The list of routes to expose. Available routes: `info`, `download`, `bulk`, `get_list`, `get`, `post`, `put`, `delete`.
     """
-    exclude_routes: typing.List[AVAILABLE_ROUTES] = lazy(lambda: [])
+    exclude_routes: list[AVAILABLE_ROUTES] = lazy(lambda: [])
     """
     The list of routes to exclude. Available routes: `info`, `download`, `bulk`, `get_list`, `get`, `post`, `put`, `delete`.
     """
-    protected_routes: typing.List[AVAILABLE_ROUTES] = lazy(
+    protected_routes: list[AVAILABLE_ROUTES] = lazy(
         lambda self: [x for x in self.routes if x not in self.exclude_protected_routes]
     )
     """
     The list of routes to protect. Defaults to all routes within `routes` property except those in `exclude_protected_routes`.
     """
-    exclude_protected_routes: typing.List[AVAILABLE_ROUTES] = lazy(lambda: [])
+    exclude_protected_routes: list[AVAILABLE_ROUTES] = lazy(lambda: [])
     """
     The list of routes to exclude from protection. Defaults to `[]`.
     """
@@ -199,7 +198,7 @@ class ModelRestApi(
     }
     ```
     """
-    base_order: typing.Tuple[str, typing.Literal["asc", "desc"]] | None = None
+    base_order: tuple[str, typing.Literal["asc", "desc"]] | None = None
     """
     The default order for the list endpoint. Set this to set the default order for the list endpoint.
 
@@ -208,9 +207,7 @@ class ModelRestApi(
     base_order = ("name", "asc")
     ```
     """
-    base_filters: (
-        typing.List[typing.Tuple[str, typing.Type[BaseFilter], typing.Any]] | None
-    ) = None
+    base_filters: list[tuple[str, type[BaseFilter], typing.Any]] | None = None
     """
     The default filters to apply for the following endpoints: `download`, `list`, `show`, `add`, and `edit`. Defaults to None.
 
@@ -221,9 +218,7 @@ class ModelRestApi(
     ]
     ```
     """
-    base_opr_filters: (
-        typing.List[typing.Tuple[typing.Type[BaseOprFilter], typing.Any]] | None
-    ) = None
+    base_opr_filters: list[tuple[type[BaseOprFilter], typing.Any]] | None = None
     """
     The default opr filters to apply for the following endpoints: `download`, `list`, `show`, `add`, and `edit`. Defaults to None.
 
@@ -234,7 +229,7 @@ class ModelRestApi(
     ]
     ```
     """
-    opr_filters: typing.List[typing.Type[BaseOprFilter]] | None = None
+    opr_filters: list[type[BaseOprFilter]] | None = None
     """
     The list of opr filters to be exposed to the user. Defaults to None, which means no opr filters will be exposed.
 
@@ -269,15 +264,15 @@ class ModelRestApi(
     """
     The enum for the order columns in the list endpoint.
     """
-    query_schema: typing.Type[QuerySchema] = lazy(
+    query_schema: type[QuerySchema] = lazy(
         lambda self: merge_schema(
             QuerySchema,
             {
                 "order_column": (
                     self.order_column_enum | None,
-                    Field(default=None),
+                    pydantic.Field(default=None),
                 ),
-                "page_size": (int | None, Field(default=self.page_size)),
+                "page_size": (int | None, pydantic.Field(default=self.page_size)),
             },
             True,
             f"{self.__class__.__name__}-QuerySchema",
@@ -288,12 +283,15 @@ class ModelRestApi(
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    download_body_schema: typing.Type[QueryBody] = lazy(
+    download_body_schema: type[QueryBody] = lazy(
         lambda self: merge_schema(
             QueryBody,
             {
-                "order_column": (self.order_column_enum | None, Field(default=None)),
-                "page_size": (int | None, Field(default=self.page_size)),
+                "order_column": (
+                    self.order_column_enum | None,
+                    pydantic.Field(default=None),
+                ),
+                "page_size": (int | None, pydantic.Field(default=self.page_size)),
             },
             True,
             f"{self.__class__.__name__}-DownloadBodySchema",
@@ -335,7 +333,7 @@ class ModelRestApi(
     ```
     """
     add_query_rel_fields = lazy(
-        lambda: dict[str, list[tuple[str, typing.Type[BaseFilter], typing.Any]]]()
+        lambda: dict[str, list[tuple[str, type[BaseFilter], typing.Any]]]()
     )
     """
     The query fields for the related fields in the add_columns property.
@@ -350,7 +348,7 @@ class ModelRestApi(
     ```
     """
     edit_query_rel_fields = lazy(
-        lambda: dict[str, list[tuple[str, typing.Type[BaseFilter], typing.Any]]]()
+        lambda: dict[str, list[tuple[str, type[BaseFilter], typing.Any]]]()
     )
     """
     The query fields for the related fields in the edit_columns property.
@@ -365,7 +363,7 @@ class ModelRestApi(
     ```
     """
     search_query_rel_fields = lazy(
-        lambda: dict[str, list[tuple[str, typing.Type[BaseFilter], typing.Any]]]()
+        lambda: dict[str, list[tuple[str, type[BaseFilter], typing.Any]]]()
     )
     """
     The query fields for the related fields in the filters.
@@ -392,7 +390,7 @@ class ModelRestApi(
     }
     ```
     """
-    search_filters = lazy(lambda: dict[str, list[typing.Type[BaseFilter]]]())
+    search_filters = lazy(lambda: dict[str, list[type[BaseFilter]]]())
     """
     Add additional filters to the search columns.
 
@@ -403,9 +401,7 @@ class ModelRestApi(
     }
     ```
     """
-    search_exclude_filters = lazy(
-        lambda: dict[str, list[typing.Type[BaseFilter] | str]]()
-    )
+    search_exclude_filters = lazy(lambda: dict[str, list[type[BaseFilter] | str]]())
     """
     Exclude filters from the search columns.
 
@@ -418,28 +414,42 @@ class ModelRestApi(
     }
     ```
     """
-    info_return_schema: typing.Type[InfoResponse] = lazy(
+    info_return_schema: type[InfoResponse] = lazy(
         lambda self: merge_schema(
             InfoResponse,
             {
-                "add_title": (str, Field(default_factory=lambda: self.add_title)),
-                "edit_title": (str, Field(default_factory=lambda: self.edit_title)),
-                "filter_options": (dict, Field(default={})),
+                "add_title": (
+                    str,
+                    pydantic.Field(default_factory=lambda: self.add_title),
+                ),
+                "edit_title": (
+                    str,
+                    pydantic.Field(default_factory=lambda: self.edit_title),
+                ),
+                "filter_options": (dict, pydantic.Field(default={})),
                 "add_translations": (
                     dict,
-                    Field(default_factory=lambda: self.add_jsonforms_translations),
+                    pydantic.Field(
+                        default_factory=lambda: self.add_jsonforms_translations
+                    ),
                 ),
                 "edit_translations": (
                     dict,
-                    Field(default_factory=lambda: self.edit_jsonforms_translations),
+                    pydantic.Field(
+                        default_factory=lambda: self.edit_jsonforms_translations
+                    ),
                 ),
                 "add_type": (
                     typing.Literal["json"] | typing.Literal["form"],
-                    Field(default="form" if self._is_form_data_add else "json"),
+                    pydantic.Field(
+                        default="form" if self._is_form_data_add else "json"
+                    ),
                 ),
                 "edit_type": (
                     typing.Literal["json"] | typing.Literal["form"],
-                    Field(default="form" if self._is_form_data_edit else "json"),
+                    pydantic.Field(
+                        default="form" if self._is_form_data_edit else "json"
+                    ),
                 ),
             },
             name=f"{self.__class__.__name__}-InfoResponse",
@@ -646,11 +656,15 @@ class ModelRestApi(
     -------------
     """
 
-    add_jsonforms_schema: typing.Dict[str, typing.Any] | None = None
+    add_jsonforms_schema: (
+        dict[str, typing.Any]
+        | collections.abc.Callable[[], dict | collections.abc.Awaitable[dict]]
+        | None
+    ) = None
     """
-    The `JSONForms` schema for the add endpoint. If not provided, Defaults to the schema generated from the `add_columns` property.
+    The `JSONForms` schema for the add endpoint. If not provided, Defaults to the schema generated from the `add_columns` property. May also be a sync or async callable returning the schema, resolved via `smart_run`.
     """
-    add_jsonforms_uischema: typing.Dict[str, typing.Any] | None = None
+    add_jsonforms_uischema: dict[str, typing.Any] | None = None
     """
     The `JSONForms` uischema for the add endpoint. If not provided, it will let `JSONForms` generate the uischema.
     """
@@ -660,11 +674,15 @@ class ModelRestApi(
     """
     add_jsonforms_use_enum: (
         bool
-        | typing.Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool]
+        | collections.abc.Callable[
+            [ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool
+        ]
         | dict[
             str,
             bool
-            | typing.Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool],
+            | collections.abc.Callable[
+                [ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool
+            ],
         ]
     ) = lazy(lambda: lambda info: len(info.values) > 100)
     """
@@ -688,11 +706,15 @@ class ModelRestApi(
     A workaround for issue https://github.com/eclipsesource/jsonforms/issues/2271
     """
 
-    edit_jsonforms_schema: typing.Dict[str, typing.Any] | None = None
+    edit_jsonforms_schema: (
+        dict[str, typing.Any]
+        | collections.abc.Callable[[], dict | collections.abc.Awaitable[dict]]
+        | None
+    ) = None
     """
-    The `JSONForms` schema for the edit endpoint. If not provided, Defaults to the schema generated from the `edit_columns` property.
+    The `JSONForms` schema for the edit endpoint. If not provided, Defaults to the schema generated from the `edit_columns` property. May also be a sync or async callable returning the schema, resolved via `smart_run`.
     """
-    edit_jsonforms_uischema: typing.Dict[str, typing.Any] | None = None
+    edit_jsonforms_uischema: dict[str, typing.Any] | None = None
     """
     The `JSONForms` uischema for the edit endpoint. If not provided, it will let `JSONForms` generate the uischema.
     """
@@ -702,11 +724,15 @@ class ModelRestApi(
     """
     edit_jsonforms_use_enum: (
         bool
-        | typing.Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool]
+        | collections.abc.Callable[
+            [ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool
+        ]
         | dict[
             str,
             bool
-            | typing.Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool],
+            | collections.abc.Callable[
+                [ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool
+            ],
         ]
     ) = lazy(lambda: lambda info: len(info.values) > 100)
     """
@@ -800,14 +826,14 @@ class ModelRestApi(
     -------------
     """
 
-    add_schema: typing.Type[BaseModel] = lazy(
+    add_schema: type[pydantic.BaseModel] = lazy(
         lambda self: typing.Annotated[
-            self._create_request_schema(
-                merge_schema(
+            merge_schema(
+                self._create_request_schema(
                     self.add_obj_schema,
-                    self._handle_schema_extra_fields(self.add_schema_extra_fields),
-                    name=f"{self.__class__.__name__}-AddObjSchema-Merged",
+                    name=f"{self.__class__.__name__}-AddObjSchema-Request",
                 ),
+                self._handle_schema_extra_fields(self.add_schema_extra_fields),
                 name=f"{self.__class__.__name__}-AddSchema",
             ),
             fastapi.Form(media_type="multipart/form-data")
@@ -820,15 +846,15 @@ class ModelRestApi(
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    edit_schema: typing.Type[BaseModel] = lazy(
+    edit_schema: type[pydantic.BaseModel] = lazy(
         lambda self: typing.Annotated[
-            self._create_request_schema(
-                merge_schema(
+            merge_schema(
+                self._create_request_schema(
                     self.edit_obj_schema,
-                    self._handle_schema_extra_fields(self.edit_schema_extra_fields),
-                    name=f"{self.__class__.__name__}-EditObjSchema-Merged",
+                    optional=True,
+                    name=f"{self.__class__.__name__}-EditObjSchema-Request",
                 ),
-                optional=True,
+                self._handle_schema_extra_fields(self.edit_schema_extra_fields),
                 name=f"{self.__class__.__name__}-EditSchema",
             ),
             fastapi.Form(media_type="multipart/form-data")
@@ -847,11 +873,13 @@ class ModelRestApi(
     """
     Extra fields to add to the add schema. Useful when you want to add extra fields in the body of the add endpoint for your custom logic.
 
+    Keys must not collide with `add_columns`; a colliding name raises `ValueError` at API setup, since extra fields override the request body but not the JSONForms / object schema.
+
     Example:
     ```python
     add_schema_extra_fields = {
         "extra_field": str,
-        "extra_field_with_field_info": (str, Field(default="default_value")),
+        "extra_field_with_field_info": (str, pydantic.Field(default="default_value")),
     }
     ```
     """
@@ -861,11 +889,13 @@ class ModelRestApi(
     """
     Extra fields to add to the edit schema. Useful when you want to add extra fields in the body of the edit endpoint for your custom logic.
 
+    Keys must not collide with `edit_columns`; a colliding name raises `ValueError` at API setup, since extra fields override the request body but not the JSONForms / object schema.
+
     Example:
     ```python
     edit_schema_extra_fields = {
         "extra_field": str,
-        "extra_field_with_field_info": (str, Field(default="default_value")),
+        "extra_field_with_field_info": (str, pydantic.Field(default="default_value")),
     }
     ```
     """
@@ -876,12 +906,12 @@ class ModelRestApi(
     -------------
     """
 
-    list_return_schema: typing.Type[BaseResponseMany] = lazy(
+    list_return_schema: type[BaseResponseMany] = lazy(
         lambda self: merge_schema(
             BaseResponseMany,
             {
                 **vars(self),
-                "result": (typing.List[self.list_obj_schema], ...),
+                "result": (list[self.list_obj_schema], ...),
             },
             True,
             f"{self.__class__.__name__}-ListResponse",
@@ -892,7 +922,7 @@ class ModelRestApi(
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    show_return_schema: typing.Type[BaseResponseSingle] = lazy(
+    show_return_schema: type[BaseResponseSingle] = lazy(
         lambda self: merge_schema(
             BaseResponseSingle,
             {
@@ -908,7 +938,7 @@ class ModelRestApi(
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    add_return_schema: typing.Type[BaseResponseSingle] = lazy(
+    add_return_schema: type[BaseResponseSingle] = lazy(
         lambda self: merge_schema(
             self.show_return_schema,
             {},
@@ -920,7 +950,7 @@ class ModelRestApi(
 
     DO NOT MODIFY UNLESS YOU KNOW WHAT YOU ARE DOING.
     """
-    edit_return_schema: typing.Type[BaseResponseSingle] = lazy(
+    edit_return_schema: type[BaseResponseSingle] = lazy(
         lambda self: merge_schema(
             self.show_return_schema,
             {},
@@ -1032,6 +1062,23 @@ class ModelRestApi(
                 f"Search columns with 2nd level relations are not supported: {not_supported_search_columns}"
             )
 
+        # Extra fields override the request schema but never the JSONForms /
+        # object schema, so a name in both desyncs the form from the body.
+        add_collisions = set(self.add_schema_extra_fields) & set(self.add_columns)
+        if add_collisions:
+            raise ValueError(
+                f"add_schema_extra_fields keys collide with add_columns in "
+                f"{self.__class__.__name__}: {sorted(add_collisions)}. Remove them "
+                f"from add_columns or rename the extra fields."
+            )
+        edit_collisions = set(self.edit_schema_extra_fields) & set(self.edit_columns)
+        if edit_collisions:
+            raise ValueError(
+                f"edit_schema_extra_fields keys collide with edit_columns in "
+                f"{self.__class__.__name__}: {sorted(edit_collisions)}. Remove them "
+                f"from edit_columns or rename the extra fields."
+            )
+
         self._gen_labels_columns(self.list_columns)
         self._gen_labels_columns(self.show_columns)
         self._gen_labels_columns(self.search_columns)
@@ -1088,7 +1135,7 @@ class ModelRestApi(
         Returns the current permissions dependency.
 
         Returns:
-            typing.Callable[..., Coroutine[typing.Any, typing.Any, typing.Any | list]]: The current permissions that the user has for the API dependency.
+            collections.abc.Callable[..., Coroutine[typing.Any, typing.Any, typing.Any | list]]: The current permissions that the user has for the API dependency.
         """
         return current_permissions(self)
 
@@ -1099,12 +1146,12 @@ class ModelRestApi(
         If `list_query_count_enabled` is False or `q.with_count` is False, the session will be None.
 
         Returns:
-            typing.Callable[..., Coroutine[typing.Any, typing.Any, typing.Tuple[QuerySchema, SQLASession | None]]]: The dependency that yields the tuple.
+            collections.abc.Callable[..., Coroutine[typing.Any, typing.Any, tuple[QuerySchema, SQLASession | None]]]: The dependency that yields the tuple.
         """
 
         async def dependency(
-            q: self.query_schema = Depends(),  # type: ignore
-            session=Depends(self.datamodel.get_session_factory()),
+            q: self.query_schema = fastapi.Depends(),  # type: ignore
+            session=fastapi.Depends(self.datamodel.get_session_factory()),
         ):
             q: QuerySchema = q
             if not self.list_query_count_enabled or not q.with_count:

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.4}/fastapi_rtk/api/model_rest_api/_add_mixin.py

@@ -6,36 +6,18 @@ implementation, ``pre_add`` and ``post_add`` hooks.
 import typing
 
 import pydantic
-from pydantic import BaseModel
 
-from ...backends.sqla.filters import BaseFilter
-from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.model import Model
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES
 from ...decorators import expose, permission_name, priority, protect
-from ...schemas import BaseResponseSingle
 from ...utils import AsyncTaskRunner, SelfDepends, SelfType, smart_run
 from ._params import PARAM_BODY_SESSION
+from ._typed_base import _TypedModelRestApi
 
 
-class AddMixin:
+class AddMixin(_TypedModelRestApi):
     """Add endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        add_return_schema: typing.Type[BaseResponseSingle]
-        add_query_rel_fields: dict[
-            str, list[tuple[str, typing.Type[BaseFilter], typing.Any]]
-        ]
-        add_schema_extra_fields: dict[
-            str, type | tuple[type, pydantic.fields.FieldInfo]
-        ]
-        add_schema: typing.Type[BaseModel]
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-
     def post(self):
         """
         Post endpoint for the API.
@@ -54,7 +36,7 @@ class AddMixin:
 
     async def post_headless(
         self,
-        body: BaseModel = SelfType().add_schema,
+        body: pydantic.BaseModel = SelfType().add_schema,
         session: SQLASession = SelfDepends().datamodel.get_session_factory,
     ):
         """

{fastapi_rtk-2.3.2 → fastapi_rtk-2.3.4}/fastapi_rtk/api/model_rest_api/_bulk_mixin.py

@@ -3,27 +3,21 @@ Bulk route mixin for ``ModelRestApi``: ``bulk`` registration, ``bulk_headless``
 dispatcher, and the subclass-overridable ``bulk_handler``.
 """
 
-import typing
+import collections.abc
 
 import fastapi
-from fastapi import Body, HTTPException, Response
 
 from ...backends.sqla.interface import SQLAInterface
 from ...backends.sqla.session import SQLASession
-from ...const import AVAILABLE_ROUTES, ErrorCode
+from ...const import ErrorCode
 from ...decorators import expose, permission_name, priority, protect
 from ...utils import AsyncTaskRunner, SelfDepends, smart_run
+from ._typed_base import _TypedModelRestApi
 
 
-class BulkMixin:
+class BulkMixin(_TypedModelRestApi):
     """Bulk endpoint methods for ``ModelRestApi``."""
 
-    if typing.TYPE_CHECKING:
-        # Attributes supplied by the composed ``ModelRestApi`` class via MRO.
-        datamodel: SQLAInterface
-        expose_params: dict[AVAILABLE_ROUTES, dict[str, typing.Any]]
-        protected_routes: typing.List[AVAILABLE_ROUTES]
-
     def bulk(self):
         """
         Bulk endpoint for the API.
@@ -42,7 +36,7 @@ class BulkMixin:
     async def bulk_headless(
         self,
         handler: str,
-        body: dict | list = Body(...),
+        body: dict | list = fastapi.Body(...),
         session: SQLASession = SelfDepends().datamodel.get_session_factory,
     ):
         """
@@ -60,24 +54,24 @@ class BulkMixin:
             If you are overriding this method, make sure to copy all the decorators too.
         """
         async with AsyncTaskRunner():
-            bulk_handler: typing.Callable | None = getattr(
+            bulk_handler: collections.abc.Callable | None = getattr(
                 self, f"bulk_{handler}", None
             )
             if not bulk_handler:
-                raise HTTPException(
+                raise fastapi.HTTPException(
                     fastapi.status.HTTP_404_NOT_FOUND, ErrorCode.HANDLER_NOT_FOUND
                 )
             try:
                 return await smart_run(bulk_handler, body, self.datamodel, session)
             except NotImplementedError as e:
-                raise HTTPException(fastapi.status.HTTP_404_NOT_FOUND, str(e))
+                raise fastapi.HTTPException(fastapi.status.HTTP_404_NOT_FOUND, str(e))
 
     async def bulk_handler(
         self,
         body: dict | list,
         query: SQLAInterface,
         session: SQLASession,
-    ) -> Response:
+    ) -> fastapi.Response:
         """
         Bulk handler for the API, to be implemented by the subclass.