docs: update README

exceptions

README.md

@@ -20,7 +20,7 @@ A modular collection of production-ready utilities for FastAPI. Install only wha
 
 ## Installation
 
-The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, model mixins, logging):
+The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, logging):
 
 ```bash
 uv add fastapi-toolsets
@@ -48,7 +48,6 @@ uv add "fastapi-toolsets[all]"
 - **Database**: Session management, transaction helpers, table locking, and polling-based row change detection
 - **Dependencies**: FastAPI dependency factories (`PathDependency`, `BodyDependency`) for automatic DB lookups from path or body parameters
 - **Fixtures**: Fixture system with dependency management, context support, and pytest integration
-- **Model Mixins**: SQLAlchemy mixins for common column patterns (`UUIDMixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`)
 - **Standardized API Responses**: Consistent response format with `Response`, `PaginatedResponse`, and `PydanticBase`
 - **Exception Handling**: Structured error responses with automatic OpenAPI documentation
 - **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`

docs/index.md

@@ -20,7 +20,7 @@ A modular collection of production-ready utilities for FastAPI. Install only wha
 
 ## Installation
 
-The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, model mixins, logging):
+The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, logging):
 
 ```bash
 uv add fastapi-toolsets
@@ -44,11 +44,10 @@ uv add "fastapi-toolsets[all]"
 
 ### Core
 
-- **CRUD**: Generic async CRUD operations with `CrudFactory`, built-in full-text/faceted search and Offset/Cursor pagination.
+- **CRUD**: Generic async CRUD operations with `CrudFactory`, built-in full-text/faceted search and offset/cursor pagination.
 - **Database**: Session management, transaction helpers, table locking, and polling-based row change detection
 - **Dependencies**: FastAPI dependency factories (`PathDependency`, `BodyDependency`) for automatic DB lookups from path or body parameters
 - **Fixtures**: Fixture system with dependency management, context support, and pytest integration
-- **Model Mixins**: SQLAlchemy mixins for common column patterns (`UUIDMixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`)
 - **Standardized API Responses**: Consistent response format with `Response`, `PaginatedResponse`, and `PydanticBase`
 - **Exception Handling**: Structured error responses with automatic OpenAPI documentation
 - **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`

docs/migration/v2.md

@@ -16,15 +16,15 @@ Previously `schema` was optional; omitting it returned raw SQLAlchemy model inst
 
     ```python
     # schema omitted — returned raw model instances
-    result = await UserCrud.offset_paginate(session=session, page=1)
-    result = await UserCrud.cursor_paginate(session=session, cursor=token)
+    result = await UserCrud.offset_paginate(session, page=1)
+    result = await UserCrud.cursor_paginate(session, cursor=token)
     ```
 
 === "Now (`v2`)"
 
     ```python
-    result = await UserCrud.offset_paginate(session=session, page=1, schema=UserRead)
-    result = await UserCrud.cursor_paginate(session=session, cursor=token, schema=UserRead)
+    result = await UserCrud.offset_paginate(session, page=1, schema=UserRead)
+    result = await UserCrud.cursor_paginate(session, cursor=token, schema=UserRead)
     ```
 
 ### `as_response` removed from `create()`, `get()`, and `update()`
@@ -36,17 +36,17 @@ The `as_response=True` shorthand is replaced by passing a `schema` directly. The
 === "Before (`v1`)"
 
     ```python
-    user = await UserCrud.create(session=session, obj=data, as_response=True)
-    user = await UserCrud.get(session=session, filters=filters, as_response=True)
-    user = await UserCrud.update(session=session, obj=data, filters, as_response=True)
+    user = await UserCrud.create(session, data, as_response=True)
+    user = await UserCrud.get(session, filters, as_response=True)
+    user = await UserCrud.update(session, data, filters, as_response=True)
     ```
 
 === "Now (`v2`)"
 
     ```python
-    user = await UserCrud.create(session=session, obj=data, schema=UserRead)
-    user = await UserCrud.get(session=session, filters=filters, schema=UserRead)
-    user = await UserCrud.update(session=session, obj=data, filters, schema=UserRead)
+    user = await UserCrud.create(session, data, schema=UserRead)
+    user = await UserCrud.get(session, filters, schema=UserRead)
+    user = await UserCrud.update(session, data, filters, schema=UserRead)
     ```
 
 ### `delete()`: `as_response` renamed and return type changed
@@ -61,19 +61,19 @@ Two changes were made to `delete()`:
 === "Before (`v1`)"
 
     ```python
-    ok = await UserCrud.delete(session=session, filters=filters)
+    ok = await UserCrud.delete(session, filters)
     if ok:  # True on success
         ...
 
-    response = await UserCrud.delete(session=session, filters=filters, as_response=True)
+    response = await UserCrud.delete(session, filters, as_response=True)
     ```
 
 === "Now (`v2`)"
 
     ```python
-    await UserCrud.delete(session=session, filters=filters)  # returns None
+    await UserCrud.delete(session, filters)  # returns None
 
-    response = await UserCrud.delete(session=session, filters=filters, return_response=True)
+    response = await UserCrud.delete(session, filters, return_response=True)
     ```
 
 ### `paginate()` alias removed
@@ -85,13 +85,13 @@ The `paginate` shorthand was an alias for `offset_paginate`. It has been removed
 === "Before (`v1`)"
 
     ```python
-    result = await UserCrud.paginate(session=session, page=2, items_per_page=20, schema=UserRead)
+    result = await UserCrud.paginate(session, page=2, items_per_page=20, schema=UserRead)
     ```
 
 === "Now (`v2`)"
 
     ```python
-    result = await UserCrud.offset_paginate(session=session, page=2, items_per_page=20, schema=UserRead)
+    result = await UserCrud.offset_paginate(session, page=2, items_per_page=20, schema=UserRead)
     ```
 
 ---

docs/module/crud.md

@@ -22,8 +22,6 @@ UserCrud = CrudFactory(model=User)
 
 ## Basic operations
 
-!!! info "`get_or_none` added in `v2.2`"
-
 ```python
 # Create
 user = await UserCrud.create(session=session, obj=UserCreateSchema(username="alice"))
@@ -31,9 +29,6 @@ user = await UserCrud.create(session=session, obj=UserCreateSchema(username="ali
 # Get one (raises NotFoundError if not found)
 user = await UserCrud.get(session=session, filters=[User.id == user_id])
 
-# Get one or None (never raises)
-user = await UserCrud.get_or_none(session=session, filters=[User.id == user_id])
-
 # Get first or None
 user = await UserCrud.first(session=session, filters=[User.email == email])
 
@@ -51,36 +46,6 @@ count = await UserCrud.count(session=session, filters=[User.is_active == True])
 exists = await UserCrud.exists(session=session, filters=[User.email == email])
 ```
 
-## Fetching a single record
-
-Three methods fetch a single record — choose based on how you want to handle the "not found" case and whether you need strict uniqueness:
-
-| Method | Not found | Multiple results |
-|---|---|---|
-| `get` | raises `NotFoundError` | raises `MultipleResultsFound` |
-| `get_or_none` | returns `None` | raises `MultipleResultsFound` |
-| `first` | returns `None` | returns the first match silently |
-
-Use `get` when the record must exist (e.g. a detail endpoint that should return 404):
-
-```python
-user = await UserCrud.get(session=session, filters=[User.id == user_id])
-```
-
-Use `get_or_none` when the record may not exist but you still want strict uniqueness enforcement:
-
-```python
-user = await UserCrud.get_or_none(session=session, filters=[User.email == email])
-if user is None:
-    ...  # handle missing case without catching an exception
-```
-
-Use `first` when you only care about any one match and don't need uniqueness:
-
-```python
-user = await UserCrud.first(session=session, filters=[User.is_active == True])
-```
-
 ## Pagination
 
 !!! info "Added in `v1.1` (only offset_pagination via `paginate` if `<v1.1`)"
@@ -212,9 +177,6 @@ Two search strategies are available, both compatible with [`offset_paginate`](..
 
 ### Full-text search
 
-!!! info "Added in `v2.2.1`"
-    The model's primary key is always included in `searchable_fields` automatically, so searching by ID works out of the box without any configuration. When no `searchable_fields` are declared, only the primary key is searched.
-
 Declare `searchable_fields` on the CRUD class. Relationship traversal is supported via tuples:
 
 ```python

docs/module/db.md

@@ -87,37 +87,6 @@ await wait_for_row_change(
 )
 ```
 
-## Creating a database
-
-!!! info "Added in `v2.1`"
-
-[`create_database`](../reference/db.md#fastapi_toolsets.db.create_database) creates a database at a given URL. It connects to *server_url* and issues a `CREATE DATABASE` statement:
-
-```python
-from fastapi_toolsets.db import create_database
-
-SERVER_URL = "postgresql+asyncpg://postgres:postgres@localhost/postgres"
-
-await create_database(db_name="myapp_test", server_url=SERVER_URL)
-```
-
-For test isolation with automatic cleanup, use [`create_worker_database`](../reference/pytest.md#fastapi_toolsets.pytest.utils.create_worker_database) from the `pytest` module instead — it handles drop-before, create, and drop-after automatically.
-
-## Cleaning up tables
-
-!!! info "Added in `v2.1`"
-
-[`cleanup_tables`](../reference/db.md#fastapi_toolsets.db.cleanup_tables) truncates all tables:
-
-```python
-from fastapi_toolsets.db import cleanup_tables
-
-@pytest.fixture(autouse=True)
-async def clean(db_session):
-    yield
-    await cleanup_tables(session=db_session, base=Base)
-```
-
 ---
 
 [:material-api: API Reference](../reference/db.md)

docs/module/metrics.md

@@ -36,13 +36,7 @@ This mounts the `/metrics` endpoint that Prometheus can scrape.
 
 ### Providers
 
-Providers are called once at startup by `init_metrics`. The return value (the Prometheus metric object) is stored in the registry and can be retrieved later with [`registry.get(name)`](../reference/metrics.md#fastapi_toolsets.metrics.registry.MetricsRegistry.get).
-
-Use providers when you want **deferred initialization**: the Prometheus metric is not registered with the global `CollectorRegistry` until `init_metrics` runs, not at import time. This is particularly useful for testing — importing the module in a test suite without calling `init_metrics` leaves no metrics registered, avoiding cross-test pollution.
-
-It is also useful when metrics are defined across multiple modules and merged with `include_registry`: any code that needs a metric can call `metrics.get()` on the shared registry instead of importing the metric directly from its origin module.
-
-If neither of these applies to you, declaring metrics at module level (e.g. `HTTP_REQUESTS = Counter(...)`) is simpler and equally valid.
+Providers are called once at startup and register metrics that are updated externally (e.g. counters, histograms):
 
 ```python
 from prometheus_client import Counter, Histogram
@@ -56,32 +50,15 @@ def request_duration():
     return Histogram("request_duration_seconds", "Request duration")
 ```
 
-To use a provider's metric elsewhere (e.g. in a middleware), call `metrics.get()` inside the handler — **not** at module level, as providers are only initialized when `init_metrics` runs:
-
-```python
-async def metrics_middleware(request: Request, call_next):
-    response = await call_next(request)
-    metrics.get("http_requests").labels(
-        method=request.method, status=response.status_code
-    ).inc()
-    return response
-```
-
 ### Collectors
 
-Collectors are called on every scrape. Use them for metrics that reflect current state (e.g. gauges).
-
-!!! warning "Declare the metric at module level"
-    Do **not** instantiate the Prometheus metric inside the collector function. Doing so recreates it on every scrape, raising `ValueError: Duplicated timeseries in CollectorRegistry`. Declare it once at module level instead:
+Collectors are called on every scrape. Use them for metrics that reflect current state (e.g. gauges):
 
 ```python
-from prometheus_client import Gauge
-
-_queue_depth = Gauge("queue_depth", "Current queue depth")
-
 @metrics.register(collect=True)
-def collect_queue_depth():
-    _queue_depth.set(get_current_queue_depth())
+def queue_depth():
+    gauge = Gauge("queue_depth", "Current queue depth")
+    gauge.set(get_current_queue_depth())
 ```
 
 ## Merging registries

docs/module/models.md

@@ -1,113 +0,0 @@
-# Models
-
-!!! info "Added in `v2.0`"
-
-Reusable SQLAlchemy 2.0 mixins for common column patterns, designed to be composed freely on any `DeclarativeBase` model.
-
-## Overview
-
-The `models` module provides mixins that each add a single, well-defined column behaviour. They work with standard SQLAlchemy 2.0 declarative syntax and are fully compatible with `AsyncSession`.
-
-```python
-from fastapi_toolsets.models import UUIDMixin, TimestampMixin
-
-class Article(Base, UUIDMixin, TimestampMixin):
-    __tablename__ = "articles"
-
-    title: Mapped[str]
-    content: Mapped[str]
-```
-
-All timestamp columns are timezone-aware (`TIMESTAMPTZ`). All defaults are server-side, so they are also applied when inserting rows via raw SQL outside the ORM.
-
-## Mixins
-
-### [`UUIDMixin`](../reference/models.md#fastapi_toolsets.models.UUIDMixin)
-
-Adds a `id: UUID` primary key generated server-side by PostgreSQL using `gen_random_uuid()` (requires PostgreSQL 13+). The value is retrieved via `RETURNING` after insert, so it is available on the Python object immediately after `flush()`.
-
-```python
-from fastapi_toolsets.models import UUIDMixin
-
-class User(Base, UUIDMixin):
-    __tablename__ = "users"
-
-    username: Mapped[str]
-
-# id is None before flush
-user = User(username="alice")
-await session.flush()
-print(user.id)  # UUID('...')
-```
-
-### [`CreatedAtMixin`](../reference/models.md#fastapi_toolsets.models.CreatedAtMixin)
-
-Adds a `created_at: datetime` column set to `NOW()` on insert. The column has no `onupdate` hook — it is intentionally immutable after the row is created.
-
-```python
-from fastapi_toolsets.models import UUIDMixin, CreatedAtMixin
-
-class Order(Base, UUIDMixin, CreatedAtMixin):
-    __tablename__ = "orders"
-
-    total: Mapped[float]
-```
-
-### [`UpdatedAtMixin`](../reference/models.md#fastapi_toolsets.models.UpdatedAtMixin)
-
-Adds an `updated_at: datetime` column set to `NOW()` on insert and automatically updated to `NOW()` on every ORM-level update (via SQLAlchemy's `onupdate` hook).
-
-```python
-from fastapi_toolsets.models import UUIDMixin, UpdatedAtMixin
-
-class Post(Base, UUIDMixin, UpdatedAtMixin):
-    __tablename__ = "posts"
-
-    title: Mapped[str]
-
-post = Post(title="Hello")
-await session.flush()
-await session.refresh(post)
-
-post.title = "Hello World"
-await session.flush()
-await session.refresh(post)
-print(post.updated_at)
-```
-
-!!! note
-    `updated_at` is updated by SQLAlchemy at ORM flush time. If you update rows via raw SQL (e.g. `UPDATE posts SET ...`), the column will **not** be updated automatically — use a database trigger if you need that guarantee.
-
-### [`TimestampMixin`](../reference/models.md#fastapi_toolsets.models.TimestampMixin)
-
-Convenience mixin that combines [`CreatedAtMixin`](../reference/models.md#fastapi_toolsets.models.CreatedAtMixin) and [`UpdatedAtMixin`](../reference/models.md#fastapi_toolsets.models.UpdatedAtMixin). Equivalent to inheriting both.
-
-```python
-from fastapi_toolsets.models import UUIDMixin, TimestampMixin
-
-class Article(Base, UUIDMixin, TimestampMixin):
-    __tablename__ = "articles"
-
-    title: Mapped[str]
-```
-
-## Composing mixins
-
-All mixins can be combined in any order. The only constraint is that exactly one primary key must be defined — either via `UUIDMixin` or directly on the model.
-
-```python
-from fastapi_toolsets.models import UUIDMixin, TimestampMixin
-
-class Event(Base, UUIDMixin, TimestampMixin):
-    __tablename__ = "events"
-    name: Mapped[str]
-
-class Counter(Base, UpdatedAtMixin):
-    __tablename__ = "counters"
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    value: Mapped[int]
-```
-
----
-
-[:material-api: API Reference](../reference/models.md)

docs/module/pytest.md

@@ -40,10 +40,10 @@ async def http_client(db_session):
 
 ## Database sessions in tests
 
-Use [`create_db_session`](../reference/pytest.md#fastapi_toolsets.pytest.utils.create_db_session) to create an isolated `AsyncSession` for a test, combined with [`create_worker_database`](../reference/pytest.md#fastapi_toolsets.pytest.utils.create_worker_database) to set up a per-worker database:
+Use [`create_db_session`](../reference/pytest.md#fastapi_toolsets.pytest.utils.create_db_session) to create an isolated `AsyncSession` for a test:
 
 ```python
-from fastapi_toolsets.pytest import create_worker_database, create_db_session
+from fastapi_toolsets.pytest import create_db_session, create_worker_database
 
 @pytest.fixture(scope="session")
 async def worker_db_url():
@@ -64,28 +64,16 @@ async def db_session(worker_db_url):
 !!! info
     In this example, the database is reset between each test using the argument `cleanup=True`.
 
-Use [`worker_database_url`](../reference/pytest.md#fastapi_toolsets.pytest.utils.worker_database_url) to derive the per-worker URL manually if needed:
-
-```python
-from fastapi_toolsets.pytest import worker_database_url
-
-url = worker_database_url("postgresql+asyncpg://user:pass@localhost/test_db", default_test_db="test")
-# e.g. "postgresql+asyncpg://user:pass@localhost/test_db_gw0" under xdist
-```
-
 ## Parallel testing with pytest-xdist
 
 The examples above are already compatible with parallel test execution with `pytest-xdist`.
 
 ## Cleaning up tables
 
-!!! warning
-    Since `V2.1.0` `cleanup_tables` now live in `fastapi_toolsets.db`. For backward compatibility the function is still available in `fastapi_toolsets.pytest`, but this will be remove in `V3.0.0`.
-
-If you want to manually clean up a database you can use [`cleanup_tables`](../reference/db.md#fastapi_toolsets.db.cleanup_tables), this will truncate all tables between tests for fast isolation:
+If you want to manually clean up a database you can use [`cleanup_tables`](../reference/pytest.md#fastapi_toolsets.pytest.utils.cleanup_tables), this will truncates all tables between tests for fast isolation:
 
 ```python
-from fastapi_toolsets.db import cleanup_tables
+from fastapi_toolsets.pytest import cleanup_tables
 
 @pytest.fixture(autouse=True)
 async def clean(db_session):

docs/reference/db.md

@@ -7,8 +7,6 @@ You can import them directly from `fastapi_toolsets.db`:
 ```python
 from fastapi_toolsets.db import (
     LockMode,
-    cleanup_tables,
-    create_database,
     create_db_dependency,
     create_db_context,
     get_transaction,
@@ -28,7 +26,3 @@ from fastapi_toolsets.db import (
 ## ::: fastapi_toolsets.db.lock_tables
 
 ## ::: fastapi_toolsets.db.wait_for_row_change
-
-## ::: fastapi_toolsets.db.create_database
-
-## ::: fastapi_toolsets.db.cleanup_tables

docs/reference/models.md

@@ -1,22 +0,0 @@
-# `models`
-
-Here's the reference for the SQLAlchemy model mixins provided by the `models` module.
-
-You can import them directly from `fastapi_toolsets.models`:
-
-```python
-from fastapi_toolsets.models import (
-    UUIDMixin,
-    CreatedAtMixin,
-    UpdatedAtMixin,
-    TimestampMixin,
-)
-```
-
-## ::: fastapi_toolsets.models.UUIDMixin
-
-## ::: fastapi_toolsets.models.CreatedAtMixin
-
-## ::: fastapi_toolsets.models.UpdatedAtMixin
-
-## ::: fastapi_toolsets.models.TimestampMixin

docs/reference/pytest.md

@@ -24,3 +24,5 @@ from fastapi_toolsets.pytest import (
 ## ::: fastapi_toolsets.pytest.utils.worker_database_url
 
 ## ::: fastapi_toolsets.pytest.utils.create_worker_database
+
+## ::: fastapi_toolsets.pytest.utils.cleanup_tables

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-toolsets"
-version = "2.2.1"
+version = "1.3.0"
 description = "Production-ready utilities for FastAPI applications"
 readme = "README.md"
 license = "MIT"

src/fastapi_toolsets/__init__.py

@@ -21,4 +21,4 @@ Example usage:
         return Response(data={"user": user.username}, message="Success")
 """
 
-__version__ = "2.2.1"
+__version__ = "1.3.0"

src/fastapi_toolsets/crud/factory.py

@@ -14,6 +14,7 @@ from typing import Any, ClassVar, Generic, Literal, Self, cast, overload
 from fastapi import Query
 from pydantic import BaseModel
 from sqlalchemy import Date, DateTime, Float, Integer, Numeric, Uuid, and_, func, select
+from sqlalchemy import delete as sql_delete
 from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.exc import NoResultFound
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -79,13 +80,13 @@ class AsyncCrud(Generic[ModelType]):
     facet_fields: ClassVar[Sequence[FacetFieldType] | None] = None
     order_fields: ClassVar[Sequence[QueryableAttribute[Any]] | None] = None
     m2m_fields: ClassVar[M2MFieldType | None] = None
-    default_load_options: ClassVar[Sequence[ExecutableOption] | None] = None
+    default_load_options: ClassVar[list[ExecutableOption] | None] = None
     cursor_column: ClassVar[Any | None] = None
 
     @classmethod
     def _resolve_load_options(
-        cls, load_options: Sequence[ExecutableOption] | None
-    ) -> Sequence[ExecutableOption] | None:
+        cls, load_options: list[ExecutableOption] | None
+    ) -> list[ExecutableOption] | None:
         """Return load_options if provided, else fall back to default_load_options."""
         if load_options is not None:
             return load_options
@@ -360,7 +361,7 @@ class AsyncCrud(Generic[ModelType]):
         joins: JoinType | None = None,
         outer_join: bool = False,
         with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
+        load_options: list[ExecutableOption] | None = None,
         schema: type[SchemaType],
     ) -> Response[SchemaType]: ...
 
@@ -374,7 +375,7 @@ class AsyncCrud(Generic[ModelType]):
         joins: JoinType | None = None,
         outer_join: bool = False,
         with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
+        load_options: list[ExecutableOption] | None = None,
         schema: None = ...,
     ) -> ModelType: ...
 
@@ -387,7 +388,7 @@ class AsyncCrud(Generic[ModelType]):
         joins: JoinType | None = None,
         outer_join: bool = False,
         with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
+        load_options: list[ExecutableOption] | None = None,
         schema: type[BaseModel] | None = None,
     ) -> ModelType | Response[Any]:
         """Get exactly one record. Raises NotFoundError if not found.
@@ -409,82 +410,6 @@ class AsyncCrud(Generic[ModelType]):
             NotFoundError: If no record found
             MultipleResultsFound: If more than one record found
         """
-        result = await cls.get_or_none(
-            session,
-            filters,
-            joins=joins,
-            outer_join=outer_join,
-            with_for_update=with_for_update,
-            load_options=load_options,
-            schema=schema,
-        )
-        if result is None:
-            raise NotFoundError()
-        return result
-
-    @overload
-    @classmethod
-    async def get_or_none(  # pragma: no cover
-        cls: type[Self],
-        session: AsyncSession,
-        filters: list[Any],
-        *,
-        joins: JoinType | None = None,
-        outer_join: bool = False,
-        with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
-        schema: type[SchemaType],
-    ) -> Response[SchemaType] | None: ...
-
-    @overload
-    @classmethod
-    async def get_or_none(  # pragma: no cover
-        cls: type[Self],
-        session: AsyncSession,
-        filters: list[Any],
-        *,
-        joins: JoinType | None = None,
-        outer_join: bool = False,
-        with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
-        schema: None = ...,
-    ) -> ModelType | None: ...
-
-    @classmethod
-    async def get_or_none(
-        cls: type[Self],
-        session: AsyncSession,
-        filters: list[Any],
-        *,
-        joins: JoinType | None = None,
-        outer_join: bool = False,
-        with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
-        schema: type[BaseModel] | None = None,
-    ) -> ModelType | Response[Any] | None:
-        """Get exactly one record, or ``None`` if not found.
-
-        Like :meth:`get` but returns ``None`` instead of raising
-        :class:`~fastapi_toolsets.exceptions.NotFoundError` when no record
-        matches the filters.
-
-        Args:
-            session: DB async session
-            filters: List of SQLAlchemy filter conditions
-            joins: List of (model, condition) tuples for joining related tables
-            outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
-            with_for_update: Lock the row for update
-            load_options: SQLAlchemy loader options (e.g., selectinload)
-            schema: Pydantic schema to serialize the result into. When provided,
-                the result is automatically wrapped in a ``Response[schema]``.
-
-        Returns:
-            Model instance, ``Response[schema]`` when ``schema`` is given,
-            or ``None`` when no record matches.
-
-        Raises:
-            MultipleResultsFound: If more than one record found
-        """
         q = select(cls.model)
         q = _apply_joins(q, joins, outer_join)
         q = q.where(and_(*filters))
@@ -494,40 +419,12 @@ class AsyncCrud(Generic[ModelType]):
             q = q.with_for_update()
         result = await session.execute(q)
         item = result.unique().scalar_one_or_none()
-        if item is None:
-            return None
-        db_model = cast(ModelType, item)
+        if not item:
+            raise NotFoundError()
+        result = cast(ModelType, item)
         if schema:
-            return Response(data=schema.model_validate(db_model))
-        return db_model
-
-    @overload
-    @classmethod
-    async def first(  # pragma: no cover
-        cls: type[Self],
-        session: AsyncSession,
-        filters: list[Any] | None = None,
-        *,
-        joins: JoinType | None = None,
-        outer_join: bool = False,
-        with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
-        schema: type[SchemaType],
-    ) -> Response[SchemaType] | None: ...
-
-    @overload
-    @classmethod
-    async def first(  # pragma: no cover
-        cls: type[Self],
-        session: AsyncSession,
-        filters: list[Any] | None = None,
-        *,
-        joins: JoinType | None = None,
-        outer_join: bool = False,
-        with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
-        schema: None = ...,
-    ) -> ModelType | None: ...
+            return Response(data=schema.model_validate(result))
+        return result
 
     @classmethod
     async def first(
@@ -537,10 +434,8 @@ class AsyncCrud(Generic[ModelType]):
         *,
         joins: JoinType | None = None,
         outer_join: bool = False,
-        with_for_update: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
-        schema: type[BaseModel] | None = None,
-    ) -> ModelType | Response[Any] | None:
+        load_options: list[ExecutableOption] | None = None,
+    ) -> ModelType | None:
         """Get the first matching record, or None.
 
         Args:
@@ -548,14 +443,10 @@ class AsyncCrud(Generic[ModelType]):
             filters: List of SQLAlchemy filter conditions
             joins: List of (model, condition) tuples for joining related tables
             outer_join: Use LEFT OUTER JOIN instead of INNER JOIN
-            with_for_update: Lock the row for update
-            load_options: SQLAlchemy loader options (e.g., selectinload)
-            schema: Pydantic schema to serialize the result into. When provided,
-                the result is automatically wrapped in a ``Response[schema]``.
+            load_options: SQLAlchemy loader options
 
         Returns:
-            Model instance, ``Response[schema]`` when ``schema`` is given,
-            or ``None`` when no record matches.
+            Model instance or None
         """
         q = select(cls.model)
         q = _apply_joins(q, joins, outer_join)
@@ -563,16 +454,8 @@ class AsyncCrud(Generic[ModelType]):
             q = q.where(and_(*filters))
         if resolved := cls._resolve_load_options(load_options):
             q = q.options(*resolved)
-        if with_for_update:
-            q = q.with_for_update()
         result = await session.execute(q)
-        item = result.unique().scalars().first()
-        if item is None:
-            return None
-        db_model = cast(ModelType, item)
-        if schema:
-            return Response(data=schema.model_validate(db_model))
-        return db_model
+        return cast(ModelType | None, result.unique().scalars().first())
 
     @classmethod
     async def get_multi(
@@ -582,7 +465,7 @@ class AsyncCrud(Generic[ModelType]):
         filters: list[Any] | None = None,
         joins: JoinType | None = None,
         outer_join: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
+        load_options: list[ExecutableOption] | None = None,
         order_by: OrderByClause | None = None,
         limit: int | None = None,
         offset: int | None = None,
@@ -791,10 +674,8 @@ class AsyncCrud(Generic[ModelType]):
             ``None``, or ``Response[None]`` when ``return_response=True``.
         """
         async with get_transaction(session):
-            result = await session.execute(select(cls.model).where(and_(*filters)))
-            objects = result.scalars().all()
-            for obj in objects:
-                await session.delete(obj)
+            q = sql_delete(cls.model).where(and_(*filters))
+            await session.execute(q)
         if return_response:
             return Response(data=None)
         return None
@@ -860,7 +741,7 @@ class AsyncCrud(Generic[ModelType]):
         filters: list[Any] | None = None,
         joins: JoinType | None = None,
         outer_join: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
+        load_options: list[ExecutableOption] | None = None,
         order_by: OrderByClause | None = None,
         page: int = 1,
         items_per_page: int = 20,
@@ -971,7 +852,7 @@ class AsyncCrud(Generic[ModelType]):
         filters: list[Any] | None = None,
         joins: JoinType | None = None,
         outer_join: bool = False,
-        load_options: Sequence[ExecutableOption] | None = None,
+        load_options: list[ExecutableOption] | None = None,
         order_by: OrderByClause | None = None,
         items_per_page: int = 20,
         search: str | SearchConfig | None = None,
@@ -1112,7 +993,7 @@ def CrudFactory(
     facet_fields: Sequence[FacetFieldType] | None = None,
     order_fields: Sequence[QueryableAttribute[Any]] | None = None,
     m2m_fields: M2MFieldType | None = None,
-    default_load_options: Sequence[ExecutableOption] | None = None,
+    default_load_options: list[ExecutableOption] | None = None,
     cursor_column: Any | None = None,
 ) -> type[AsyncCrud[ModelType]]:
     """Create a CRUD class for a specific model.
@@ -1211,26 +1092,12 @@ def CrudFactory(
         )
         ```
     """
-    pk_key = model.__mapper__.primary_key[0].key
-    assert pk_key is not None
-    pk_col = getattr(model, pk_key)
-
-    if searchable_fields is None:
-        effective_searchable = [pk_col]
-    else:
-        existing_keys = {f.key for f in searchable_fields if not isinstance(f, tuple)}
-        effective_searchable = (
-            [pk_col, *searchable_fields]
-            if pk_key not in existing_keys
-            else list(searchable_fields)
-        )
-
     cls = type(
         f"Async{model.__name__}Crud",
         (AsyncCrud,),
         {
             "model": model,
-            "searchable_fields": effective_searchable,
+            "searchable_fields": searchable_fields,
             "facet_fields": facet_fields,
             "order_fields": order_fields,
             "m2m_fields": m2m_fields,

src/fastapi_toolsets/db.py

@@ -7,19 +7,17 @@ from enum import Enum
 from typing import Any, TypeVar
 
 from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from sqlalchemy.orm import DeclarativeBase
 
 from .exceptions import NotFoundError
 
 __all__ = [
     "LockMode",
-    "cleanup_tables",
-    "create_database",
     "create_db_context",
     "create_db_dependency",
-    "get_transaction",
     "lock_tables",
+    "get_transaction",
     "wait_for_row_change",
 ]
 
@@ -190,71 +188,6 @@ async def lock_tables(
         yield session
 
 
-async def create_database(
-    db_name: str,
-    *,
-    server_url: str,
-) -> None:
-    """Create a database.
-
-    Connects to *server_url* using ``AUTOCOMMIT`` isolation and issues a
-    ``CREATE DATABASE`` statement for *db_name*.
-
-    Args:
-        db_name: Name of the database to create.
-        server_url: URL used for server-level DDL (must point to an existing
-            database on the same server).
-
-    Example:
-        ```python
-        from fastapi_toolsets.db import create_database
-
-        SERVER_URL = "postgresql+asyncpg://postgres:postgres@localhost/postgres"
-        await create_database("myapp_test", server_url=SERVER_URL)
-        ```
-    """
-    engine = create_async_engine(server_url, isolation_level="AUTOCOMMIT")
-    try:
-        async with engine.connect() as conn:
-            await conn.execute(text(f"CREATE DATABASE {db_name}"))
-    finally:
-        await engine.dispose()
-
-
-async def cleanup_tables(
-    session: AsyncSession,
-    base: type[DeclarativeBase],
-) -> None:
-    """Truncate all tables for fast between-test cleanup.
-
-    Executes a single ``TRUNCATE … RESTART IDENTITY CASCADE`` statement
-    across every table in *base*'s metadata, which is significantly faster
-    than dropping and re-creating tables between tests.
-
-    This is a no-op when the metadata contains no tables.
-
-    Args:
-        session: An active async database session.
-        base: SQLAlchemy DeclarativeBase class containing model metadata.
-
-    Example:
-        ```python
-        @pytest.fixture
-        async def db_session(worker_db_url):
-            async with create_db_session(worker_db_url, Base) as session:
-                yield session
-                await cleanup_tables(session, Base)
-        ```
-    """
-    tables = base.metadata.sorted_tables
-    if not tables:
-        return
-
-    table_names = ", ".join(f'"{t.name}"' for t in tables)
-    await session.execute(text(f"TRUNCATE {table_names} RESTART IDENTITY CASCADE"))
-    await session.commit()
-
-
 _M = TypeVar("_M", bound=DeclarativeBase)
 
 

src/fastapi_toolsets/metrics/handler.py

@@ -51,7 +51,7 @@ def init_metrics(
     """
     for provider in registry.get_providers():
         logger.debug("Initialising metric provider '%s'", provider.name)
-        registry._instances[provider.name] = provider.func()
+        provider.func()
 
     # Partition collectors and cache env check at startup — both are stable for the app lifetime.
     async_collectors = [

src/fastapi_toolsets/metrics/registry.py

@@ -19,11 +19,31 @@ class Metric:
 
 
 class MetricsRegistry:
-    """Registry for managing Prometheus metric providers and collectors."""
+    """Registry for managing Prometheus metric providers and collectors.
+
+    Example:
+        ```python
+        from prometheus_client import Counter, Gauge
+        from fastapi_toolsets.metrics import MetricsRegistry
+
+        metrics = MetricsRegistry()
+
+        @metrics.register
+        def http_requests():
+            return Counter("http_requests_total", "Total HTTP requests", ["method", "status"])
+
+        @metrics.register(name="db_pool")
+        def database_pool_size():
+            return Gauge("db_pool_size", "Database connection pool size")
+
+        @metrics.register(collect=True)
+        def collect_queue_depth(gauge=Gauge("queue_depth", "Current queue depth")):
+            gauge.set(get_current_queue_depth())
+        ```
+    """
 
     def __init__(self) -> None:
         self._metrics: dict[str, Metric] = {}
-        self._instances: dict[str, Any] = {}
 
     def register(
         self,
@@ -41,6 +61,17 @@ class MetricsRegistry:
             name: Metric name (defaults to function name).
             collect: If ``True``, the function is called on every scrape.
                 If ``False`` (default), called once at init time.
+
+        Example:
+            ```python
+            @metrics.register
+            def my_counter():
+                return Counter("my_counter", "A counter")
+
+            @metrics.register(collect=True, name="queue")
+            def collect_queue_depth():
+                gauge.set(compute_depth())
+            ```
         """
 
         def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
@@ -56,25 +87,6 @@ class MetricsRegistry:
             return decorator(func)
         return decorator
 
-    def get(self, name: str) -> Any:
-        """Return the metric instance created by a provider.
-
-        Args:
-            name: The metric name (defaults to the provider function name).
-
-        Raises:
-            KeyError: If the metric name is unknown or ``init_metrics`` has not
-                been called yet.
-        """
-        if name not in self._instances:
-            if name in self._metrics:
-                raise KeyError(
-                    f"Metric '{name}' exists but has not been initialized yet. "
-                    "Ensure init_metrics() has been called before accessing metric instances."
-                )
-            raise KeyError(f"Unknown metric '{name}'.")
-        return self._instances[name]
-
     def include_registry(self, registry: "MetricsRegistry") -> None:
         """Include another :class:`MetricsRegistry` into this one.
 
@@ -83,6 +95,18 @@ class MetricsRegistry:
 
         Raises:
             ValueError: If a metric name already exists in the current registry.
+
+        Example:
+            ```python
+            main = MetricsRegistry()
+            sub = MetricsRegistry()
+
+            @sub.register
+            def sub_metric():
+                return Counter("sub_total", "Sub counter")
+
+            main.include_registry(sub)
+            ```
         """
         for metric_name, definition in registry._metrics.items():
             if metric_name in self._metrics:

src/fastapi_toolsets/models.py

@@ -1,47 +0,0 @@
-"""SQLAlchemy model mixins for common column patterns."""
-
-import uuid
-from datetime import datetime
-
-from sqlalchemy import DateTime, Uuid, func, text
-from sqlalchemy.orm import Mapped, mapped_column
-
-__all__ = [
-    "UUIDMixin",
-    "CreatedAtMixin",
-    "UpdatedAtMixin",
-    "TimestampMixin",
-]
-
-
-class UUIDMixin:
-    """Mixin that adds a UUID primary key auto-generated by the database."""
-
-    id: Mapped[uuid.UUID] = mapped_column(
-        Uuid,
-        primary_key=True,
-        server_default=text("gen_random_uuid()"),
-    )
-
-
-class CreatedAtMixin:
-    """Mixin that adds a ``created_at`` timestamp column."""
-
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        server_default=func.now(),
-    )
-
-
-class UpdatedAtMixin:
-    """Mixin that adds an ``updated_at`` timestamp column."""
-
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        server_default=func.now(),
-        onupdate=func.now(),
-    )
-
-
-class TimestampMixin(CreatedAtMixin, UpdatedAtMixin):
-    """Mixin that combines ``created_at`` and ``updated_at`` timestamp columns."""

src/fastapi_toolsets/pytest/utils.py

@@ -1,12 +1,12 @@
 """Pytest helper utilities for FastAPI testing."""
 
 import os
-import warnings
 from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from typing import Any
 
 from httpx import ASGITransport, AsyncClient
+from sqlalchemy import text
 from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import (
     AsyncSession,
@@ -15,134 +15,7 @@ from sqlalchemy.ext.asyncio import (
 )
 from sqlalchemy.orm import DeclarativeBase
 
-from sqlalchemy import text
-
-from ..db import (
-    cleanup_tables as _cleanup_tables,
-    create_database,
-    create_db_context,
-)
-
-
-async def cleanup_tables(
-    session: AsyncSession,
-    base: type[DeclarativeBase],
-) -> None:
-    """Truncate all tables for fast between-test cleanup.
-
-    .. deprecated::
-        Import ``cleanup_tables`` from ``fastapi_toolsets.db`` instead.
-        This re-export will be removed in v3.0.0.
-    """
-    warnings.warn(
-        "Importing cleanup_tables from fastapi_toolsets.pytest is deprecated "
-        "and will be removed in v3.0.0. "
-        "Use 'from fastapi_toolsets.db import cleanup_tables' instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    await _cleanup_tables(session=session, base=base)
-
-
-def _get_xdist_worker(default_test_db: str) -> str:
-    """Return the pytest-xdist worker name, or *default_test_db* when not running under xdist.
-
-    Reads the ``PYTEST_XDIST_WORKER`` environment variable that xdist sets
-    automatically in each worker process (e.g. ``"gw0"``, ``"gw1"``).
-    When xdist is not installed or not active, the variable is absent and
-    *default_test_db* is returned instead.
-
-    Args:
-        default_test_db: Fallback value returned when ``PYTEST_XDIST_WORKER``
-            is not set.
-    """
-    return os.environ.get("PYTEST_XDIST_WORKER", default_test_db)
-
-
-def worker_database_url(database_url: str, default_test_db: str) -> str:
-    """Derive a per-worker database URL for pytest-xdist parallel runs.
-
-    Appends ``_{worker_name}`` to the database name so each xdist worker
-    operates on its own database.  When not running under xdist,
-    ``_{default_test_db}`` is appended instead.
-
-    The worker name is read from the ``PYTEST_XDIST_WORKER`` environment
-    variable (set automatically by xdist in each worker process).
-
-    Args:
-        database_url: Original database connection URL.
-        default_test_db: Suffix appended to the database name when
-            ``PYTEST_XDIST_WORKER`` is not set.
-
-    Returns:
-        A database URL with a worker- or default-specific database name.
-    """
-    worker = _get_xdist_worker(default_test_db=default_test_db)
-
-    url = make_url(database_url)
-    url = url.set(database=f"{url.database}_{worker}")
-    return url.render_as_string(hide_password=False)
-
-
-@asynccontextmanager
-async def create_worker_database(
-    database_url: str,
-    default_test_db: str = "test_db",
-) -> AsyncGenerator[str, None]:
-    """Create and drop a per-worker database for pytest-xdist isolation.
-
-    Derives a worker-specific database URL using :func:`worker_database_url`,
-    then delegates to :func:`~fastapi_toolsets.db.create_database` to create
-    and drop it.  Intended for use as a **session-scoped** fixture.
-
-    When running under xdist the database name is suffixed with the worker
-    name (e.g. ``_gw0``).  Otherwise it is suffixed with *default_test_db*.
-
-    Args:
-        database_url: Original database connection URL (used as the server
-            connection and as the base for the worker database name).
-        default_test_db: Suffix appended to the database name when
-            ``PYTEST_XDIST_WORKER`` is not set. Defaults to ``"test_db"``.
-
-    Yields:
-        The worker-specific database URL.
-
-    Example:
-        ```python
-        from fastapi_toolsets.pytest import create_worker_database, create_db_session
-
-        DATABASE_URL = "postgresql+asyncpg://postgres:postgres@localhost/test_db"
-
-        @pytest.fixture(scope="session")
-        async def worker_db_url():
-            async with create_worker_database(DATABASE_URL) as url:
-                yield url
-
-        @pytest.fixture
-        async def db_session(worker_db_url):
-            async with create_db_session(
-                worker_db_url, Base, cleanup=True
-            ) as session:
-                yield session
-        ```
-    """
-    worker_url = worker_database_url(
-        database_url=database_url, default_test_db=default_test_db
-    )
-    worker_db_name: str = make_url(worker_url).database  # type: ignore[assignment]
-
-    engine = create_async_engine(database_url, isolation_level="AUTOCOMMIT")
-    try:
-        async with engine.connect() as conn:
-            await conn.execute(text(f"DROP DATABASE IF EXISTS {worker_db_name}"))
-        await create_database(db_name=worker_db_name, server_url=database_url)
-
-        yield worker_url
-
-        async with engine.connect() as conn:
-            await conn.execute(text(f"DROP DATABASE IF EXISTS {worker_db_name}"))
-    finally:
-        await engine.dispose()
+from ..db import create_db_context
 
 
 @asynccontextmanager
@@ -283,3 +156,160 @@ async def create_db_session(
                 await conn.run_sync(base.metadata.drop_all)
     finally:
         await engine.dispose()
+
+
+def _get_xdist_worker(default_test_db: str) -> str:
+    """Return the pytest-xdist worker name, or *default_test_db* when not running under xdist.
+
+    Reads the ``PYTEST_XDIST_WORKER`` environment variable that xdist sets
+    automatically in each worker process (e.g. ``"gw0"``, ``"gw1"``).
+    When xdist is not installed or not active, the variable is absent and
+    *default_test_db* is returned instead.
+
+    Args:
+        default_test_db: Fallback value returned when ``PYTEST_XDIST_WORKER``
+            is not set.
+    """
+    return os.environ.get("PYTEST_XDIST_WORKER", default_test_db)
+
+
+def worker_database_url(database_url: str, default_test_db: str) -> str:
+    """Derive a per-worker database URL for pytest-xdist parallel runs.
+
+    Appends ``_{worker_name}`` to the database name so each xdist worker
+    operates on its own database.  When not running under xdist,
+    ``_{default_test_db}`` is appended instead.
+
+    The worker name is read from the ``PYTEST_XDIST_WORKER`` environment
+    variable (set automatically by xdist in each worker process).
+
+    Args:
+        database_url: Original database connection URL.
+        default_test_db: Suffix appended to the database name when
+            ``PYTEST_XDIST_WORKER`` is not set.
+
+    Returns:
+        A database URL with a worker- or default-specific database name.
+
+    Example:
+        ```python
+        # With PYTEST_XDIST_WORKER="gw0":
+        url = worker_database_url(
+            "postgresql+asyncpg://user:pass@localhost/test_db",
+            default_test_db="test",
+        )
+        # "postgresql+asyncpg://user:pass@localhost/test_db_gw0"
+
+        # Without PYTEST_XDIST_WORKER:
+        url = worker_database_url(
+            "postgresql+asyncpg://user:pass@localhost/test_db",
+            default_test_db="test",
+        )
+        # "postgresql+asyncpg://user:pass@localhost/test_db_test"
+        ```
+    """
+    worker = _get_xdist_worker(default_test_db=default_test_db)
+
+    url = make_url(database_url)
+    url = url.set(database=f"{url.database}_{worker}")
+    return url.render_as_string(hide_password=False)
+
+
+@asynccontextmanager
+async def create_worker_database(
+    database_url: str,
+    default_test_db: str = "test_db",
+) -> AsyncGenerator[str, None]:
+    """Create and drop a per-worker database for pytest-xdist isolation.
+
+    Intended for use as a **session-scoped** fixture.  Connects to the server
+    using the original *database_url* (with ``AUTOCOMMIT`` isolation for DDL),
+    creates a dedicated database for the worker, and yields the worker-specific
+    URL.  On cleanup the worker database is dropped.
+
+    When running under xdist the database name is suffixed with the worker
+    name (e.g. ``_gw0``).  Otherwise it is suffixed with *default_test_db*.
+
+    Args:
+        database_url: Original database connection URL.
+        default_test_db: Suffix appended to the database name when
+            ``PYTEST_XDIST_WORKER`` is not set. Defaults to ``"test_db"``.
+
+    Yields:
+        The worker-specific database URL.
+
+    Example:
+        ```python
+        from fastapi_toolsets.pytest import (
+            create_worker_database, create_db_session,
+        )
+
+        DATABASE_URL = "postgresql+asyncpg://postgres:postgres@localhost/test_db"
+
+        @pytest.fixture(scope="session")
+        async def worker_db_url():
+            async with create_worker_database(DATABASE_URL) as url:
+                yield url
+
+        @pytest.fixture
+        async def db_session(worker_db_url):
+            async with create_db_session(
+                worker_db_url, Base, cleanup=True
+            ) as session:
+                yield session
+        ```
+    """
+    worker_url = worker_database_url(
+        database_url=database_url, default_test_db=default_test_db
+    )
+    worker_db_name = make_url(worker_url).database
+
+    engine = create_async_engine(
+        database_url,
+        isolation_level="AUTOCOMMIT",
+    )
+    try:
+        async with engine.connect() as conn:
+            await conn.execute(text(f"DROP DATABASE IF EXISTS {worker_db_name}"))
+            await conn.execute(text(f"CREATE DATABASE {worker_db_name}"))
+
+        yield worker_url
+
+        async with engine.connect() as conn:
+            await conn.execute(text(f"DROP DATABASE IF EXISTS {worker_db_name}"))
+    finally:
+        await engine.dispose()
+
+
+async def cleanup_tables(
+    session: AsyncSession,
+    base: type[DeclarativeBase],
+) -> None:
+    """Truncate all tables for fast between-test cleanup.
+
+    Executes a single ``TRUNCATE … RESTART IDENTITY CASCADE`` statement
+    across every table in *base*'s metadata, which is significantly faster
+    than dropping and re-creating tables between tests.
+
+    This is a no-op when the metadata contains no tables.
+
+    Args:
+        session: An active async database session.
+        base: SQLAlchemy DeclarativeBase class containing model metadata.
+
+    Example:
+        ```python
+        @pytest.fixture
+        async def db_session(worker_db_url):
+            async with create_db_session(worker_db_url, Base) as session:
+                yield session
+                await cleanup_tables(session, Base)
+        ```
+    """
+    tables = base.metadata.sorted_tables
+    if not tables:
+        return
+
+    table_names = ", ".join(f'"{t.name}"' for t in tables)
+    await session.execute(text(f"TRUNCATE {table_names} RESTART IDENTITY CASCADE"))
+    await session.commit()

tests/test_crud.py

@@ -35,7 +35,6 @@ from .conftest import (
     RoleCursorCrud,
     RoleRead,
     RoleUpdate,
-    Tag,
     TagCreate,
     TagCrud,
     User,
@@ -295,100 +294,6 @@ class TestCrudGet:
         assert user.username == "active"
 
 
-class TestCrudGetOrNone:
-    """Tests for CRUD get_or_none operations."""
-
-    @pytest.mark.anyio
-    async def test_returns_record_when_found(self, db_session: AsyncSession):
-        """get_or_none returns the record when it exists."""
-        created = await RoleCrud.create(db_session, RoleCreate(name="admin"))
-        fetched = await RoleCrud.get_or_none(db_session, [Role.id == created.id])
-
-        assert fetched is not None
-        assert fetched.id == created.id
-        assert fetched.name == "admin"
-
-    @pytest.mark.anyio
-    async def test_returns_none_when_not_found(self, db_session: AsyncSession):
-        """get_or_none returns None instead of raising NotFoundError."""
-        result = await RoleCrud.get_or_none(db_session, [Role.id == uuid.uuid4()])
-        assert result is None
-
-    @pytest.mark.anyio
-    async def test_with_schema_returns_response_when_found(
-        self, db_session: AsyncSession
-    ):
-        """get_or_none with schema returns Response[schema] when found."""
-        from fastapi_toolsets.schemas import Response
-
-        created = await RoleCrud.create(db_session, RoleCreate(name="editor"))
-        result = await RoleCrud.get_or_none(
-            db_session, [Role.id == created.id], schema=RoleRead
-        )
-
-        assert isinstance(result, Response)
-        assert isinstance(result.data, RoleRead)
-        assert result.data.name == "editor"
-
-    @pytest.mark.anyio
-    async def test_with_schema_returns_none_when_not_found(
-        self, db_session: AsyncSession
-    ):
-        """get_or_none with schema returns None (not Response) when not found."""
-        result = await RoleCrud.get_or_none(
-            db_session, [Role.id == uuid.uuid4()], schema=RoleRead
-        )
-        assert result is None
-
-    @pytest.mark.anyio
-    async def test_with_load_options(self, db_session: AsyncSession):
-        """get_or_none respects load_options."""
-        from sqlalchemy.orm import selectinload
-
-        role = await RoleCrud.create(db_session, RoleCreate(name="member"))
-        user = await UserCrud.create(
-            db_session,
-            UserCreate(username="alice", email="alice@test.com", role_id=role.id),
-        )
-
-        fetched = await UserCrud.get_or_none(
-            db_session,
-            [User.id == user.id],
-            load_options=[selectinload(User.role)],
-        )
-
-        assert fetched is not None
-        assert fetched.role is not None
-        assert fetched.role.name == "member"
-
-    @pytest.mark.anyio
-    async def test_with_join(self, db_session: AsyncSession):
-        """get_or_none respects joins."""
-        user = await UserCrud.create(
-            db_session, UserCreate(username="author", email="author@test.com")
-        )
-        await PostCrud.create(
-            db_session,
-            PostCreate(title="Published", author_id=user.id, is_published=True),
-        )
-
-        fetched = await UserCrud.get_or_none(
-            db_session,
-            [User.id == user.id, Post.is_published == True],  # noqa: E712
-            joins=[(Post, Post.author_id == User.id)],
-        )
-        assert fetched is not None
-        assert fetched.id == user.id
-
-        # Filter that matches no join — returns None
-        missing = await UserCrud.get_or_none(
-            db_session,
-            [User.id == user.id, Post.is_published == False],  # noqa: E712
-            joins=[(Post, Post.author_id == User.id)],
-        )
-        assert missing is None
-
-
 class TestCrudFirst:
     """Tests for CRUD first operations."""
 
@@ -416,38 +321,6 @@ class TestCrudFirst:
         role = await RoleCrud.first(db_session)
         assert role is not None
 
-    @pytest.mark.anyio
-    async def test_first_with_schema(self, db_session: AsyncSession):
-        """First with schema returns a Response wrapping the serialized record."""
-        await RoleCrud.create(db_session, RoleCreate(name="admin"))
-
-        result = await RoleCrud.first(
-            db_session, [Role.name == "admin"], schema=RoleRead
-        )
-
-        assert result is not None
-        assert result.data is not None
-        assert result.data.name == "admin"
-
-    @pytest.mark.anyio
-    async def test_first_with_schema_not_found(self, db_session: AsyncSession):
-        """First with schema returns None when no record matches."""
-        result = await RoleCrud.first(
-            db_session, [Role.name == "ghost"], schema=RoleRead
-        )
-        assert result is None
-
-    @pytest.mark.anyio
-    async def test_first_with_for_update(self, db_session: AsyncSession):
-        """First with with_for_update locks the row."""
-        await RoleCrud.create(db_session, RoleCreate(name="admin"))
-
-        role = await RoleCrud.first(
-            db_session, [Role.name == "admin"], with_for_update=True
-        )
-        assert role is not None
-        assert role.name == "admin"
-
 
 class TestCrudGetMulti:
     """Tests for CRUD get_multi operations."""
@@ -607,69 +480,6 @@ class TestCrudDelete:
         assert result.data is None
         assert await RoleCrud.first(db_session, [Role.id == role.id]) is None
 
-    @pytest.mark.anyio
-    async def test_delete_m2m_cascade(self, db_session: AsyncSession):
-        """Deleting a record with M2M relationships cleans up the association table."""
-        from sqlalchemy import text
-
-        user = await UserCrud.create(
-            db_session, UserCreate(username="author", email="author@test.com")
-        )
-        tag1 = await TagCrud.create(db_session, TagCreate(name="python"))
-        tag2 = await TagCrud.create(db_session, TagCreate(name="fastapi"))
-
-        post = await PostM2MCrud.create(
-            db_session,
-            PostM2MCreate(
-                title="M2M Delete Test",
-                author_id=user.id,
-                tag_ids=[tag1.id, tag2.id],
-            ),
-        )
-
-        await PostM2MCrud.delete(db_session, [Post.id == post.id])
-
-        # Post is gone
-        assert await PostCrud.first(db_session, [Post.id == post.id]) is None
-
-        # Association rows are gone — tags themselves must still exist
-        assert await TagCrud.first(db_session, [Tag.id == tag1.id]) is not None
-        assert await TagCrud.first(db_session, [Tag.id == tag2.id]) is not None
-
-        # No orphaned rows in post_tags
-        result = await db_session.execute(
-            text("SELECT COUNT(*) FROM post_tags WHERE post_id = :pid").bindparams(
-                pid=post.id
-            )
-        )
-        assert result.scalar() == 0
-
-    @pytest.mark.anyio
-    async def test_delete_m2m_does_not_delete_related_records(
-        self, db_session: AsyncSession
-    ):
-        """Deleting a post with M2M tags must not delete the tags themselves."""
-        user = await UserCrud.create(
-            db_session, UserCreate(username="author2", email="author2@test.com")
-        )
-        tag = await TagCrud.create(db_session, TagCreate(name="shared_tag"))
-
-        post1 = await PostM2MCrud.create(
-            db_session,
-            PostM2MCreate(title="Post 1", author_id=user.id, tag_ids=[tag.id]),
-        )
-        post2 = await PostM2MCrud.create(
-            db_session,
-            PostM2MCreate(title="Post 2", author_id=user.id, tag_ids=[tag.id]),
-        )
-
-        # Delete only post1
-        await PostM2MCrud.delete(db_session, [Post.id == post1.id])
-
-        # Tag and post2 still exist
-        assert await TagCrud.first(db_session, [Tag.id == tag.id]) is not None
-        assert await PostCrud.first(db_session, [Post.id == post2.id]) is not None
-
 
 class TestCrudExists:
     """Tests for CRUD exists operations."""

tests/test_crud_search.py

@@ -211,17 +211,14 @@ class TestPaginateSearch:
         assert result.data[0].username == "active_john"
 
     @pytest.mark.anyio
-    async def test_search_explicit_fields(self, db_session: AsyncSession):
-        """Search works when search_fields are passed per call."""
+    async def test_search_auto_detect_fields(self, db_session: AsyncSession):
+        """Auto-detect searchable fields when not specified."""
         await UserCrud.create(
             db_session, UserCreate(username="findme", email="other@test.com")
         )
 
         result = await UserCrud.offset_paginate(
-            db_session,
-            search="findme",
-            search_fields=[User.username],
-            schema=UserRead,
+            db_session, search="findme", schema=UserRead
         )
 
         assert isinstance(result.pagination, OffsetPagination)

tests/test_db.py

@@ -4,15 +4,10 @@ import asyncio
 import uuid
 
 import pytest
-from sqlalchemy import text
-from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase
 
 from fastapi_toolsets.db import (
     LockMode,
-    cleanup_tables,
-    create_database,
     create_db_context,
     create_db_dependency,
     get_transaction,
@@ -20,9 +15,8 @@ from fastapi_toolsets.db import (
     wait_for_row_change,
 )
 from fastapi_toolsets.exceptions import NotFoundError
-from fastapi_toolsets.pytest import create_db_session
 
-from .conftest import DATABASE_URL, Base, Role, RoleCrud, User, UserCrud
+from .conftest import DATABASE_URL, Base, Role, RoleCrud, User
 
 
 class TestCreateDbDependency:
@@ -350,83 +344,3 @@ class TestWaitForRowChange:
         with pytest.raises(NotFoundError):
             await wait_for_row_change(db_session, Role, role.id, interval=0.05)
         await delete_task
-
-
-class TestCreateDatabase:
-    """Tests for create_database."""
-
-    @pytest.mark.anyio
-    async def test_creates_database(self):
-        """Database is created by create_database."""
-        target_url = (
-            make_url(DATABASE_URL)
-            .set(database="test_create_db_general")
-            .render_as_string(hide_password=False)
-        )
-        expected_db: str = make_url(target_url).database  # type: ignore[assignment]
-
-        engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
-        try:
-            async with engine.connect() as conn:
-                await conn.execute(text(f"DROP DATABASE IF EXISTS {expected_db}"))
-
-            await create_database(db_name=expected_db, server_url=DATABASE_URL)
-
-            async with engine.connect() as conn:
-                result = await conn.execute(
-                    text("SELECT 1 FROM pg_database WHERE datname = :name"),
-                    {"name": expected_db},
-                )
-                assert result.scalar() == 1
-
-            # Cleanup
-            async with engine.connect() as conn:
-                await conn.execute(text(f"DROP DATABASE IF EXISTS {expected_db}"))
-        finally:
-            await engine.dispose()
-
-
-class TestCleanupTables:
-    """Tests for cleanup_tables helper."""
-
-    @pytest.mark.anyio
-    async def test_truncates_all_tables(self):
-        """All table rows are removed after cleanup_tables."""
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
-            role = Role(id=uuid.uuid4(), name="cleanup_role")
-            session.add(role)
-            await session.flush()
-
-            user = User(
-                id=uuid.uuid4(),
-                username="cleanup_user",
-                email="cleanup@test.com",
-                role_id=role.id,
-            )
-            session.add(user)
-            await session.commit()
-
-            # Verify rows exist
-            roles_count = await RoleCrud.count(session)
-            users_count = await UserCrud.count(session)
-            assert roles_count == 1
-            assert users_count == 1
-
-            await cleanup_tables(session, Base)
-
-            # Verify tables are empty
-            roles_count = await RoleCrud.count(session)
-            users_count = await UserCrud.count(session)
-            assert roles_count == 0
-            assert users_count == 0
-
-    @pytest.mark.anyio
-    async def test_noop_for_empty_metadata(self):
-        """cleanup_tables does not raise when metadata has no tables."""
-
-        class EmptyBase(DeclarativeBase):
-            pass
-
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
-            # Should not raise
-            await cleanup_tables(session, EmptyBase)

tests/test_metrics.py

@@ -159,42 +159,6 @@ class TestMetricsRegistry:
         assert registry.get_all()[0].func is second
 
 
-class TestGet:
-    """Tests for MetricsRegistry.get method."""
-
-    def test_get_returns_instance_after_init(self):
-        """get() returns the metric instance stored by init_metrics."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-
-        @registry.register
-        def my_gauge():
-            return Gauge("get_test_gauge", "A test gauge")
-
-        init_metrics(app, registry)
-
-        instance = registry.get("my_gauge")
-        assert isinstance(instance, Gauge)
-
-    def test_get_raises_for_registered_but_not_initialized(self):
-        """get() raises KeyError with an informative message when init_metrics was not called."""
-        registry = MetricsRegistry()
-
-        @registry.register
-        def my_counter():
-            return Counter("get_uninit_counter", "A counter")
-
-        with pytest.raises(KeyError, match="not been initialized yet"):
-            registry.get("my_counter")
-
-    def test_get_raises_for_unknown_name(self):
-        """get() raises KeyError when the metric name is not registered at all."""
-        registry = MetricsRegistry()
-
-        with pytest.raises(KeyError, match="Unknown metric"):
-            registry.get("nonexistent")
-
-
 class TestIncludeRegistry:
     """Tests for MetricsRegistry.include_registry method."""
 

tests/test_models.py

@@ -1,247 +0,0 @@
-"""Tests for fastapi_toolsets.models mixins."""
-
-import uuid
-
-import pytest
-from sqlalchemy import String
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-
-from fastapi_toolsets.models import (
-    CreatedAtMixin,
-    TimestampMixin,
-    UUIDMixin,
-    UpdatedAtMixin,
-)
-
-from .conftest import DATABASE_URL
-
-
-class MixinBase(DeclarativeBase):
-    pass
-
-
-class UUIDModel(MixinBase, UUIDMixin):
-    __tablename__ = "mixin_uuid_models"
-
-    name: Mapped[str] = mapped_column(String(50))
-
-
-class UpdatedAtModel(MixinBase, UpdatedAtMixin):
-    __tablename__ = "mixin_updated_at_models"
-
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    name: Mapped[str] = mapped_column(String(50))
-
-
-class CreatedAtModel(MixinBase, CreatedAtMixin):
-    __tablename__ = "mixin_created_at_models"
-
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    name: Mapped[str] = mapped_column(String(50))
-
-
-class TimestampModel(MixinBase, TimestampMixin):
-    __tablename__ = "mixin_timestamp_models"
-
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    name: Mapped[str] = mapped_column(String(50))
-
-
-class FullMixinModel(MixinBase, UUIDMixin, UpdatedAtMixin):
-    __tablename__ = "mixin_full_models"
-
-    name: Mapped[str] = mapped_column(String(50))
-
-
-@pytest.fixture(scope="function")
-async def mixin_session():
-    engine = create_async_engine(DATABASE_URL, echo=False)
-    async with engine.begin() as conn:
-        await conn.run_sync(MixinBase.metadata.create_all)
-
-    session_factory = async_sessionmaker(engine, expire_on_commit=False)
-    session = session_factory()
-
-    try:
-        yield session
-    finally:
-        await session.close()
-        async with engine.begin() as conn:
-            await conn.run_sync(MixinBase.metadata.drop_all)
-        await engine.dispose()
-
-
-class TestUUIDMixin:
-    @pytest.mark.anyio
-    async def test_uuid_generated_by_db(self, mixin_session):
-        """UUID is generated server-side and populated after flush."""
-        obj = UUIDModel(name="test")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-
-        assert obj.id is not None
-        assert isinstance(obj.id, uuid.UUID)
-
-    @pytest.mark.anyio
-    async def test_uuid_is_primary_key(self):
-        """UUIDMixin adds id as primary key column."""
-        pk_cols = [c.name for c in UUIDModel.__table__.primary_key]
-        assert pk_cols == ["id"]
-
-    @pytest.mark.anyio
-    async def test_each_row_gets_unique_uuid(self, mixin_session):
-        """Each inserted row gets a distinct UUID."""
-        a = UUIDModel(name="a")
-        b = UUIDModel(name="b")
-        mixin_session.add_all([a, b])
-        await mixin_session.flush()
-
-        assert a.id != b.id
-
-    @pytest.mark.anyio
-    async def test_uuid_server_default_set(self):
-        """Column has gen_random_uuid() as server default."""
-        col = UUIDModel.__table__.c["id"]
-        assert col.server_default is not None
-        assert "gen_random_uuid" in str(col.server_default.arg)
-
-
-class TestUpdatedAtMixin:
-    @pytest.mark.anyio
-    async def test_updated_at_set_on_insert(self, mixin_session):
-        """updated_at is populated after insert."""
-        obj = UpdatedAtModel(name="initial")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert obj.updated_at is not None
-        assert obj.updated_at.tzinfo is not None  # timezone-aware
-
-    @pytest.mark.anyio
-    async def test_updated_at_changes_on_update(self, mixin_session):
-        """updated_at is updated when the row is modified."""
-        obj = UpdatedAtModel(name="initial")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        original_ts = obj.updated_at
-
-        obj.name = "modified"
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert obj.updated_at >= original_ts
-
-    @pytest.mark.anyio
-    async def test_updated_at_column_is_not_nullable(self):
-        """updated_at column is non-nullable."""
-        col = UpdatedAtModel.__table__.c["updated_at"]
-        assert not col.nullable
-
-    @pytest.mark.anyio
-    async def test_updated_at_has_server_default(self):
-        """updated_at column has a server-side default."""
-        col = UpdatedAtModel.__table__.c["updated_at"]
-        assert col.server_default is not None
-
-    @pytest.mark.anyio
-    async def test_updated_at_has_onupdate(self):
-        """updated_at column has an onupdate clause."""
-        col = UpdatedAtModel.__table__.c["updated_at"]
-        assert col.onupdate is not None
-
-
-class TestCreatedAtMixin:
-    @pytest.mark.anyio
-    async def test_created_at_set_on_insert(self, mixin_session):
-        """created_at is populated after insert."""
-        obj = CreatedAtModel(name="new")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert obj.created_at is not None
-        assert obj.created_at.tzinfo is not None  # timezone-aware
-
-    @pytest.mark.anyio
-    async def test_created_at_not_changed_on_update(self, mixin_session):
-        """created_at is not modified when the row is updated."""
-        obj = CreatedAtModel(name="original")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        original_ts = obj.created_at
-
-        obj.name = "updated"
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert obj.created_at == original_ts
-
-    @pytest.mark.anyio
-    async def test_created_at_column_is_not_nullable(self):
-        """created_at column is non-nullable."""
-        col = CreatedAtModel.__table__.c["created_at"]
-        assert not col.nullable
-
-    @pytest.mark.anyio
-    async def test_created_at_has_no_onupdate(self):
-        """created_at column has no onupdate clause."""
-        col = CreatedAtModel.__table__.c["created_at"]
-        assert col.onupdate is None
-
-
-class TestTimestampMixin:
-    @pytest.mark.anyio
-    async def test_both_columns_set_on_insert(self, mixin_session):
-        """created_at and updated_at are both populated after insert."""
-        obj = TimestampModel(name="new")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert obj.created_at is not None
-        assert obj.updated_at is not None
-
-    @pytest.mark.anyio
-    async def test_created_at_stable_updated_at_changes_on_update(self, mixin_session):
-        """On update: created_at stays the same, updated_at advances."""
-        obj = TimestampModel(name="original")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        original_created = obj.created_at
-        original_updated = obj.updated_at
-
-        obj.name = "modified"
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert obj.created_at == original_created
-        assert obj.updated_at >= original_updated
-
-    @pytest.mark.anyio
-    async def test_timestamp_mixin_has_both_columns(self):
-        """TimestampModel exposes both created_at and updated_at columns."""
-        col_names = {c.name for c in TimestampModel.__table__.columns}
-        assert "created_at" in col_names
-        assert "updated_at" in col_names
-
-
-class TestFullMixinModel:
-    @pytest.mark.anyio
-    async def test_combined_mixins_work_together(self, mixin_session):
-        """UUIDMixin and UpdatedAtMixin can be combined on the same model."""
-        obj = FullMixinModel(name="combined")
-        mixin_session.add(obj)
-        await mixin_session.flush()
-        await mixin_session.refresh(obj)
-
-        assert isinstance(obj.id, uuid.UUID)
-        assert obj.updated_at is not None
-        assert obj.updated_at.tzinfo is not None

tests/test_pytest.py

@@ -8,10 +8,11 @@ from httpx import AsyncClient
 from sqlalchemy import select, text
 from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import selectinload
+from sqlalchemy.orm import DeclarativeBase, selectinload
 
 from fastapi_toolsets.fixtures import Context, FixtureRegistry
 from fastapi_toolsets.pytest import (
+    cleanup_tables,
     create_async_client,
     create_db_session,
     create_worker_database,
@@ -405,6 +406,7 @@ class TestCreateWorkerDatabase:
         ) as url:
             assert make_url(url).database == expected_db
 
+            # Verify the database exists while inside the context
             engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
             async with engine.connect() as conn:
                 result = await conn.execute(
@@ -414,6 +416,7 @@ class TestCreateWorkerDatabase:
                 assert result.scalar() == 1
             await engine.dispose()
 
+        # After context exit the database should be dropped
         engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
         async with engine.connect() as conn:
             result = await conn.execute(
@@ -436,6 +439,7 @@ class TestCreateWorkerDatabase:
         async with create_worker_database(DATABASE_URL) as url:
             assert make_url(url).database == expected_db
 
+            # Verify the database exists while inside the context
             engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
             async with engine.connect() as conn:
                 result = await conn.execute(
@@ -445,6 +449,7 @@ class TestCreateWorkerDatabase:
                 assert result.scalar() == 1
             await engine.dispose()
 
+        # After context exit the database should be dropped
         engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
         async with engine.connect() as conn:
             result = await conn.execute(
@@ -462,15 +467,18 @@ class TestCreateWorkerDatabase:
             worker_database_url(DATABASE_URL, default_test_db="unused")
         ).database
 
+        # Pre-create the database to simulate a stale leftover
         engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
         async with engine.connect() as conn:
             await conn.execute(text(f"DROP DATABASE IF EXISTS {expected_db}"))
             await conn.execute(text(f"CREATE DATABASE {expected_db}"))
         await engine.dispose()
 
+        # Should succeed despite the database already existing
         async with create_worker_database(DATABASE_URL) as url:
             assert make_url(url).database == expected_db
 
+        # Verify cleanup after context exit
         engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
         async with engine.connect() as conn:
             result = await conn.execute(
@@ -479,3 +487,49 @@ class TestCreateWorkerDatabase:
             )
             assert result.scalar() is None
         await engine.dispose()
+
+
+class TestCleanupTables:
+    """Tests for cleanup_tables helper."""
+
+    @pytest.mark.anyio
+    async def test_truncates_all_tables(self):
+        """All table rows are removed after cleanup_tables."""
+        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
+            role = Role(id=uuid.uuid4(), name="cleanup_role")
+            session.add(role)
+            await session.flush()
+
+            user = User(
+                id=uuid.uuid4(),
+                username="cleanup_user",
+                email="cleanup@test.com",
+                role_id=role.id,
+            )
+            session.add(user)
+            await session.commit()
+
+            # Verify rows exist
+            roles_count = await RoleCrud.count(session)
+            users_count = await UserCrud.count(session)
+            assert roles_count == 1
+            assert users_count == 1
+
+            await cleanup_tables(session, Base)
+
+            # Verify tables are empty
+            roles_count = await RoleCrud.count(session)
+            users_count = await UserCrud.count(session)
+            assert roles_count == 0
+            assert users_count == 0
+
+    @pytest.mark.anyio
+    async def test_noop_for_empty_metadata(self):
+        """cleanup_tables does not raise when metadata has no tables."""
+
+        class EmptyBase(DeclarativeBase):
+            pass
+
+        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
+            # Should not raise
+            await cleanup_tables(session, EmptyBase)

uv.lock

@@ -235,7 +235,7 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.135.1"
+version = "0.133.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-doc" },
@@ -244,14 +244,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/7b/f8e0211e9380f7195ba3f3d40c292594fd81ba8ec4629e3854c353aaca45/fastapi-0.135.1.tar.gz", hash = "sha256:d04115b508d936d254cea545b7312ecaa58a7b3a0f84952535b4c9afae7668cd", size = 394962, upload-time = "2026-03-01T18:18:29.369Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/6f/0eafed8349eea1fa462238b54a624c8b408cd1ba2795c8e64aa6c34f8ab7/fastapi-0.133.1.tar.gz", hash = "sha256:ed152a45912f102592976fde6cbce7dae1a8a1053da94202e51dd35d184fadd6", size = 378741, upload-time = "2026-02-25T18:18:17.398Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/72/42e900510195b23a56bde950d26a51f8b723846bfcaa0286e90287f0422b/fastapi-0.135.1-py3-none-any.whl", hash = "sha256:46e2fc5745924b7c840f71ddd277382af29ce1cdb7d5eab5bf697e3fb9999c9e", size = 116999, upload-time = "2026-03-01T18:18:30.831Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/c9/a175a7779f3599dfa4adfc97a6ce0e157237b3d7941538604aadaf97bfb6/fastapi-0.133.1-py3-none-any.whl", hash = "sha256:658f34ba334605b1617a65adf2ea6461901bdb9af3a3080d63ff791ecf7dc2e2", size = 109029, upload-time = "2026-02-25T18:18:18.578Z" },
 ]
 
 [[package]]
 name = "fastapi-toolsets"
-version = "2.2.1"
+version = "1.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "asyncpg" },
@@ -1013,27 +1013,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.15.5"
+version = "0.15.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/77/9b/840e0039e65fcf12758adf684d2289024d6140cde9268cc59887dc55189c/ruff-0.15.5.tar.gz", hash = "sha256:7c3601d3b6d76dce18c5c824fc8d06f4eef33d6df0c21ec7799510cde0f159a2", size = 4574214, upload-time = "2026-03-05T20:06:34.946Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/04/eab13a954e763b0606f460443fcbf6bb5a0faf06890ea3754ff16523dce5/ruff-0.15.2.tar.gz", hash = "sha256:14b965afee0969e68bb871eba625343b8673375f457af4abe98553e8bbb98342", size = 4558148, upload-time = "2026-02-19T22:32:20.271Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/20/5369c3ce21588c708bcbe517a8fbe1a8dfdb5dfd5137e14790b1da71612c/ruff-0.15.5-py3-none-linux_armv6l.whl", hash = "sha256:4ae44c42281f42e3b06b988e442d344a5b9b72450ff3c892e30d11b29a96a57c", size = 10478185, upload-time = "2026-03-05T20:06:29.093Z" },
-    { url = "https://files.pythonhosted.org/packages/44/ed/e81dd668547da281e5dce710cf0bc60193f8d3d43833e8241d006720e42b/ruff-0.15.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6edd3792d408ebcf61adabc01822da687579a1a023f297618ac27a5b51ef0080", size = 10859201, upload-time = "2026-03-05T20:06:32.632Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/8f/533075f00aaf19b07c5cd6aa6e5d89424b06b3b3f4583bfa9c640a079059/ruff-0.15.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:89f463f7c8205a9f8dea9d658d59eff49db05f88f89cc3047fb1a02d9f344010", size = 10184752, upload-time = "2026-03-05T20:06:40.312Z" },
-    { url = "https://files.pythonhosted.org/packages/66/0e/ba49e2c3fa0395b3152bad634c7432f7edfc509c133b8f4529053ff024fb/ruff-0.15.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba786a8295c6574c1116704cf0b9e6563de3432ac888d8f83685654fe528fd65", size = 10534857, upload-time = "2026-03-05T20:06:19.581Z" },
-    { url = "https://files.pythonhosted.org/packages/59/71/39234440f27a226475a0659561adb0d784b4d247dfe7f43ffc12dd02e288/ruff-0.15.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd4b801e57955fe9f02b31d20375ab3a5c4415f2e5105b79fb94cf2642c91440", size = 10309120, upload-time = "2026-03-05T20:06:00.435Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/87/4140aa86a93df032156982b726f4952aaec4a883bb98cb6ef73c347da253/ruff-0.15.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:391f7c73388f3d8c11b794dbbc2959a5b5afe66642c142a6effa90b45f6f5204", size = 11047428, upload-time = "2026-03-05T20:05:51.867Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/f7/4953e7e3287676f78fbe85e3a0ca414c5ca81237b7575bdadc00229ac240/ruff-0.15.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8dc18f30302e379fe1e998548b0f5e9f4dff907f52f73ad6da419ea9c19d66c8", size = 11914251, upload-time = "2026-03-05T20:06:22.887Z" },
-    { url = "https://files.pythonhosted.org/packages/77/46/0f7c865c10cf896ccf5a939c3e84e1cfaeed608ff5249584799a74d33835/ruff-0.15.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1cc6e7f90087e2d27f98dc34ed1b3ab7c8f0d273cc5431415454e22c0bd2a681", size = 11333801, upload-time = "2026-03-05T20:05:57.168Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/01/a10fe54b653061585e655f5286c2662ebddb68831ed3eaebfb0eb08c0a16/ruff-0.15.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1cb7169f53c1ddb06e71a9aebd7e98fc0fea936b39afb36d8e86d36ecc2636a", size = 11206821, upload-time = "2026-03-05T20:06:03.441Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/0d/2132ceaf20c5e8699aa83da2706ecb5c5dcdf78b453f77edca7fb70f8a93/ruff-0.15.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9b037924500a31ee17389b5c8c4d88874cc6ea8e42f12e9c61a3d754ff72f1ca", size = 11133326, upload-time = "2026-03-05T20:06:25.655Z" },
-    { url = "https://files.pythonhosted.org/packages/72/cb/2e5259a7eb2a0f87c08c0fe5bf5825a1e4b90883a52685524596bfc93072/ruff-0.15.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:65bb414e5b4eadd95a8c1e4804f6772bbe8995889f203a01f77ddf2d790929dd", size = 10510820, upload-time = "2026-03-05T20:06:37.79Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/20/b67ce78f9e6c59ffbdb5b4503d0090e749b5f2d31b599b554698a80d861c/ruff-0.15.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d20aa469ae3b57033519c559e9bc9cd9e782842e39be05b50e852c7c981fa01d", size = 10302395, upload-time = "2026-03-05T20:05:54.504Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/e5/719f1acccd31b720d477751558ed74e9c88134adcc377e5e886af89d3072/ruff-0.15.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:15388dd28c9161cdb8eda68993533acc870aa4e646a0a277aa166de9ad5a8752", size = 10754069, upload-time = "2026-03-05T20:06:06.422Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/9c/d1db14469e32d98f3ca27079dbd30b7b44dbb5317d06ab36718dee3baf03/ruff-0.15.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b30da330cbd03bed0c21420b6b953158f60c74c54c5f4c1dabbdf3a57bf355d2", size = 11304315, upload-time = "2026-03-05T20:06:10.867Z" },
-    { url = "https://files.pythonhosted.org/packages/28/3a/950367aee7c69027f4f422059227b290ed780366b6aecee5de5039d50fa8/ruff-0.15.5-py3-none-win32.whl", hash = "sha256:732e5ee1f98ba5b3679029989a06ca39a950cced52143a0ea82a2102cb592b74", size = 10551676, upload-time = "2026-03-05T20:06:13.705Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/00/bf077a505b4e649bdd3c47ff8ec967735ce2544c8e4a43aba42ee9bf935d/ruff-0.15.5-py3-none-win_amd64.whl", hash = "sha256:821d41c5fa9e19117616c35eaa3f4b75046ec76c65e7ae20a333e9a8696bc7fe", size = 11678972, upload-time = "2026-03-05T20:06:45.379Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/4e/cd76eca6db6115604b7626668e891c9dd03330384082e33662fb0f113614/ruff-0.15.5-py3-none-win_arm64.whl", hash = "sha256:b498d1c60d2fe5c10c45ec3f698901065772730b411f164ae270bb6bfcc4740b", size = 10965572, upload-time = "2026-03-05T20:06:16.984Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/70/3a4dc6d09b13cb3e695f28307e5d889b2e1a66b7af9c5e257e796695b0e6/ruff-0.15.2-py3-none-linux_armv6l.whl", hash = "sha256:120691a6fdae2f16d65435648160f5b81a9625288f75544dc40637436b5d3c0d", size = 10430565, upload-time = "2026-02-19T22:32:41.824Z" },
+    { url = "https://files.pythonhosted.org/packages/71/0b/bb8457b56185ece1305c666dc895832946d24055be90692381c31d57466d/ruff-0.15.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a89056d831256099658b6bba4037ac6dd06f49d194199215befe2bb10457ea5e", size = 10820354, upload-time = "2026-02-19T22:32:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c1/e0532d7f9c9e0b14c46f61b14afd563298b8b83f337b6789ddd987e46121/ruff-0.15.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e36dee3a64be0ebd23c86ffa3aa3fd3ac9a712ff295e192243f814a830b6bd87", size = 10170767, upload-time = "2026-02-19T22:32:13.188Z" },
+    { url = "https://files.pythonhosted.org/packages/47/e8/da1aa341d3af017a21c7a62fb5ec31d4e7ad0a93ab80e3a508316efbcb23/ruff-0.15.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9fb47b6d9764677f8c0a193c0943ce9a05d6763523f132325af8a858eadc2b9", size = 10529591, upload-time = "2026-02-19T22:32:02.547Z" },
+    { url = "https://files.pythonhosted.org/packages/93/74/184fbf38e9f3510231fbc5e437e808f0b48c42d1df9434b208821efcd8d6/ruff-0.15.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f376990f9d0d6442ea9014b19621d8f2aaf2b8e39fdbfc79220b7f0c596c9b80", size = 10260771, upload-time = "2026-02-19T22:32:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ac/605c20b8e059a0bc4b42360414baa4892ff278cec1c91fff4be0dceedefd/ruff-0.15.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2dcc987551952d73cbf5c88d9fdee815618d497e4df86cd4c4824cc59d5dd75f", size = 11045791, upload-time = "2026-02-19T22:32:31.642Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/52/db6e419908f45a894924d410ac77d64bdd98ff86901d833364251bd08e22/ruff-0.15.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42a47fd785cbe8c01b9ff45031af875d101b040ad8f4de7bbb716487c74c9a77", size = 11879271, upload-time = "2026-02-19T22:32:29.305Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d8/7992b18f2008bdc9231d0f10b16df7dda964dbf639e2b8b4c1b4e91b83af/ruff-0.15.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cbe9f49354866e575b4c6943856989f966421870e85cd2ac94dccb0a9dcb2fea", size = 11303707, upload-time = "2026-02-19T22:32:22.492Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/02/849b46184bcfdd4b64cde61752cc9a146c54759ed036edd11857e9b8443b/ruff-0.15.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7a672c82b5f9887576087d97be5ce439f04bbaf548ee987b92d3a7dede41d3a", size = 11149151, upload-time = "2026-02-19T22:32:44.234Z" },
+    { url = "https://files.pythonhosted.org/packages/70/04/f5284e388bab60d1d3b99614a5a9aeb03e0f333847e2429bebd2aaa1feec/ruff-0.15.2-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:72ecc64f46f7019e2bcc3cdc05d4a7da958b629a5ab7033195e11a438403d956", size = 11091132, upload-time = "2026-02-19T22:32:24.691Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ae/88d844a21110e14d92cf73d57363fab59b727ebeabe78009b9ccb23500af/ruff-0.15.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:8dcf243b15b561c655c1ef2f2b0050e5d50db37fe90115507f6ff37d865dc8b4", size = 10504717, upload-time = "2026-02-19T22:32:26.75Z" },
+    { url = "https://files.pythonhosted.org/packages/64/27/867076a6ada7f2b9c8292884ab44d08fd2ba71bd2b5364d4136f3cd537e1/ruff-0.15.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:dab6941c862c05739774677c6273166d2510d254dac0695c0e3f5efa1b5585de", size = 10263122, upload-time = "2026-02-19T22:32:10.036Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/ef/faf9321d550f8ebf0c6373696e70d1758e20ccdc3951ad7af00c0956be7c/ruff-0.15.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1b9164f57fc36058e9a6806eb92af185b0697c9fe4c7c52caa431c6554521e5c", size = 10735295, upload-time = "2026-02-19T22:32:39.227Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/55/e8089fec62e050ba84d71b70e7834b97709ca9b7aba10c1a0b196e493f97/ruff-0.15.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:80d24fcae24d42659db7e335b9e1531697a7102c19185b8dc4a028b952865fd8", size = 11241641, upload-time = "2026-02-19T22:32:34.617Z" },
+    { url = "https://files.pythonhosted.org/packages/23/01/1c30526460f4d23222d0fabd5888868262fd0e2b71a00570ca26483cd993/ruff-0.15.2-py3-none-win32.whl", hash = "sha256:fd5ff9e5f519a7e1bd99cbe8daa324010a74f5e2ebc97c6242c08f26f3714f6f", size = 10507885, upload-time = "2026-02-19T22:32:15.635Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/10/3d18e3bbdf8fc50bbb4ac3cc45970aa5a9753c5cb51bf9ed9a3cd8b79fa3/ruff-0.15.2-py3-none-win_amd64.whl", hash = "sha256:d20014e3dfa400f3ff84830dfb5755ece2de45ab62ecea4af6b7262d0fb4f7c5", size = 11623725, upload-time = "2026-02-19T22:32:04.947Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/78/097c0798b1dab9f8affe73da9642bb4500e098cb27fd8dc9724816ac747b/ruff-0.15.2-py3-none-win_arm64.whl", hash = "sha256:cabddc5822acdc8f7b5527b36ceac55cc51eec7b1946e60181de8fe83ca8876e", size = 10941649, upload-time = "2026-02-19T22:32:18.108Z" },
 ]
 
 [[package]]
@@ -1177,26 +1177,26 @@ wheels = [
 
 [[package]]
 name = "ty"
-version = "0.0.21"
+version = "0.0.18"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/20/2ba8fd9493c89c41dfe9dbb73bc70a28b28028463bc0d2897ba8be36230a/ty-0.0.21.tar.gz", hash = "sha256:a4c2ba5d67d64df8fcdefd8b280ac1149d24a73dbda82fa953a0dff9d21400ed", size = 5297967, upload-time = "2026-03-06T01:57:13.809Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/15/9682700d8d60fdca7afa4febc83a2354b29cdcd56e66e19c92b521db3b39/ty-0.0.18.tar.gz", hash = "sha256:04ab7c3db5dcbcdac6ce62e48940d3a0124f377c05499d3f3e004e264ae94b83", size = 5214774, upload-time = "2026-02-20T21:51:31.173Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/36/70/edf38bb37517531681d1c37f5df64744e5ad02673c02eb48447eae4bea08/ty-0.0.21-py3-none-linux_armv6l.whl", hash = "sha256:7bdf2f572378de78e1f388d24691c89db51b7caf07cf90f2bfcc1d6b18b70a76", size = 10299222, upload-time = "2026-03-06T01:57:16.64Z" },
-    { url = "https://files.pythonhosted.org/packages/72/62/0047b0bd19afeefbc7286f20a5f78a2aa39f92b4d89853f0d7185ab89edc/ty-0.0.21-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:7e9613994610431ab8625025bd2880dbcb77c5c9fabdd21134cda12d840a529d", size = 10130513, upload-time = "2026-03-06T01:57:29.93Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/20/0b93a9e91aaed23155780258cdfdb4726ef68b6985378ac069bc427291a0/ty-0.0.21-py3-none-macosx_11_0_arm64.whl", hash = "sha256:56d3b198b64dd0a19b2b66e257deaed2ecea568e722ae5352f3c6fb62027f89d", size = 9605425, upload-time = "2026-03-06T01:57:27.115Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/fd/9945e2fa2996a1287b1e1d7ce050e97e1f420233b271e770934bfa0880a0/ty-0.0.21-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d23d2c34f7a77d974bb08f0860ef700addc8a683d81a0319f71c08f87506cfd0", size = 10108298, upload-time = "2026-03-06T01:57:35.429Z" },
-    { url = "https://files.pythonhosted.org/packages/52/e7/4ec52fcb15f3200826c9f048472c062549a05b0d1ef0b51f32d527b513c4/ty-0.0.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56b01fd2519637a4ca88344f61c96225f540c98ff18bca321d4eaa7bb0f7aa2f", size = 10121556, upload-time = "2026-03-06T01:57:03.242Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/c0/ad457be2a8abea0f25549598bd098554540ced66229488daa0d558dad3c8/ty-0.0.21-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e9de7e11c63c6afc40f3e9ba716374add171aee7fabc70b5146a510705c6d41b", size = 10603264, upload-time = "2026-03-06T01:56:52.134Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5b/2ecc7a2175243a4bcb72f5298ae41feabbb93b764bb0dc45722f3752c2c2/ty-0.0.21-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:62f7f5b235c4f7876db305c36997aea07b7af29b1a068f373d0e2547e25f32ff", size = 11196428, upload-time = "2026-03-06T01:57:32.94Z" },
-    { url = "https://files.pythonhosted.org/packages/37/f5/aff507d6a901f328ef96a298032b0c11aaaf950a146ed7dd3b5bf2cd3acf/ty-0.0.21-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ee8399f7c453a425291e6688efe430cfae7ab0ac4ffd50eba9f872bf878b54f6", size = 10866355, upload-time = "2026-03-06T01:56:57.831Z" },
-    { url = "https://files.pythonhosted.org/packages/be/30/822bbcb92d55b65989aa7ed06d9585f28ade9c9447369194ed4b0fb3b5b9/ty-0.0.21-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210e7568c9f886c4d01308d751949ee714ad7ad9d7d928d2ba90d329dd880367", size = 10738177, upload-time = "2026-03-06T01:57:11.256Z" },
-    { url = "https://files.pythonhosted.org/packages/57/cc/46e7991b6469e93ac2c7e533a028983e402485580150ac864c56352a3a82/ty-0.0.21-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:53508e345b11569f78b21ba8e2b4e61df38a9754947fb3cd9f2ef574367338fb", size = 10079158, upload-time = "2026-03-06T01:57:00.516Z" },
-    { url = "https://files.pythonhosted.org/packages/15/c2/0bbdadfbd008240f8f1a87dc877433cb3884436097926107ccf06e618199/ty-0.0.21-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:553e43571f4a35604c36cfd07d8b61a5eb7a714e3c67f8c4ff2cf674fefbaef9", size = 10150535, upload-time = "2026-03-06T01:57:08.815Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/b5/2dbdb7b57b5362200ef0a39738ebd31331726328336def0143ac097ee59d/ty-0.0.21-py3-none-musllinux_1_2_i686.whl", hash = "sha256:666f6822e3b9200abfa7e95eb0ddd576460adb8d66b550c0ad2c70abc84a2048", size = 10319803, upload-time = "2026-03-06T01:57:19.106Z" },
-    { url = "https://files.pythonhosted.org/packages/72/84/70e52c0b7abc7c2086f9876ef454a73b161d3125315536d8d7e911c94ca4/ty-0.0.21-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a0854d008347ce4a5fb351af132f660a390ab2a1163444d075251d43e6f74b9b", size = 10826239, upload-time = "2026-03-06T01:57:21.727Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/8a/1f72480fd013bbc6cd1929002abbbcde9a0b08ead6a15154de9d7f7fa37e/ty-0.0.21-py3-none-win32.whl", hash = "sha256:bef3ab4c7b966bcc276a8ac6c11b63ba222d21355b48d471ea782c4104eee4e0", size = 9693196, upload-time = "2026-03-06T01:57:24.126Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/f8/1104808b875c26c640e536945753a78562d606bef4e241d9dbf3d92477f6/ty-0.0.21-py3-none-win_amd64.whl", hash = "sha256:a709d576e5bea84b745d43058d8b9cd4f27f74a0b24acb4b0cbb7d3d41e0d050", size = 10668660, upload-time = "2026-03-06T01:56:55.06Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/b8/25e0adc404bbf986977657b25318991f93097b49f8aea640d93c0b0db68e/ty-0.0.21-py3-none-win_arm64.whl", hash = "sha256:f72047996598ac20553fb7e21ba5741e3c82dee4e9eadf10d954551a5fe09391", size = 10104161, upload-time = "2026-03-06T01:57:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d8/920460d4c22ea68fcdeb0b2fb53ea2aeb9c6d7875bde9278d84f2ac767b6/ty-0.0.18-py3-none-linux_armv6l.whl", hash = "sha256:4e5e91b0a79857316ef893c5068afc4b9872f9d257627d9bc8ac4d2715750d88", size = 10280825, upload-time = "2026-02-20T21:51:25.03Z" },
+    { url = "https://files.pythonhosted.org/packages/83/56/62587de582d3d20d78fcdddd0594a73822ac5a399a12ef512085eb7a4de6/ty-0.0.18-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ee0e578b3f8416e2d5416da9553b78fd33857868aa1384cb7fefeceee5ff102d", size = 10118324, upload-time = "2026-02-20T21:51:22.27Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/2d/dbdace8d432a0755a7417f659bfd5b8a4261938ecbdfd7b42f4c454f5aa9/ty-0.0.18-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3f7a0487d36b939546a91d141f7fc3dbea32fab4982f618d5b04dc9d5b6da21e", size = 9605861, upload-time = "2026-02-20T21:51:16.066Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/d9/de11c0280f778d5fc571393aada7fe9b8bc1dd6a738f2e2c45702b8b3150/ty-0.0.18-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5e2fa8d45f57ca487a470e4bf66319c09b561150e98ae2a6b1a97ef04c1a4eb", size = 10092701, upload-time = "2026-02-20T21:51:26.862Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/94/068d4d591d791041732171e7b63c37a54494b2e7d28e88d2167eaa9ad875/ty-0.0.18-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d75652e9e937f7044b1aca16091193e7ef11dac1c7ec952b7fb8292b7ba1f5f2", size = 10109203, upload-time = "2026-02-20T21:51:11.59Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e4/526a4aa56dc0ca2569aaa16880a1ab105c3b416dd70e87e25a05688999f3/ty-0.0.18-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:563c868edceb8f6ddd5e91113c17d3676b028f0ed380bdb3829b06d9beb90e58", size = 10614200, upload-time = "2026-02-20T21:51:20.298Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/3d/b68ab20a34122a395880922587fbfc3adf090d22e0fb546d4d20fe8c2621/ty-0.0.18-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:502e2a1f948bec563a0454fc25b074bf5cf041744adba8794d024277e151d3b0", size = 11153232, upload-time = "2026-02-20T21:51:14.121Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ea/678243c042343fcda7e6af36036c18676c355878dcdcd517639586d2cf9e/ty-0.0.18-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc881dea97021a3aa29134a476937fd8054775c4177d01b94db27fcfb7aab65b", size = 10832934, upload-time = "2026-02-20T21:51:32.92Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/bd/7f8d647cef8b7b346c0163230a37e903c7461c7248574840b977045c77df/ty-0.0.18-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:421fcc3bc64cab56f48edb863c7c1c43649ec4d78ff71a1acb5366ad723b6021", size = 10700888, upload-time = "2026-02-20T21:51:09.673Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/06/cb3620dc48c5d335ba7876edfef636b2f4498eff4a262ff90033b9e88408/ty-0.0.18-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0fe5038a7136a0e638a2fb1ad06e3d3c4045314c6ba165c9c303b9aeb4623d6c", size = 10078965, upload-time = "2026-02-20T21:51:07.678Z" },
+    { url = "https://files.pythonhosted.org/packages/60/27/c77a5a84533fa3b685d592de7b4b108eb1f38851c40fac4e79cc56ec7350/ty-0.0.18-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d123600a52372677613a719bbb780adeb9b68f47fb5f25acb09171de390e0035", size = 10134659, upload-time = "2026-02-20T21:51:18.311Z" },
+    { url = "https://files.pythonhosted.org/packages/43/6e/60af6b88c73469e628ba5253a296da6984e0aa746206f3034c31f1a04ed1/ty-0.0.18-py3-none-musllinux_1_2_i686.whl", hash = "sha256:bb4bc11d32a1bf96a829bf6b9696545a30a196ac77bbc07cc8d3dfee35e03723", size = 10297494, upload-time = "2026-02-20T21:51:39.631Z" },
+    { url = "https://files.pythonhosted.org/packages/33/90/612dc0b68224c723faed6adac2bd3f930a750685db76dfe17e6b9e534a83/ty-0.0.18-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:dda2efbf374ba4cd704053d04e32f2f784e85c2ddc2400006b0f96f5f7e4b667", size = 10791944, upload-time = "2026-02-20T21:51:37.13Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/da/f4ada0fd08a9e4138fe3fd2bcd3797753593f423f19b1634a814b9b2a401/ty-0.0.18-py3-none-win32.whl", hash = "sha256:c5768607c94977dacddc2f459ace6a11a408a0f57888dd59abb62d28d4fee4f7", size = 9677964, upload-time = "2026-02-20T21:51:42.039Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/fa/090ed9746e5c59fc26d8f5f96dc8441825171f1f47752f1778dad690b08b/ty-0.0.18-py3-none-win_amd64.whl", hash = "sha256:b78d0fa1103d36fc2fce92f2092adace52a74654ab7884d54cdaec8eb5016a4d", size = 10636576, upload-time = "2026-02-20T21:51:29.159Z" },
+    { url = "https://files.pythonhosted.org/packages/92/4f/5dd60904c8105cda4d0be34d3a446c180933c76b84ae0742e58f02133713/ty-0.0.18-py3-none-win_arm64.whl", hash = "sha256:01770c3c82137c6b216aa3251478f0b197e181054ee92243772de553d3586398", size = 10095449, upload-time = "2026-02-20T21:51:34.914Z" },
 ]
 
 [[package]]
@@ -1264,7 +1264,7 @@ wheels = [
 
 [[package]]
 name = "zensical"
-version = "0.0.26"
+version = "0.0.23"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -1274,18 +1274,18 @@ dependencies = [
     { name = "pymdown-extensions" },
     { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/1f/0a0b1ce8e0553a9dabaedc736d0f34b11fc33d71ff46bce44d674996d41f/zensical-0.0.26.tar.gz", hash = "sha256:f4d9c8403df25fbb3d6dd9577122dc2f23c73a2d16ab778bb7d40370dd71e987", size = 3841473, upload-time = "2026-03-11T09:51:38.838Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/ab/a65452b4e769552fd5a78c4996d6cf322630d896ddfd55c5433d96485e8b/zensical-0.0.23.tar.gz", hash = "sha256:5c4fc3aaf075df99d8cf41b9f2566e4d588180d9a89493014d3607dfe50ac4bc", size = 3822451, upload-time = "2026-02-11T21:24:38.373Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/41/58/fa3d9538ff1ea8cf4a193edbf47254f374fa7983fcfa876bb4336d72c53a/zensical-0.0.26-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:7823b25afe7d36099253aa59d643abaac940f80fd015d4a37954210c87d3da56", size = 12263607, upload-time = "2026-03-11T09:50:49.202Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/6e/44a3b21bd3569b9cad203364d73a956768d28a879e4c2be91bd889f74d2c/zensical-0.0.26-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c0254814382cdd3769bc7689180d09bf41de8879871dd736dc52d5f141e8ada7", size = 12144562, upload-time = "2026-03-11T09:50:53.685Z" },
-    { url = "https://files.pythonhosted.org/packages/07/ae/31b9885745b3e7ef23a3ae7f175b879807288d11b3fb7e2d3c119c916258/zensical-0.0.26-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c8e601b2bbd239e564b04cf235eefb9777e7dfc7e1857b8871d6cdcfb577aa0", size = 12506728, upload-time = "2026-03-11T09:50:57.775Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/93/f5291e2c47076474f181f6eef35ef0428117d3f192da4358c0511e2ce09e/zensical-0.0.26-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2dc43c7e6c25d9724fc0450f0273ca4e5e2506eeb7f89f52f1405a592896ca3b", size = 12454975, upload-time = "2026-03-11T09:51:01.514Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/2e/61cac4f2ebad31dab768eb02753ffde9e56d4d34b8f876b949bf516fbd50/zensical-0.0.26-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:24ed236d1254cc474c19227eaa3670a1ccf921af53134ec5542b05853bdcd59c", size = 12791930, upload-time = "2026-03-11T09:51:05.162Z" },
-    { url = "https://files.pythonhosted.org/packages/02/86/51995d1ed2dd6ad8a1a70bcdf3c5eb16b50e62ea70e638d454a6b9061c4d/zensical-0.0.26-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1110147710d1dd025d932c4a7eada836bdf079c91b70fb0ae5b202e14b094617", size = 12548166, upload-time = "2026-03-11T09:51:09.218Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/93/decbafdbfc77170cbc3851464632390846e9aaf45e743c8dd5a24d5673e9/zensical-0.0.26-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7d21596a785428cdebc20859bd94a05334abe14ad24f1bb9cd80d19219e3c220", size = 12682103, upload-time = "2026-03-11T09:51:12.68Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/e2/391d2d08dde621177da069a796a886b549fefb15734aeeb6e696af99b662/zensical-0.0.26-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:680a3c7bb71499b4da784d6072e44b3d7b8c0df3ce9bbd9974e24bd8058c2736", size = 12724219, upload-time = "2026-03-11T09:51:17.32Z" },
-    { url = "https://files.pythonhosted.org/packages/80/2a/21b40c5c40a67da8a841f278d61dbd8d5e035e489de6fe1cef5f4e211b4f/zensical-0.0.26-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:e3294a79f98218b6fc2219232e166aa0932ae4dad58f6c8dbc0dbe0ecbff9c25", size = 12862117, upload-time = "2026-03-11T09:51:22.161Z" },
-    { url = "https://files.pythonhosted.org/packages/51/76/e1910d6d75d207654c867b8efbda6822dedda9fed3601bf4a864a1f4fe26/zensical-0.0.26-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:630229587df1fb47be184a4a69d0772ce59a44cd2c481ae9f7e8852fffaff11e", size = 12815714, upload-time = "2026-03-11T09:51:26.24Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/eb/34b042542cd949192535f8bac172d33b3da5a0ec0853eed008a6ad3242e3/zensical-0.0.26-cp310-abi3-win32.whl", hash = "sha256:e0756581541aad2e63dd8b4abae47e6ff12229a474b4eede5b4da5cc183c5101", size = 11856425, upload-time = "2026-03-11T09:51:31.087Z" },
-    { url = "https://files.pythonhosted.org/packages/92/a5/30f6a88bb125c2bbeae3ae80a0812131614ab30e9b0b199d75d4199e5b66/zensical-0.0.26-cp310-abi3-win_amd64.whl", hash = "sha256:9ca07f5c75b5eac4d273d887100bbccd6eb8ba4959c904e2ab61971a0017c172", size = 12059895, upload-time = "2026-03-11T09:51:35.226Z" },
+    { url = "https://files.pythonhosted.org/packages/66/86/035aa02bd36d26a03a1885bc22a73d4fe61ba0e21d0033cc42baf13d24f6/zensical-0.0.23-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:35d6d3eb803fe73a67187a1a25443408bd02a8dd50e151f4a4bafd40de3f0928", size = 12242966, upload-time = "2026-02-11T21:24:05.894Z" },
+    { url = "https://files.pythonhosted.org/packages/be/68/335dfbb7efc972964f0610736a0ad243dd8a5dcc2ec76b9ddb84c847a4a4/zensical-0.0.23-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:5973267460a190f348f24d445ff0c01e8ed334fd075947687b305e68257f6b18", size = 12125173, upload-time = "2026-02-11T21:24:08.507Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/d567da04fbeb077df5cf06a94f947af829ebef0ff5ca7d0ba4910a6cbdf6/zensical-0.0.23-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:953adf1f0b346a6c65fc6e05e6cc1c38a6440fec29c50c76fb29700cc1927006", size = 12489636, upload-time = "2026-02-11T21:24:10.91Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/6e/481a3ecf8a7b63a35c67f5be1ea548185d55bb1dacead54f76a9550197b2/zensical-0.0.23-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:49c1cbd6131dafa056be828e081759184f9b8dd24b99bf38d1e77c8c31b0c720", size = 12421313, upload-time = "2026-02-11T21:24:13.9Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/aa/a95481547f708432636f5f8155917c90d877c244c62124a084f7448b60b2/zensical-0.0.23-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f5b7fe22c5d33b2b91899c5df7631ad4ce9cccfabac2560cc92ba73eafe2d297", size = 12761031, upload-time = "2026-02-11T21:24:17.016Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/9f/ce1c5af9afd11fe3521a90441aba48c484f98730c6d833d69ee4387ae2e9/zensical-0.0.23-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a3679d6bf6374f503afb74d9f6061da5de83c25922f618042b63a30b16f0389", size = 12527415, upload-time = "2026-02-11T21:24:19.558Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b8/13a5d4d99f3b77e7bf4e791ef991a611ca2f108ed7eddf20858544ab0a91/zensical-0.0.23-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:54d981e21a19c3dcec6e7fa77c4421db47389dfdff20d29fea70df8e1be4062e", size = 12665352, upload-time = "2026-02-11T21:24:22.703Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/84/3d0a187ed941826ca26b19a661c41685d8017b2a019afa0d353eb2ebbdba/zensical-0.0.23-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:afde7865cc3c79c99f6df4a911d638fb2c3b472a1b81367d47163f8e3c36f910", size = 12689042, upload-time = "2026-02-11T21:24:26.118Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/65/12466408f428f2cf7140b32d484753db0891debae3c956f4c076b51eeb17/zensical-0.0.23-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:c484674d7b0a3e6d39db83914db932249bccdef2efaf8a5669671c66c16f584d", size = 12834779, upload-time = "2026-02-11T21:24:28.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ab/0771ac6ffb30e4f04c20374e3beca9e71c3f81112219cdbd86cdc0e3d337/zensical-0.0.23-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:927d12fe2851f355fb3206809e04641d6651bdd2ff4afe9c205721aa3a32aa82", size = 12797057, upload-time = "2026-02-11T21:24:31.383Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ce/fbd45c00a1cba15508ea3c29b121b4be010254eb65c1512bf11f4478496c/zensical-0.0.23-cp310-abi3-win32.whl", hash = "sha256:ffb79db4244324e9cc063d16adff25a40b145153e5e76d75e0012ba3c05af25d", size = 11837823, upload-time = "2026-02-11T21:24:33.869Z" },
+    { url = "https://files.pythonhosted.org/packages/37/82/0aebaa8e7d2e6314a85d9b7ff3f7fc74837a94086b56a9d5d8f2240e9b9c/zensical-0.0.23-cp310-abi3-win_amd64.whl", hash = "sha256:a8cfe240dca75231e8e525985366d010d09ee73aec0937930e88f7230694ce01", size = 12036837, upload-time = "2026-02-11T21:24:36.163Z" },
 ]

zensical.toml

@@ -113,7 +113,6 @@ Modules = [
     {Fixtures = "module/fixtures.md"},
     {Logger = "module/logger.md"},
     {Metrics = "module/metrics.md"},
-    {Models = "module/models.md"},
     {Pytest = "module/pytest.md"},
     {Schemas = "module/schemas.md"},
 ]
@@ -128,7 +127,6 @@ Reference = [
     {Fixtures = "reference/fixtures.md"},
     {Logger = "reference/logger.md"},
     {Metrics = "reference/metrics.md"},
-    {Models = "reference/models.md"},
     {Pytest = "reference/pytest.md"},
     {Schemas = "reference/schemas.md"},
 ]