Deployed 88ecfa8 to v5.1 with Zensical 0.0.51 and mike 2.2.0+zensical-0.1.0

Deployed c15aee2 to v5.0 with Zensical 0.0.50 and mike 2.2.0+zensical-0.1.0
Deployed 06d49d5 to v5.0 with Zensical 0.0.43 and mike 2.2.0+zensical-0.1.0
2026-08-04 23:54:09 +00:00 · 2026-07-28 12:24:25 +00:00 · 2026-07-11 13:17:37 +00:00 · 2026-07-04 09:08:25 +00:00 · 2026-06-25 19:18:13 +00:00 · 2026-06-25 19:18:10 +00:00
337 changed files with 402382 additions and 25578 deletions
@@ -1,14 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    commit-message:
-      prefix: ⬆
-  - package-ecosystem: "uv"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    commit-message:
-      prefix: ⬆
@@ -1,29 +0,0 @@
-name: Build Package
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  build-package:
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-      id-token: write
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Set up Python
-        run: uv python install 3.14
-
-      - name: Install dependencies
-        run: uv sync --group dev
-
-      - name: Build
-        run: uv build
-
-      - name: Publish package distributions to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
@@ -1,111 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  lint:
-    name: Lint (Ruff)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Set up Python
-        run: uv python install 3.13
-
-      - name: Install dependencies
-        run: uv sync --group dev
-
-      - name: Run Ruff linter
-        run: uv run ruff check .
-
-      - name: Run Ruff formatter check
-        run: uv run ruff format --check .
-
-  typecheck:
-    name: Type Check (ty)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Set up Python
-        run: uv python install 3.13
-
-      - name: Install dependencies
-        run: uv sync --group dev
-
-      - name: Run ty
-        run: uv run ty check
-
-  test:
-    name: Test (Python ${{ matrix.python-version }})
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.11", "3.12", "3.13", "3.14"]
-
-    services:
-      postgres:
-        image: postgres:18
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: test_db
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Set up Python ${{ matrix.python-version }}
-        run: uv python install ${{ matrix.python-version }}
-
-      - name: Install dependencies
-        run: uv sync --group dev
-
-      - name: Run tests with coverage
-        env:
-          DATABASE_URL: postgresql+asyncpg://postgres:postgres@localhost:5432/test_db
-        run: |
-          uv run pytest --cov --cov-report=xml --cov-report=term-missing  --junitxml=junit.xml -o junit_family=legacy
-
-      - name: Upload coverage to Codecov
-        if: matrix.python-version == '3.14'
-        uses: codecov/codecov-action@v6
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          report_type: coverage
-          files: ./coverage.xml
-          fail_ci_if_error: false
-
-      - name: Upload test results to Codecov
-        if: matrix.python-version == '3.14'
-        uses: codecov/codecov-action@v6
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          report_type: test_results
@@ -1,53 +0,0 @@
-name: Documentation
-
-on:
-  release:
-    types: [published]
-
-permissions:
-  contents: write
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Set up Python
-        run: uv python install 3.13
-
-      - run: uv sync --group dev
-
-      - name: Configure git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Deploy documentation
-        run: |
-          VERSION=${GITHUB_REF_NAME#v}
-          MAJOR=$(echo "$VERSION" | cut -d. -f1)
-          DEPLOY_VERSION="v$(echo "$VERSION" | cut -d. -f1-2)"
-
-          # On new major: keep only the latest feature version of the previous major
-          PREV_MAJOR=$((MAJOR - 1))
-          OLD_FEATURE_VERSIONS=$(uv run mike list 2>/dev/null | grep -oE "^v${PREV_MAJOR}\.[0-9]+" || true)
-
-          if [ -n "$OLD_FEATURE_VERSIONS" ]; then
-            LATEST_PREV=$(echo "$OLD_FEATURE_VERSIONS" | sort -t. -k2 -n | tail -1)
-            echo "$OLD_FEATURE_VERSIONS" | while read -r OLD_V; do
-              if [ "$OLD_V" != "$LATEST_PREV" ]; then
-                echo "Deleting $OLD_V"
-                uv run mike delete "$OLD_V"
-              fi
-            done
-          fi
-
-          uv run mike deploy --update-aliases "$DEPLOY_VERSION" stable
-          uv run mike set-default stable
-          git push origin gh-pages
@@ -1,207 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[codz]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py.cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-#poetry.toml
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
-#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
-#pdm.lock
-#pdm.toml
-.pdm-python
-.pdm-build/
-
-# pixi
-#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
-#pixi.lock
-#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
-#   in the .venv directory. It is recommended not to include this directory in version control.
-.pixi
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.envrc
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# Abstra
-# Abstra is an AI-powered process automation framework.
-# Ignore directories containing user credentials, local state, and settings.
-# Learn more at https://abstra.io/docs
-.abstra/
-
-# Visual Studio Code
-#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
-#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
-#  and can be added to the global gitignore or merged into this file. However, if you prefer,
-#  you could uncomment the following to ignore the entire vscode folder
-# .vscode/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
-
-# Cursor
-#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
-#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
-#  refer to https://docs.cursor.com/context/ignore-files
-.cursorignore
-.cursorindexingignore
-
-# Marimo
-marimo/_static/
-marimo/_lsp/
-__marimo__/
@@ -1,34 +0,0 @@
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
-repos:
-    - repo: https://github.com/pre-commit/pre-commit-hooks
-      rev: v6.0.0
-      hooks:
-          - id: check-added-large-files
-            args: ["--maxkb=750"]
-            exclude: ^uv.lock$
-          - id: end-of-file-fixer
-          - id: trailing-whitespace
-
-    - repo: local
-      hooks:
-          - id: local-ruff-check
-            name: ruff check
-            entry: uv run ruff check --force-exclude --fix --exit-non-zero-on-fix .
-            require_serial: true
-            language: unsupported
-            types: [python]
-
-          - id: local-ruff-format
-            name: ruff format
-            entry: uv run ruff format --force-exclude --exit-non-zero-on-format .
-            require_serial: true
-            language: unsupported
-            types: [python]
-
-          - id: local-ty
-            name: ty check
-            entry: uv run ty check
-            require_serial: true
-            language: unsupported
-            pass_filenames: false
@@ -1 +0,0 @@
-3.14
@@ -0,0 +1 @@
+fastapi-toolsets.d3vyce.fr
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 d3vyce
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
@@ -1,69 +0,0 @@
-# FastAPI Toolsets
-
-A modular collection of production-ready utilities for FastAPI. Install only what you need — from async CRUD and database helpers to CLI tooling, Prometheus metrics, and pytest fixtures. Each module is independently installable via optional extras, keeping your dependency footprint minimal.
-
-[![CI](https://github.com/d3vyce/fastapi-toolsets/actions/workflows/ci.yml/badge.svg)](https://github.com/d3vyce/fastapi-toolsets/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/d3vyce/fastapi-toolsets/graph/badge.svg)](https://codecov.io/gh/d3vyce/fastapi-toolsets)
-[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
---
-
-**Documentation**: [https://fastapi-toolsets.d3vyce.fr](https://fastapi-toolsets.d3vyce.fr)
-
-**Source Code**: [https://github.com/d3vyce/fastapi-toolsets](https://github.com/d3vyce/fastapi-toolsets)
-
---
-
-## Installation
-
-The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, model mixins, logging):
-
-```bash
-uv add fastapi-toolsets
-```
-
-Install only the extras you need:
-
-```bash
-uv add "fastapi-toolsets[cli]"
-uv add "fastapi-toolsets[metrics]"
-uv add "fastapi-toolsets[pytest]"
-```
-
-Or install everything:
-
-```bash
-uv add "fastapi-toolsets[all]"
-```
-
-## Features
-
-### Core
-
- **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`, `UUIDv7Mixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`)
- **Lifecycle Events**: Post-commit event system (`EventSession`, `listens_for`) that dispatches async/sync callbacks for insert, update, and delete operations
- **Standardized API Responses**: Consistent response format with `Response`, `ErrorResponse`, `PaginatedResponse`, `CursorPaginatedResponse` and `OffsetPaginatedResponse`.
- **Exception Handling**: Structured error responses with automatic OpenAPI documentation
- **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`
-
-### Optional
-
- **CLI**: Django-like command-line interface with fixture management and custom commands support
- **Metrics**: Prometheus metrics endpoint with provider/collector registry
- **Pytest Helpers**: Async test client, database session management, `pytest-xdist` support, and table cleanup utilities
-
-## License
-
-MIT License - see [LICENSE](LICENSE) for details.
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit issues and pull requests.
@@ -1,185 +0,0 @@
-# Pagination & search
-
-This example builds an articles listing endpoint that supports **offset pagination**, **cursor pagination**, **full-text search**, **faceted filtering**, and **sorting** — all from a single `CrudFactory` definition.
-
-## Models
-
-```python title="models.py"
--8<-- "docs_src/examples/pagination_search/models.py"
-```
-
-## Schemas
-
-```python title="schemas.py"
--8<-- "docs_src/examples/pagination_search/schemas.py"
-```
-
-## Crud
-
-Declare `searchable_fields`, `facet_fields`, and `order_fields` once on [`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory). All endpoints built from this class share the same defaults and can override them per call.
-
-```python title="crud.py"
--8<-- "docs_src/examples/pagination_search/crud.py"
-```
-
-## Session dependency
-
-```python title="db.py"
--8<-- "docs_src/examples/pagination_search/db.py"
-```
-
-!!! info "Deploy a Postgres DB with docker"
-    ```bash
-    docker run -d --name postgres -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=postgres -p 5432:5432 postgres:18-alpine
-    ```
-
-
-## App
-
-```python title="app.py"
--8<-- "docs_src/examples/pagination_search/app.py"
-```
-
-
-## Routes
-
-```python title="routes.py:1:16"
--8<-- "docs_src/examples/pagination_search/routes.py:1:16"
-```
-
-### Offset pagination
-
-Best for admin panels or any UI that needs a total item count and numbered pages.
-
-```python title="routes.py:19:37"
--8<-- "docs_src/examples/pagination_search/routes.py:19:37"
-```
-
-**Example request**
-
-```
-GET /articles/offset?page=2&items_per_page=10&search=fastapi&status=published&order_by=title&order=asc
-```
-
-**Example response**
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "offset",
-  "data": [
-    { "id": "3f47ac69-...", "title": "FastAPI tips", "status": "published", ... }
-  ],
-  "pagination": {
-    "total_count": 42,
-    "pages": 5,
-    "page": 2,
-    "items_per_page": 10,
-    "has_more": true
-  },
-  "filter_attributes": {
-    "status": ["archived", "draft", "published"],
-    "name": ["backend", "frontend", "python"]
-  }
-}
-```
-
-`filter_attributes` always reflects the values visible **after** applying the active filters. Use it to populate filter dropdowns on the client.
-
-To skip the `COUNT(*)` query for better performance on large tables, pass `include_total=False`. `pagination.total_count` will be `null` in the response, while `has_more` remains accurate.
-
-### Cursor pagination
-
-Best for feeds, infinite scroll, or any high-throughput API where offset performance degrades.
-
-```python title="routes.py:40:58"
--8<-- "docs_src/examples/pagination_search/routes.py:40:58"
-```
-
-**Example request**
-
-```
-GET /articles/cursor?items_per_page=10&status=published&order_by=created_at&order=desc
-```
-
-**Example response**
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "cursor",
-  "data": [
-    { "id": "3f47ac69-...", "title": "FastAPI tips", "status": "published", ... }
-  ],
-  "pagination": {
-    "next_cursor": "eyJ2YWx1ZSI6ICIzZjQ3YWM2OS0uLi4ifQ==",
-    "prev_cursor": null,
-    "items_per_page": 10,
-    "has_more": true
-  },
-  "filter_attributes": {
-    "status": ["published"],
-    "name": ["backend", "python"]
-  }
-}
-```
-
-Pass `next_cursor` as the `cursor` query parameter on the next request to advance to the next page.
-
-### Unified endpoint (both strategies)
-
-!!! info "Added in `v2.3.0`"
-
-[`paginate()`](../module/crud.md#unified-paginate--both-strategies-on-one-endpoint) lets a single endpoint support both strategies via a `pagination_type` query parameter. The `pagination_type` field in the response acts as a discriminator for frontend tooling.
-
-```python title="routes.py:61:79"
--8<-- "docs_src/examples/pagination_search/routes.py:61:79"
-```
-
-**Offset request** (default)
-
-```
-GET /articles/?pagination_type=offset&page=1&items_per_page=10
-```
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "offset",
-  "data": ["..."],
-  "pagination": { "total_count": 42, "pages": 5, "page": 1, "items_per_page": 10, "has_more": true }
-}
-```
-
-**Cursor request**
-
-```
-GET /articles/?pagination_type=cursor&items_per_page=10
-GET /articles/?pagination_type=cursor&items_per_page=10&cursor=eyJ2YWx1ZSI6...
-```
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "cursor",
-  "data": ["..."],
-  "pagination": { "next_cursor": "eyJ2YWx1ZSI6...", "prev_cursor": null, "items_per_page": 10, "has_more": true }
-}
-```
-
-## Search behaviour
-
-Both endpoints inherit the same `searchable_fields` declared on `ArticleCrud`:
-
-Search is **case-insensitive** and uses a `LIKE %query%` pattern. Pass a [`SearchConfig`](../reference/crud.md#fastapi_toolsets.crud.search.SearchConfig) instead of a plain string to control case sensitivity or switch to `match_mode="all"` (AND across all fields instead of OR).
-
-```python
-from fastapi_toolsets.crud import SearchConfig
-
-# Both title AND body must contain "fastapi"
-result = await ArticleCrud.offset_paginate(
-    session,
-    search=SearchConfig(query="fastapi", case_sensitive=True, match_mode="all"),
-    search_fields=[Article.title, Article.body],
-)
-```
@@ -1,69 +0,0 @@
-# FastAPI Toolsets
-
-A modular collection of production-ready utilities for FastAPI. Install only what you need — from async CRUD and database helpers to CLI tooling, Prometheus metrics, and pytest fixtures. Each module is independently installable via optional extras, keeping your dependency footprint minimal.
-
-[![CI](https://github.com/d3vyce/fastapi-toolsets/actions/workflows/ci.yml/badge.svg)](https://github.com/d3vyce/fastapi-toolsets/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/d3vyce/fastapi-toolsets/graph/badge.svg)](https://codecov.io/gh/d3vyce/fastapi-toolsets)
-[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
---
-
-**Documentation**: [https://fastapi-toolsets.d3vyce.fr](https://fastapi-toolsets.d3vyce.fr)
-
-**Source Code**: [https://github.com/d3vyce/fastapi-toolsets](https://github.com/d3vyce/fastapi-toolsets)
-
---
-
-## Installation
-
-The base package includes the core modules (CRUD, database, schemas, exceptions, fixtures, dependencies, model mixins, logging):
-
-```bash
-uv add fastapi-toolsets
-```
-
-Install only the extras you need:
-
-```bash
-uv add "fastapi-toolsets[cli]"
-uv add "fastapi-toolsets[metrics]"
-uv add "fastapi-toolsets[pytest]"
-```
-
-Or install everything:
-
-```bash
-uv add "fastapi-toolsets[all]"
-```
-
-## Features
-
-### Core
-
- **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`, `UUIDv7Mixin`, `CreatedAtMixin`, `UpdatedAtMixin`, `TimestampMixin`).
- **Lifecycle Events**: Post-commit event system (`EventSession`, `listens_for`) that dispatches async/sync callbacks for insert, update, and delete operations.
- **Standardized API Responses**: Consistent response format with `Response`, `ErrorResponse`, `PaginatedResponse`, `CursorPaginatedResponse` and `OffsetPaginatedResponse`.
- **Exception Handling**: Structured error responses with automatic OpenAPI documentation
- **Logging**: Logging configuration with uvicorn integration via `configure_logging` and `get_logger`
-
-### Optional
-
- **CLI**: Django-like command-line interface with fixture management and custom commands support
- **Metrics**: Prometheus metrics endpoint with provider/collector registry
- **Pytest Helpers**: Async test client, database session management, `pytest-xdist` support, and table cleanup utilities
-
-## License
-
-MIT License - see [LICENSE](LICENSE) for details.
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit issues and pull requests.
@@ -1,137 +0,0 @@
-# Migrating to v2.0
-
-This page covers every breaking change introduced in **v2.0** and the steps required to update your code.
-
---
-
-## CRUD
-
-### `schema` is now required in `offset_paginate()` and `cursor_paginate()`
-
-Calls that omit `schema` will now raise a `TypeError` at runtime.
-
-Previously `schema` was optional; omitting it returned raw SQLAlchemy model instances inside the response. It is now a required keyword argument and the response always contains serialized schema instances.
-
-=== "Before (`v1`)"
-
-    ```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)
-    ```
-
-=== "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)
-    ```
-
-### `as_response` removed from `create()`, `get()`, and `update()`
-
-Passing `as_response` to these methods will raise a `TypeError` at runtime.
-
-The `as_response=True` shorthand is replaced by passing a `schema` directly. The return value is a `Response[schema]` when `schema` is provided, or the raw model instance when it is not.
-
-=== "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)
-    ```
-
-=== "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)
-    ```
-
-### `delete()`: `as_response` renamed and return type changed
-
-`as_response` is gone, and the plain (non-response) call no longer returns `True`.
-
-Two changes were made to `delete()`:
-
-1. The `as_response` parameter is renamed to `return_response`.
-2. When called without `return_response=True`, the method now returns `None` on success instead of `True`.
-
-=== "Before (`v1`)"
-
-    ```python
-    ok = await UserCrud.delete(session=session, filters=filters)
-    if ok:  # True on success
-        ...
-
-    response = await UserCrud.delete(session=session, filters=filters, as_response=True)
-    ```
-
-=== "Now (`v2`)"
-
-    ```python
-    await UserCrud.delete(session=session, filters=filters)  # returns None
-
-    response = await UserCrud.delete(session=session, filters=filters, return_response=True)
-    ```
-
-### `paginate()` alias removed
-
-Any call to `crud.paginate(...)` will raise `AttributeError` at runtime.
-
-The `paginate` shorthand was an alias for `offset_paginate`. It has been removed; call `offset_paginate` directly.
-
-=== "Before (`v1`)"
-
-    ```python
-    result = await UserCrud.paginate(session=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)
-    ```
-
---
-
-## Exceptions
-
-### Missing `api_error` raises `TypeError` at class definition time
-
-Unfinished or stub exception subclasses that previously compiled fine will now fail on import.
-
-In `v1`, a subclass without `api_error` would only fail when the exception was raised. In `v2`, `__init_subclass__` validates this at class definition time.
-
-=== "Before (`v1`)"
-
-    ```python
-    class MyError(ApiException):
-        pass  # fine until raised
-    ```
-
-=== "Now (`v2`)"
-
-    ```python
-    class MyError(ApiException):
-        pass  # TypeError: MyError must define an 'api_error' class attribute.
-    ```
-
-For shared base classes that are not meant to be raised directly, use `abstract=True`:
-
-```python
-class BillingError(ApiException, abstract=True):
-    """Base for all billing-related errors — not raised directly."""
-
-class PaymentRequiredError(BillingError):
-    api_error = ApiError(code=402, msg="Payment Required", desc="...", err_code="BILLING-402")
-```
-
---
-
-## Schemas
-
-### `Pagination` alias removed
-
-`Pagination` was already deprecated in `v1` and is fully removed in `v2`, you now need to use [`OffsetPagination`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPagination) or [`CursorPagination`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPagination).
@@ -1,180 +0,0 @@
-# Migrating to v3.0
-
-This page covers every breaking change introduced in **v3.0** and the steps required to update your code.
-
---
-
-## CRUD
-
-### Facet keys now always use the full relationship chain
-
-In `v2`, relationship facet fields used only the terminal column key (e.g. `"name"` for `Role.name`) and only prepended the relationship name when two facet fields shared the same column key. In `v3`, facet keys **always** include the full relationship chain joined by `__`, regardless of collisions.
-
-=== "Before (`v2`)"
-
-    ```
-    User.status -> status
-    (User.role, Role.name) -> name
-    (User.role, Role.permission, Permission.name) -> name
-    ```
-
-=== "Now (`v3`)"
-
-    ```
-    User.status -> status
-    (User.role, Role.name) -> role__name
-    (User.role, Role.permission, Permission.name) -> role__permission__name
-    ```
-
---
-
-### `*_params` dependencies consolidated into per-paginate methods
-
-The six individual dependency methods (`offset_params`, `cursor_params`, `paginate_params`, `filter_params`, `search_params`, `order_params`) have been **removed** and replaced by three consolidated methods that bundle pagination, search, filter, and order into a single `Depends()` call.
-
-| Removed | Replacement |
-|---|---|
-| `offset_params()` + `filter_params()` + `search_params()` + `order_params()` | `offset_paginate_params()` |
-| `cursor_params()` + `filter_params()` + `search_params()` + `order_params()` | `cursor_paginate_params()` |
-| `paginate_params()` + `filter_params()` + `search_params()` + `order_params()` | `paginate_params()` |
-
-Each new method accepts `search`, `filter`, and `order` boolean toggles (all `True` by default) to disable features you don't need.
-
-=== "Before (`v2`)"
-
-    ```python
-    from fastapi_toolsets.crud import OrderByClause
-
-    @router.get("/offset")
-    async def list_articles_offset(
-        session: SessionDep,
-        params: Annotated[dict, Depends(ArticleCrud.offset_params(default_page_size=20))],
-        filter_by: Annotated[dict, Depends(ArticleCrud.filter_params())],
-        order_by: Annotated[OrderByClause | None, Depends(ArticleCrud.order_params(default_field=Article.created_at))],
-        search: str | None = None,
-    ) -> OffsetPaginatedResponse[ArticleRead]:
-        return await ArticleCrud.offset_paginate(
-            session=session,
-            **params,
-            search=search,
-            filter_by=filter_by or None,
-            order_by=order_by,
-            schema=ArticleRead,
-        )
-    ```
-
-=== "Now (`v3`)"
-
-    ```python
-    @router.get("/offset")
-    async def list_articles_offset(
-        session: SessionDep,
-        params: Annotated[
-            dict,
-            Depends(
-                ArticleCrud.offset_paginate_params(
-                    default_page_size=20,
-                    default_order_field=Article.created_at,
-                )
-            ),
-        ],
-    ) -> OffsetPaginatedResponse[ArticleRead]:
-        return await ArticleCrud.offset_paginate(session=session, **params, schema=ArticleRead)
-    ```
-
-The same pattern applies to `cursor_paginate_params()` and `paginate_params()`. To disable a feature, pass the toggle:
-
-```python
-# No search or ordering, only pagination + filtering
-ArticleCrud.offset_paginate_params(search=False, order=False)
-```
-
---
-
-## Models
-
-The lifecycle event system has been rewritten. Callbacks are now registered with a module-level [`listens_for`](../reference/models.md#fastapi_toolsets.models.listens_for) decorator and dispatched by [`EventSession`](../reference/models.md#fastapi_toolsets.models.EventSession), replacing the mixin-based approach from `v2`.
-
-### `WatchedFieldsMixin` and `@watch` removed
-
-Importing `WatchedFieldsMixin` or `watch` will raise `ImportError`.
-
-Model method callbacks (`on_create`, `on_delete`, `on_update`) and the `@watch` decorator are replaced by:
-
-1. **`__watched_fields__`** — a plain class attribute to restrict which field changes trigger `UPDATE` events (replaces `@watch`).
-2. **`@listens_for`** — a module-level decorator to register callbacks for one or more [`ModelEvent`](../reference/models.md#fastapi_toolsets.models.ModelEvent) types (replaces `on_create` / `on_delete` / `on_update` methods).
-
-=== "Before (`v2`)"
-
-    ```python
-    from fastapi_toolsets.models import WatchedFieldsMixin, watch
-
-    @watch("status")
-    class Order(Base, UUIDMixin, WatchedFieldsMixin):
-        __tablename__ = "orders"
-
-        status: Mapped[str]
-
-        async def on_create(self):
-            await notify_new_order(self.id)
-
-        async def on_update(self, changes):
-            if "status" in changes:
-                await notify_status_change(self.id, changes["status"])
-
-        async def on_delete(self):
-            await notify_order_cancelled(self.id)
-    ```
-
-=== "Now (`v3`)"
-
-    ```python
-    from fastapi_toolsets.models import ModelEvent, UUIDMixin, listens_for
-
-    class Order(Base, UUIDMixin):
-        __tablename__ = "orders"
-        __watched_fields__ = ("status",)
-
-        status: Mapped[str]
-
-    @listens_for(Order, [ModelEvent.CREATE])
-    async def on_order_created(order: Order, event_type: ModelEvent, changes: None):
-        await notify_new_order(order.id)
-
-    @listens_for(Order, [ModelEvent.UPDATE])
-    async def on_order_updated(order: Order, event_type: ModelEvent, changes: dict):
-        if "status" in changes:
-            await notify_status_change(order.id, changes["status"])
-
-    @listens_for(Order, [ModelEvent.DELETE])
-    async def on_order_deleted(order: Order, event_type: ModelEvent, changes: None):
-        await notify_order_cancelled(order.id)
-    ```
-
-### `EventSession` now required
-
-Without `EventSession`, lifecycle callbacks will silently stop firing.
-
-Callbacks are now dispatched inside `EventSession.commit()` rather than via background tasks. Pass it as the session class when creating your session factory:
-
-=== "Before (`v2`)"
-
-    ```python
-    from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-
-    engine = create_async_engine("postgresql+asyncpg://...")
-    SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
-    ```
-
-=== "Now (`v3`)"
-
-    ```python
-    from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-    from fastapi_toolsets.models import EventSession
-
-    engine = create_async_engine("postgresql+asyncpg://...")
-    SessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=EventSession)
-    ```
-
-!!! note
-    If you use `create_db_session` from `fastapi_toolsets.pytest`, the session already uses `EventSession` — no changes needed in tests.
@@ -1,93 +0,0 @@
-# CLI
-
-Typer-based command-line interface for managing your FastAPI application, with built-in fixture commands integration.
-
-## Installation
-
-=== "uv"
-    ``` bash
-    uv add "fastapi-toolsets[cli]"
-    ```
-
-=== "pip"
-    ``` bash
-    pip install "fastapi-toolsets[cli]"
-    ```
-
-## Overview
-
-The `cli` module provides a `manager` entry point built with [Typer](https://typer.tiangolo.com/). It allow custom commands to be added in addition of the fixture commands when a [`FixtureRegistry`](../reference/fixtures.md#fastapi_toolsets.fixtures.registry.FixtureRegistry) and a database context are configured.
-
-## Configuration
-
-Configure the CLI in your `pyproject.toml`:
-
-```toml
-[tool.fastapi-toolsets]
-cli = "myapp.cli:cli"                   # Custom Typer app
-fixtures = "myapp.fixtures:registry"    # FixtureRegistry instance
-db_context = "myapp.db:db_context"      # Async context manager for sessions
-```
-
-All fields are optional. Without configuration, the `manager` command still works but no command are available.
-
-## Usage
-
-```bash
-# Manager commands
-manager --help
-
- Usage: manager [OPTIONS] COMMAND [ARGS]...
-
- FastAPI utilities CLI.
-
-╭─ Options ────────────────────────────────────────────────────────────────────────╮
-│ --install-completion          Install completion for the current shell.          │
-│ --show-completion             Show completion for the current shell, to copy it  │
-│                               or customize the installation.                     │
-│ --help                        Show this message and exit.                        │
-╰──────────────────────────────────────────────────────────────────────────────────╯
-╭─ Commands ───────────────────────────────────────────────────────────────────────╮
-│ check-db                                                                         │
-│ fixtures  Manage database fixtures.                                              │
-╰──────────────────────────────────────────────────────────────────────────────────╯
-
-# Fixtures commands
-manager fixtures --help
-
- Usage: manager fixtures [OPTIONS] COMMAND [ARGS]...
-
- Manage database fixtures.
-
-╭─ Options ────────────────────────────────────────────────────────────────────────╮
-│ --help          Show this message and exit.                                      │
-╰──────────────────────────────────────────────────────────────────────────────────╯
-╭─ Commands ───────────────────────────────────────────────────────────────────────╮
-│ list  List all registered fixtures.                                              │
-│ load  Load fixtures into the database.                                           │
-╰──────────────────────────────────────────────────────────────────────────────────╯
-```
-
-## Custom CLI
-
-You can extend the CLI by providing your own Typer app. The `manager` entry point will merge your app's commands with the built-in ones:
-
-```python
-# myapp/cli.py
-import typer
-
-cli = typer.Typer()
-
-@cli.command()
-def hello():
-    print("Hello from my app!")
-```
-
-```toml
-[tool.fastapi-toolsets]
-cli = "myapp.cli:cli"
-```
-
---
-
-[:material-api: API Reference](../reference/cli.md)
@@ -1,644 +0,0 @@
-# CRUD
-
-Generic async CRUD operations for SQLAlchemy models with search, pagination, and many-to-many support.
-
-!!! info
-    This module has been coded and tested to be compatible with PostgreSQL only.
-
-## Overview
-
-The `crud` module provides [`AsyncCrud`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud), a base class with a full suite of async database operations, and [`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory), a convenience function to instantiate it for a given model.
-
-## Creating a CRUD class
-
-### Factory style
-
-```python
-from fastapi_toolsets.crud import CrudFactory
-from myapp.models import User
-
-UserCrud = CrudFactory(model=User)
-```
-
-[`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory) dynamically creates a class named `AsyncUserCrud` with `User` as its model. This is the most concise option for straightforward CRUD with no custom logic.
-
-### Subclass style
-
-!!! info "Added in `v2.3.0`"
-
-```python
-from fastapi_toolsets.crud.factory import AsyncCrud
-from myapp.models import User
-
-class UserCrud(AsyncCrud[User]):
-    model = User
-    searchable_fields = [User.username, User.email]
-    default_load_options = [selectinload(User.role)]
-```
-
-Subclassing [`AsyncCrud`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud) directly is the preferred style when you need to add custom methods or when the configuration is complex enough to benefit from a named class body.
-
-### Adding custom methods
-
-```python
-class UserCrud(AsyncCrud[User]):
-    model = User
-
-    @classmethod
-    async def get_active(cls, session: AsyncSession) -> list[User]:
-        return await cls.get_multi(session, filters=[User.is_active == True])
-```
-
-### Sharing a custom base across multiple models
-
-Define a generic base class with the shared methods, then subclass it for each model:
-
-```python
-from typing import Generic, TypeVar
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase
-from fastapi_toolsets.crud.factory import AsyncCrud
-
-T = TypeVar("T", bound=DeclarativeBase)
-
-class AuditedCrud(AsyncCrud[T], Generic[T]):
-    """Base CRUD with custom function"""
-
-    @classmethod
-    async def get_active(cls, session: AsyncSession):
-        return await cls.get_multi(session, filters=[cls.model.is_active == True])
-
-
-class UserCrud(AuditedCrud[User]):
-    model = User
-    searchable_fields = [User.username, User.email]
-```
-
-You can also use the factory shorthand with the same base by passing `base_class`:
-
-```python
-UserCrud = CrudFactory(User, base_class=AuditedCrud)
-```
-
-## Basic operations
-
-!!! info "`get_or_none` added in `v2.2`"
-
-```python
-# Create
-user = await UserCrud.create(session=session, obj=UserCreateSchema(username="alice"))
-
-# 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])
-
-# Get multiple
-users = await UserCrud.get_multi(session=session, filters=[User.is_active == True])
-
-# Update
-user = await UserCrud.update(session=session, obj=UserUpdateSchema(username="bob"), filters=[User.id == user_id])
-
-# Delete
-await UserCrud.delete(session=session, filters=[User.id == user_id])
-
-# Count / exists
-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`)"
-
-Three pagination methods are available.  All return a typed response whose `pagination_type` field tells clients which strategy was used.
-
-| | `offset_paginate` | `cursor_paginate` | `paginate` |
-|---|---|---|---|
-| Return type | `OffsetPaginatedResponse` | `CursorPaginatedResponse` | either, based on `pagination_type` param |
-| Total count | Yes | No | / |
-| Jump to arbitrary page | Yes | No | / |
-| Performance on deep pages | Degrades | Constant | / |
-| Stable under concurrent inserts | No | Yes | / |
-| Use case | Admin panels, numbered pagination | Feeds, APIs, infinite scroll | single endpoint, both strategies |
-
-### Offset pagination
-
-```python
-from typing import Annotated
-from fastapi import Depends
-
-@router.get("")
-async def get_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-The [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) method returns an [`OffsetPaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPaginatedResponse):
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "offset",
-  "data": ["..."],
-  "pagination": {
-    "total_count": 100,
-    "pages": 5,
-    "page": 1,
-    "items_per_page": 20,
-    "has_more": true
-  }
-}
-```
-
-#### Skipping the COUNT query
-
-!!! info "Added in `v2.4.1`"
-
-By default `offset_paginate` runs two queries: one for the page items and one `COUNT(*)` for `total_count`. On large tables the `COUNT` can be expensive. Pass `include_total=False` to `offset_paginate_params()` to skip it:
-
-```python
-@router.get("")
-async def get_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params(include_total=False))],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-### Cursor pagination
-
-```python
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
-```
-
-The [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate) method returns a [`CursorPaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPaginatedResponse):
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "cursor",
-  "data": ["..."],
-  "pagination": {
-    "next_cursor": "eyJ2YWx1ZSI6ICIzZjQ3YWM2OS0uLi4ifQ==",
-    "prev_cursor": null,
-    "items_per_page": 20,
-    "has_more": true
-  }
-}
-```
-
-Pass `next_cursor` as the `cursor` query parameter on the next request to advance to the next page. `prev_cursor` is set on pages 2+ and points back to the first item of the current page. Both are `null` when there is no adjacent page.
-
-#### Choosing a cursor column
-
-The cursor column is set once on [`CrudFactory`](../reference/crud.md#fastapi_toolsets.crud.factory.CrudFactory) via the `cursor_column` parameter. It must be monotonically ordered for stable results:
-
- Auto-increment integer PKs
- UUID v7 PKs
- Timestamps
-
-!!! warning
-    Random UUID v4 PKs are **not** suitable as cursor columns because their ordering is non-deterministic.
-
-!!! note
-    `cursor_column` is required. Calling [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate) on a CRUD class that has no `cursor_column` configured raises a `ValueError`.
-
-The cursor value is URL-safe base64-encoded (no padding) when returned to the client and decoded back to the correct Python type on the next request. The following SQLAlchemy column types are supported:
-
-| SQLAlchemy type | Python type |
-|---|---|
-| `Integer`, `BigInteger`, `SmallInteger` | `int` |
-| `Uuid` | `uuid.UUID` |
-| `DateTime` | `datetime.datetime` |
-| `Date` | `datetime.date` |
-| `Float`, `Numeric` | `decimal.Decimal` |
-
-```python
-# Paginate by the primary key
-PostCrud = CrudFactory(model=Post, cursor_column=Post.id)
-
-# Paginate by a timestamp column instead
-PostCrud = CrudFactory(model=Post, cursor_column=Post.created_at)
-```
-
-### Unified endpoint (both strategies)
-
-!!! info "Added in `v2.3.0`"
-
-[`paginate()`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.paginate) dispatches to `offset_paginate` or `cursor_paginate` based on a `pagination_type` query parameter, letting you expose **one endpoint** that supports both strategies.  The `pagination_type` field in the response tells clients which strategy was used, enabling frontend discriminated-union typing.
-
-```python
-from fastapi_toolsets.schemas import PaginatedResponse
-
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.paginate_params())],
-) -> PaginatedResponse[UserRead]:
-    return await UserCrud.paginate(session, **params, schema=UserRead)
-```
-
-```
-GET /users?pagination_type=offset&page=2&items_per_page=10
-GET /users?pagination_type=cursor&cursor=eyJ2YWx1ZSI6...&items_per_page=10
-```
-
-## Search
-
-Two search strategies are available, both compatible with [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) and [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate).
-
-| | Full-text search | Faceted search |
-|---|---|---|
-| Input | Free-text string | Exact column values |
-| Relationship support | Yes | Yes |
-| Use case | Search bars | Filter dropdowns |
-
-!!! info "You can use both search strategies in the same endpoint!"
-
-### 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
-PostCrud = CrudFactory(
-    model=Post,
-    searchable_fields=[
-        Post.title,
-        Post.content,
-        (Post.author, User.username),  # search across relationship
-    ],
-)
-```
-
-You can override `searchable_fields` per call with `search_fields`:
-
-```python
-result = await UserCrud.offset_paginate(
-    session=session,
-    search_fields=[User.country],
-)
-```
-
-Or via the dependency to narrow which fields are exposed as query parameters:
-
-```python
-params = UserCrud.offset_paginate_params(search_fields=[Post.title])
-```
-
-This allows searching with both [`offset_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.offset_paginate) and [`cursor_paginate`](../reference/crud.md#fastapi_toolsets.crud.factory.AsyncCrud.cursor_paginate):
-
-```python
-@router.get("")
-async def get_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-```python
-@router.get("")
-async def get_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
-```
-
-The dependency adds two query parameters to the endpoint:
-
-| Parameter       | Type          |
-| --------------- | ------------- |
-| `search`        | `str \| null` |
-| `search_column` | `str \| null` |
-
-```
-GET /posts?search=hello                        → search all configured columns
-GET /posts?search=hello&search_column=title    → search only Post.title
-```
-
-The available search column keys are returned in the `search_columns` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse). Use them to populate a column picker in the UI, or to validate `search_column` values on the client side:
-
-```json
-{
-  "status": "SUCCESS",
-  "data": ["..."],
-  "pagination": { "..." },
-  "search_columns": ["content", "author__username", "title"]
-}
-```
-
-!!! info "Key format uses `__` as a separator for relationship chains."
-    A direct column `Post.title` produces `"title"`. A relationship tuple `(Post.author, User.username)` produces `"author__username"`. An unknown `search_column` value raises [`InvalidSearchColumnError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidSearchColumnError) (HTTP 422).
-
-### Faceted search
-
-!!! info "Added in `v1.2`"
-
-Declare `facet_fields` on the CRUD class to return distinct column values alongside paginated results. This is useful for populating filter dropdowns or building faceted search UIs. Relationship traversal is supported via tuples, using the same syntax as `searchable_fields`:
-
-```python
-UserCrud = CrudFactory(
-    model=User,
-    facet_fields=[
-        User.status,
-        User.country,
-        (User.role, Role.name),  # value from a related model
-    ],
-)
-```
-
-You can override `facet_fields` per call:
-
-```python
-result = await UserCrud.offset_paginate(
-    session=session,
-    facet_fields=[User.country],
-)
-```
-
-Or via the dependency to narrow which fields are exposed as query parameters:
-
-```python
-params = UserCrud.offset_paginate_params(facet_fields=[User.country])
-```
-
-Facet filtering is built into the consolidated params dependencies. When `filter=True` (the default), each facet field is exposed as a query parameter and values are collected into `filter_by` automatically:
-
-```python
-from typing import Annotated
-
-from fastapi import Depends
-
-@router.get("", response_model_exclude_none=True)
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-```python
-@router.get("", response_model_exclude_none=True)
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
-```
-
-Both single-value and multi-value query parameters work:
-
-```
-GET /users?status=active                      → filter_by={"status": ["active"]}
-GET /users?status=active&country=FR           → filter_by={"status": ["active"], "country": ["FR"]}
-GET /users?role__name=admin&role__name=editor → filter_by={"role__name": ["admin", "editor"]}  (IN clause)
-```
-
-`filter_by` and `filters` can be combined — both are applied with AND logic.
-
-The distinct values for each facet field are returned in the `filter_attributes` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse). Use them to populate filter dropdowns in the UI, or to validate `filter_by` keys on the client side:
-
-```json
-{
-  "status": "SUCCESS",
-  "data": ["..."],
-  "pagination": { "..." },
-  "filter_attributes": {
-    "status": ["active", "inactive"],
-    "country": ["DE", "FR", "US"],
-    "role__name": ["admin", "editor", "viewer"]
-  }
-}
-```
-
-!!! info "Key format uses `__` as a separator for relationship chains."
-    A direct column `User.status` produces `"status"`. A relationship tuple `(User.role, Role.name)` produces `"role__name"`. A deeper chain `(User.role, Role.permission, Permission.name)` produces `"role__permission__name"`. An unknown `filter_by` key raises [`InvalidFacetFilterError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidFacetFilterError) (HTTP 422).
-
-## Sorting
-
-!!! info "Added in `v1.3`"
-
-Declare `order_fields` on the CRUD class. Relationship traversal is supported via tuples, using the same syntax as `searchable_fields` and `facet_fields`:
-
-```python
-UserCrud = CrudFactory(
-    model=User,
-    order_fields=[
-        User.name,
-        User.created_at,
-        (User.role, Role.name),  # sort by a related model column
-    ],
-)
-```
-
-You can override `order_fields` per call:
-
-```python
-result = await UserCrud.offset_paginate(
-    session=session,
-    order_fields=[User.name],
-)
-```
-
-Or via the dependency to narrow which fields are exposed as query parameters:
-
-```python
-params = UserCrud.offset_paginate_params(order_fields=[User.name])
-```
-
-Sorting is built into the consolidated params dependencies. When `order=True` (the default), `order_by` and `order` query parameters are exposed and resolved into an `OrderByClause` automatically:
-
-```python
-from typing import Annotated
-
-from fastapi import Depends
-
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-```python
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(UserCrud.cursor_paginate_params())],
-) -> CursorPaginatedResponse[UserRead]:
-    return await UserCrud.cursor_paginate(session=session, **params, schema=UserRead)
-```
-
-The dependency adds two query parameters to the endpoint:
-
-| Parameter  | Type            |
-| ---------- | --------------- |
-| `order_by` | `str \| null`  |
-| `order`    | `asc` or `desc` |
-
-```
-GET /users?order_by=name&order=asc         → ORDER BY users.name ASC
-GET /users?order_by=role__name&order=desc  → LEFT JOIN roles ON ... ORDER BY roles.name DESC
-```
-
-!!! info "Relationship tuples are joined automatically."
-    When a relation field is selected, the related table is LEFT OUTER JOINed automatically. An unknown `order_by` value raises [`InvalidOrderFieldError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidOrderFieldError) (HTTP 422).
-
-
-The available sort keys are returned in the `order_columns` field of [`PaginatedResponse`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse). Use them to populate a sort picker in the UI, or to validate `order_by` values on the client side:
-
-```json
-{
-  "status": "SUCCESS",
-  "data": ["..."],
-  "pagination": { "..." },
-  "order_columns": ["created_at", "name", "role__name"]
-}
-```
-
-!!! info "Key format uses `__` as a separator for relationship chains."
-    A direct column `User.name` produces `"name"`. A relationship tuple `(User.role, Role.name)` produces `"role__name"`.
-
-## Relationship loading
-
-!!! info "Added in `v1.1`"
-
-By default, SQLAlchemy relationships are not loaded unless explicitly requested. Instead of using `lazy="selectin"` on model definitions (which is implicit and applies globally), define a `default_load_options` on the CRUD class to control loading strategy explicitly.
-
-!!! warning
-    Avoid using `lazy="selectin"` on model relationships. It fires silently on every query, cannot be disabled per-call, and can cause unexpected cascading loads through deep relationship chains. Use `default_load_options` instead.
-
-```python
-from sqlalchemy.orm import selectinload
-
-ArticleCrud = CrudFactory(
-    model=Article,
-    default_load_options=[
-        selectinload(Article.category),
-        selectinload(Article.tags),
-    ],
-)
-```
-
-`default_load_options` applies automatically to all read operations (`get`, `first`, `get_multi`, `offset_paginate`, `cursor_paginate`). When `load_options` is passed at call-site, it **fully replaces** `default_load_options` for that query — giving you precise per-call control:
-
-```python
-# Only loads category, tags are not loaded
-article = await ArticleCrud.get(
-    session=session,
-    filters=[Article.id == article_id],
-    load_options=[selectinload(Article.category)],
-)
-
-# Loads nothing — useful for write-then-refresh flows or lightweight checks
-articles = await ArticleCrud.get_multi(session=session, load_options=[])
-```
-
-## Many-to-many relationships
-
-Use `m2m_fields` to map schema fields containing lists of IDs to SQLAlchemy relationships. The CRUD class resolves and validates all IDs before persisting:
-
-```python
-PostCrud = CrudFactory(
-    model=Post,
-    m2m_fields={"tag_ids": Post.tags},
-)
-
-post = await PostCrud.create(session=session, obj=PostCreateSchema(title="Hello", tag_ids=[1, 2, 3]))
-```
-
-## Upsert
-
-Atomic `INSERT ... ON CONFLICT DO UPDATE` using PostgreSQL:
-
-```python
-await UserCrud.upsert(
-    session=session,
-    obj=UserCreateSchema(email="alice@example.com", username="alice"),
-    index_elements=[User.email],
-    set_={"username"},
-)
-```
-
-## Response serialization
-
-!!! info "Added in `v1.1`"
-
-Pass a Pydantic schema class to `create`, `get`, `update`, or `offset_paginate` to serialize the result directly into that schema and wrap it in a [`Response[schema]`](../reference/schemas.md#fastapi_toolsets.schemas.Response) or [`PaginatedResponse[schema]`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse):
-
-```python
-class UserRead(PydanticBase):
-    id: UUID
-    username: str
-
-@router.get(
-    "/{uuid}",
-    responses=generate_error_responses(NotFoundError),
-)
-async def get_user(session: SessionDep, uuid: UUID) -> Response[UserRead]:
-    return await crud.UserCrud.get(
-        session=session,
-        filters=[User.id == uuid],
-        schema=UserRead,
-    )
-
-@router.get("")
-async def list_users(
-    session: SessionDep,
-    params: Annotated[dict, Depends(crud.UserCrud.offset_paginate_params())],
-) -> OffsetPaginatedResponse[UserRead]:
-    return await crud.UserCrud.offset_paginate(session=session, **params, schema=UserRead)
-```
-
-The schema must have `from_attributes=True` (or inherit from [`PydanticBase`](../reference/schemas.md#fastapi_toolsets.schemas.PydanticBase)) so it can be built from SQLAlchemy model instances.
-
---
-
-[:material-api: API Reference](../reference/crud.md)
@@ -1,174 +0,0 @@
-# DB
-
-SQLAlchemy async session management with transactions, table locking, and row-change polling.
-
-!!! info
-    This module has been coded and tested to be compatible with PostgreSQL only.
-
-## Overview
-
-The `db` module provides helpers to create FastAPI dependencies and context managers for `AsyncSession`, along with utilities for nested transactions, table lock and polling for row changes.
-
-## Session dependency
-
-Use [`create_db_dependency`](../reference/db.md#fastapi_toolsets.db.create_db_dependency) to create a FastAPI dependency that yields a session and auto-commits on success:
-
-```python
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
-from fastapi_toolsets.db import create_db_dependency
-
-engine = create_async_engine(url="postgresql+asyncpg://...", future=True)
-session_maker = async_sessionmaker(bind=engine, expire_on_commit=False)
-
-get_db = create_db_dependency(session_maker=session_maker)
-
-@router.get("/users")
-async def list_users(session: AsyncSession = Depends(get_db)):
-    ...
-```
-
-## Session context manager
-
-Use [`create_db_context`](../reference/db.md#fastapi_toolsets.db.create_db_context) for sessions outside request handlers (e.g. background tasks, CLI commands):
-
-```python
-from fastapi_toolsets.db import create_db_context
-
-db_context = create_db_context(session_maker=session_maker)
-
-async def seed():
-    async with db_context() as session:
-        ...
-```
-
-## Nested transactions
-
-[`get_transaction`](../reference/db.md#fastapi_toolsets.db.get_transaction) handles savepoints automatically, allowing safe nesting:
-
-```python
-from fastapi_toolsets.db import get_transaction
-
-async def create_user_with_role(session=session):
-    async with get_transaction(session=session):
-        ...
-        async with get_transaction(session=session):  # uses savepoint
-            ...
-```
-
-## Table locking
-
-[`lock_tables`](../reference/db.md#fastapi_toolsets.db.lock_tables) acquires PostgreSQL table-level locks before executing critical sections:
-
-```python
-from fastapi_toolsets.db import lock_tables
-
-async with lock_tables(session=session, tables=[User], mode="EXCLUSIVE"):
-    # No other transaction can modify User until this block exits
-    ...
-```
-
-Available lock modes are defined in [`LockMode`](../reference/db.md#fastapi_toolsets.db.LockMode): `ACCESS_SHARE`, `ROW_SHARE`, `ROW_EXCLUSIVE`, `SHARE_UPDATE_EXCLUSIVE`, `SHARE`, `SHARE_ROW_EXCLUSIVE`, `EXCLUSIVE`, `ACCESS_EXCLUSIVE`.
-
-## Row-change polling
-
-[`wait_for_row_change`](../reference/db.md#fastapi_toolsets.db.wait_for_row_change) polls a row until a specific column changes value, useful for waiting on async side effects:
-
-```python
-from fastapi_toolsets.db import wait_for_row_change
-
-# Wait up to 30s for order.status to change
-await wait_for_row_change(
-    session=session,
-    model=Order,
-    pk_value=order_id,
-    columns=[Order.status],
-    interval=1.0,
-    timeout=30.0,
-)
-```
-
-## 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)
-```
-
-## Many-to-Many helpers
-
-SQLAlchemy's ORM collection API triggers lazy-loads when you append to a relationship inside a savepoint (e.g. inside `lock_tables` or a nested `get_transaction`). The three `m2m_*` helpers bypass the ORM collection entirely and issue direct SQL against the association table.
-
-### `m2m_add` — insert associations
-
-[`m2m_add`](../reference/db.md#fastapi_toolsets.db.m2m_add) inserts one or more rows into a secondary table without touching the ORM collection:
-
-```python
-from fastapi_toolsets.db import lock_tables, m2m_add
-
-async with lock_tables(session, [Tag]):
-    tag = await TagCrud.create(session, TagCreate(name="python"))
-    await m2m_add(session, post, Post.tags, tag)
-```
-
-Pass `ignore_conflicts=True` to silently skip associations that already exist:
-
-```python
-await m2m_add(session, post, Post.tags, tag, ignore_conflicts=True)
-```
-
-### `m2m_remove` — delete associations
-
-[`m2m_remove`](../reference/db.md#fastapi_toolsets.db.m2m_remove) deletes specific association rows. Removing a non-existent association is a no-op:
-
-```python
-from fastapi_toolsets.db import get_transaction, m2m_remove
-
-async with get_transaction(session):
-    await m2m_remove(session, post, Post.tags, tag1, tag2)
-```
-
-### `m2m_set` — replace the full set
-
-[`m2m_set`](../reference/db.md#fastapi_toolsets.db.m2m_set) atomically replaces all associations: it deletes every existing row for the owner instance then inserts the new set. Passing no related instances clears the association entirely:
-
-```python
-from fastapi_toolsets.db import get_transaction, m2m_set
-
-# Replace all tags
-async with get_transaction(session):
-    await m2m_set(session, post, Post.tags, tag_a, tag_b)
-
-# Clear all tags
-async with get_transaction(session):
-    await m2m_set(session, post, Post.tags)
-```
-
-All three helpers raise `TypeError` if the relationship attribute is not a Many-to-Many (i.e. has no secondary table).
-
---
-
-[:material-api: API Reference](../reference/db.md)
@@ -1,61 +0,0 @@
-# Dependencies
-
-FastAPI dependency factories for automatic model resolution from path and body parameters.
-
-## Overview
-
-The `dependencies` module provides two factory functions that create FastAPI dependencies to fetch a model instance from the database automatically — either from a path parameter or from a request body field — and inject it directly into your route handler.
-
-## `PathDependency`
-
-[`PathDependency`](../reference/dependencies.md#fastapi_toolsets.dependencies.PathDependency) resolves a model from a URL path parameter and injects it into the route handler. Raises [`NotFoundError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.NotFoundError) automatically if the record does not exist.
-
-```python
-from fastapi_toolsets.dependencies import PathDependency
-
-# Plain callable
-UserDep = PathDependency(model=User, field=User.id, session_dep=get_db)
-
-# Annotated
-SessionDep = Annotated[AsyncSession, Depends(get_db)]
-UserDep = PathDependency(model=User, field=User.id, session_dep=SessionDep)
-
-@router.get("/users/{user_id}")
-async def get_user(user: User = UserDep):
-    return user
-```
-
-By default the parameter name is inferred from the field (`user_id` for `User.id`). You can override it:
-
-```python
-UserDep = PathDependency(model=User, field=User.id, session_dep=get_db, param_name="id")
-
-@router.get("/users/{id}")
-async def get_user(user: User = UserDep):
-    return user
-```
-
-## `BodyDependency`
-
-[`BodyDependency`](../reference/dependencies.md#fastapi_toolsets.dependencies.BodyDependency) resolves a model from a field in the request body. Useful when a body contains a foreign key and you want the full object injected:
-
-```python
-from fastapi_toolsets.dependencies import BodyDependency
-
-# Plain callable
-RoleDep = BodyDependency(model=Role, field=Role.id, session_dep=get_db, body_field="role_id")
-
-# Annotated
-SessionDep = Annotated[AsyncSession, Depends(get_db)]
-RoleDep = BodyDependency(model=Role, field=Role.id, session_dep=SessionDep, body_field="role_id")
-
-
-@router.post("/users")
-async def create_user(body: UserCreateSchema, role: Role = RoleDep):
-    user = User(username=body.username, role=role)
-    ...
-```
-
---
-
-[:material-api: API Reference](../reference/dependencies.md)
@@ -1,131 +0,0 @@
-# Exceptions
-
-Structured API exceptions with consistent error responses and automatic OpenAPI documentation.
-
-## Overview
-
-The `exceptions` module provides a set of pre-built HTTP exceptions and a FastAPI exception handler that formats all errors — including validation errors — into a uniform [`ErrorResponse`](../reference/schemas.md#fastapi_toolsets.schemas.ErrorResponse).
-
-## Setup
-
-Register the exception handlers on your FastAPI app at startup:
-
-```python
-from fastapi import FastAPI
-from fastapi_toolsets.exceptions import init_exceptions_handlers
-
-app = FastAPI()
-init_exceptions_handlers(app=app)
-```
-
-This registers handlers for:
-
- [`ApiException`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.ApiException) — all custom exceptions below
- `HTTPException` — Starlette/FastAPI HTTP errors
- `RequestValidationError` — Pydantic request validation (422)
- `ResponseValidationError` — Pydantic response validation (422)
- `Exception` — unhandled errors (500)
-
-It also patches `app.openapi()` to replace the default Pydantic 422 schema with a structured example matching the `ErrorResponse` format.
-
-## Built-in exceptions
-
-| Exception | Status | Default message |
-|-----------|--------|-----------------|
-| [`UnauthorizedError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.UnauthorizedError) | 401 | Unauthorized |
-| [`ForbiddenError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.ForbiddenError) | 403 | Forbidden |
-| [`NotFoundError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.NotFoundError) | 404 | Not Found |
-| [`ConflictError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.ConflictError) | 409 | Conflict |
-| [`NoSearchableFieldsError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.NoSearchableFieldsError) | 400 | No Searchable Fields |
-| [`InvalidFacetFilterError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidFacetFilterError) | 400 | Invalid Facet Filter |
-| [`InvalidOrderFieldError`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.InvalidOrderFieldError) | 422 | Invalid Order Field |
-
-### Per-instance overrides
-
-All built-in exceptions accept optional keyword arguments to customise the response for a specific raise site without changing the class defaults:
-
-| Argument | Effect |
-|----------|--------|
-| `detail` | Overrides both `str(exc)` (log output) and the `message` field in the response body |
-| `desc` | Overrides the `description` field |
-| `data` | Overrides the `data` field |
-
-```python
-raise NotFoundError(detail="User 42 not found", desc="No user with that ID exists in the database.")
-```
-
-## Custom exceptions
-
-Subclass [`ApiException`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.ApiException) and define an `api_error` class variable:
-
-```python
-from fastapi_toolsets.exceptions import ApiException
-from fastapi_toolsets.schemas import ApiError
-
-class PaymentRequiredError(ApiException):
-    api_error = ApiError(
-        code=402,
-        msg="Payment Required",
-        desc="Your subscription has expired.",
-        err_code="BILLING-402",
-    )
-```
-
-!!! warning
-    Subclasses that do not define `api_error` raise a `TypeError` at **class creation time**, not at raise time.
-
-### Custom `__init__`
-
-Override `__init__` to compute `detail`, `desc`, or `data` dynamically, then delegate to `super().__init__()`:
-
-```python
-class OrderValidationError(ApiException):
-    api_error = ApiError(
-        code=422,
-        msg="Order Validation Failed",
-        desc="One or more order fields are invalid.",
-        err_code="ORDER-422",
-    )
-
-    def __init__(self, *field_errors: str) -> None:
-        super().__init__(
-            f"{len(field_errors)} validation error(s)",
-            desc=", ".join(field_errors),
-            data={"errors": [{"message": e} for e in field_errors]},
-        )
-```
-
-### Intermediate base classes
-
-Use `abstract=True` when creating a shared base that is not meant to be raised directly:
-
-```python
-class BillingError(ApiException, abstract=True):
-    """Base for all billing-related errors."""
-
-class PaymentRequiredError(BillingError):
-    api_error = ApiError(code=402, msg="Payment Required", desc="...", err_code="BILLING-402")
-
-class SubscriptionExpiredError(BillingError):
-    api_error = ApiError(code=402, msg="Subscription Expired", desc="...", err_code="BILLING-402-EXP")
-```
-
-## OpenAPI response documentation
-
-Use [`generate_error_responses`](../reference/exceptions.md#fastapi_toolsets.exceptions.exceptions.generate_error_responses) to add error schemas to your endpoint's OpenAPI spec:
-
-```python
-from fastapi_toolsets.exceptions import generate_error_responses, NotFoundError, ForbiddenError
-
-@router.get(
-    "/users/{id}",
-    responses=generate_error_responses(NotFoundError, ForbiddenError),
-)
-async def get_user(...): ...
-```
-
-Multiple exceptions sharing the same HTTP status code are grouped under one entry, each appearing as a named example keyed by its `err_code`. This keeps the OpenAPI UI readable when several error variants map to the same status.
-
---
-
-[:material-api: API Reference](../reference/exceptions.md)
@@ -1,198 +0,0 @@
-# Fixtures
-
-Dependency-aware database seeding with context-based loading strategies.
-
-## Overview
-
-The `fixtures` module lets you define named fixtures with dependencies between them, then load them into the database in the correct order. Fixtures can be scoped to contexts (e.g. base data, testing data) so that only the relevant ones are loaded for each environment.
-
-## Defining fixtures
-
-```python
-from fastapi_toolsets.fixtures import FixtureRegistry, Context
-
-fixtures = FixtureRegistry()
-
-@fixtures.register
-def roles():
-    return [
-        Role(id=1, name="admin"),
-        Role(id=2, name="user"),
-    ]
-
-@fixtures.register(depends_on=["roles"], contexts=[Context.TESTING])
-def test_users():
-    return [
-        User(id=1, username="alice", role_id=1),
-        User(id=2, username="bob", role_id=2),
-    ]
-```
-
-Dependencies declared via `depends_on` are resolved topologically — `roles` will always be loaded before `test_users`.
-
-## Loading fixtures
-
-By context with [`load_fixtures_by_context`](../reference/fixtures.md#fastapi_toolsets.fixtures.utils.load_fixtures_by_context):
-
-```python
-from fastapi_toolsets.fixtures import load_fixtures_by_context
-
-async with db_context() as session:
-    await load_fixtures_by_context(session, fixtures, Context.TESTING)
-```
-
-Directly by name with [`load_fixtures`](../reference/fixtures.md#fastapi_toolsets.fixtures.utils.load_fixtures):
-
-```python
-from fastapi_toolsets.fixtures import load_fixtures
-
-async with db_context() as session:
-    await load_fixtures(session, fixtures, "roles", "test_users")
-```
-
-Both functions return a `dict[str, list[...]]` mapping each fixture name to the list of loaded instances.
-
-## Contexts
-
-[`Context`](../reference/fixtures.md#fastapi_toolsets.fixtures.enum.Context) is an enum with predefined values:
-
-| Context | Description |
-|---------|-------------|
-| `Context.BASE` | Core data required in all environments |
-| `Context.TESTING` | Data only loaded during tests |
-| `Context.DEVELOPMENT` | Data only loaded in development |
-| `Context.PRODUCTION` | Data only loaded in production |
-
-A fixture with no `contexts` defined takes `Context.BASE` by default.
-
-### Custom contexts
-
-Plain strings and any `Enum` subclass are accepted wherever a `Context` enum is expected.
-
-```python
-from enum import Enum
-
-class AppContext(str, Enum):
-    STAGING = "staging"
-    DEMO = "demo"
-
-@fixtures.register(contexts=[AppContext.STAGING])
-def staging_data():
-    return [Config(key="feature_x", enabled=True)]
-
-await load_fixtures_by_context(session, fixtures, AppContext.STAGING)
-```
-
-### Default context for a registry
-
-Pass `contexts` to `FixtureRegistry` to set a default for all fixtures registered in it:
-
-```python
-testing_registry = FixtureRegistry(contexts=[Context.TESTING])
-
-@testing_registry.register          # implicitly contexts=[Context.TESTING]
-def test_orders():
-    return [Order(id=1, total=99)]
-```
-
-### Same fixture name, multiple context variants
-
-The same fixture name may be registered under different (non-overlapping) context sets. When multiple contexts are loaded together, all matching variants are merged:
-
-```python
-@fixtures.register(contexts=[Context.BASE])
-def users():
-    return [User(id=1, username="admin")]
-
-@fixtures.register(contexts=[Context.TESTING])
-def users():
-    return [User(id=2, username="tester")]
-
-# loads both admin and tester
-await load_fixtures_by_context(session, fixtures, Context.BASE, Context.TESTING)
-```
-
-Registering two variants with overlapping context sets raises `ValueError`.
-
-## Load strategies
-
-[`LoadStrategy`](../reference/fixtures.md#fastapi_toolsets.fixtures.enum.LoadStrategy) controls how the fixture loader handles rows that already exist:
-
-| Strategy | Description |
-|----------|-------------|
-| `LoadStrategy.INSERT` | Insert only, fail on duplicates |
-| `LoadStrategy.MERGE` | Insert or update on conflict (default) |
-| `LoadStrategy.SKIP_EXISTING` | Skip rows that already exist |
-
-```python
-await load_fixtures_by_context(
-    session, fixtures, Context.BASE, strategy=LoadStrategy.SKIP_EXISTING
-)
-```
-
-## Merging registries
-
-Split fixture definitions across modules and merge them:
-
-```python
-from myapp.fixtures.dev import dev_fixtures
-from myapp.fixtures.prod import prod_fixtures
-
-fixtures = FixtureRegistry()
-fixtures.include_registry(registry=dev_fixtures)
-fixtures.include_registry(registry=prod_fixtures)
-```
-
-Fixtures with the same name are allowed as long as their context sets do not overlap. Conflicting contexts raise `ValueError`.
-
-## Looking up fixture instances
-
-[`get_obj_by_attr`](../reference/fixtures.md#fastapi_toolsets.fixtures.utils.get_obj_by_attr) retrieves a specific instance from a fixture function by attribute value — useful when building cross-fixture `depends_on` relationships:
-
-```python
-from fastapi_toolsets.fixtures import get_obj_by_attr
-
-@fixtures.register(depends_on=["roles"])
-def users():
-    admin_role = get_obj_by_attr(roles, "name", "admin")
-    return [User(id=1, username="alice", role_id=admin_role.id)]
-```
-
-Raises `StopIteration` if no matching instance is found.
-
-## Pytest integration
-
-Use [`register_fixtures`](../reference/pytest.md#fastapi_toolsets.pytest.plugin.register_fixtures) to expose each fixture in your registry as an injectable pytest fixture named `fixture_{name}` by default:
-
-```python
-# conftest.py
-import pytest
-from fastapi_toolsets.pytest import create_db_session, register_fixtures
-from app.fixtures import registry
-from app.models import Base
-
-DATABASE_URL = "postgresql+asyncpg://user:pass@localhost/test_db"
-
-@pytest.fixture
-async def db_session():
-    async with create_db_session(database_url=DATABASE_URL, base=Base, cleanup=True) as session:
-        yield session
-
-register_fixtures(registry=registry, namespace=globals())
-```
-
-```python
-# test_users.py
-async def test_user_can_login(fixture_users: list[User], fixture_roles: list[Role]):
-    ...
-```
-
-The load order is resolved automatically from the `depends_on` declarations in your registry. Each generated fixture receives `db_session` as a dependency and returns the list of loaded model instances.
-
-## CLI integration
-
-Fixtures can be triggered from the CLI. See the [CLI module](cli.md) for setup instructions.
-
---
-
-[:material-api: API Reference](../reference/fixtures.md)
@@ -1,39 +0,0 @@
-# Logger
-
-Lightweight logging utilities with consistent formatting and uvicorn integration.
-
-## Overview
-
-The `logger` module provides two helpers: one to configure the root logger (and uvicorn loggers) at startup, and one to retrieve a named logger anywhere in your codebase.
-
-## Setup
-
-Call [`configure_logging`](../reference/logger.md#fastapi_toolsets.logger.configure_logging) once at application startup:
-
-```python
-from fastapi_toolsets.logger import configure_logging
-
-configure_logging(level="INFO")
-```
-
-This sets up a stdout handler with a consistent format and also configures uvicorn's access and error loggers so all log output shares the same style.
-
-## Getting a logger
-
-```python
-from fastapi_toolsets.logger import get_logger
-
-logger = get_logger(name=__name__)
-logger.info("User created")
-```
-
-When called without arguments, [`get_logger`](../reference/logger.md#fastapi_toolsets.logger.get_logger) auto-detects the caller's module name via frame inspection:
-
-```python
-# Equivalent to get_logger(name=__name__)
-logger = get_logger()
-```
-
---
-
-[:material-api: API Reference](../reference/logger.md)
@@ -1,109 +0,0 @@
-# Metrics
-
-Prometheus metrics integration with a decorator-based registry and multi-process support.
-
-## Installation
-
-=== "uv"
-    ``` bash
-    uv add "fastapi-toolsets[metrics]"
-    ```
-
-=== "pip"
-    ``` bash
-    pip install "fastapi-toolsets[metrics]"
-    ```
-
-## Overview
-
-The `metrics` module provides a [`MetricsRegistry`](../reference/metrics.md#fastapi_toolsets.metrics.registry.MetricsRegistry) to declare Prometheus metrics with decorators, and an [`init_metrics`](../reference/metrics.md#fastapi_toolsets.metrics.handler.init_metrics) function to mount a `/metrics` endpoint on your FastAPI app.
-
-## Setup
-
-```python
-from fastapi import FastAPI
-from fastapi_toolsets.metrics import MetricsRegistry, init_metrics
-
-app = FastAPI()
-metrics = MetricsRegistry()
-
-init_metrics(app=app, registry=metrics)
-```
-
-This mounts the `/metrics` endpoint that Prometheus can scrape.
-
-## Declaring metrics
-
-### 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.
-
-```python
-from prometheus_client import Counter, Histogram
-
-@metrics.register
-def http_requests():
-    return Counter("http_requests_total", "Total HTTP requests", ["method", "status"])
-
-@metrics.register
-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:
-
-```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())
-```
-
-## Merging registries
-
-Split metrics definitions across modules and merge them:
-
-```python
-from myapp.metrics.http import http_metrics
-from myapp.metrics.db import db_metrics
-
-metrics = MetricsRegistry()
-metrics.include_registry(registry=http_metrics)
-metrics.include_registry(registry=db_metrics)
-```
-
-## Multi-process mode
-
-Multi-process support is enabled automatically when the `PROMETHEUS_MULTIPROC_DIR` environment variable is set. No code changes are required.
-
-!!! warning "Environment variable name"
-    The correct variable is `PROMETHEUS_MULTIPROC_DIR` (not `PROMETHEUS_MULTIPROCESS_DIR`).
-
---
-
-[:material-api: API Reference](../reference/metrics.md)
@@ -1,234 +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 (`clock_timestamp()`), 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()`. The value is retrieved via `RETURNING` after insert, so it is available on the Python object immediately after `flush()`.
-
-!!! warning "Requires PostgreSQL 13+"
-
-```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")
-session.add(user)
-await session.flush()
-print(user.id)  # UUID('...')
-```
-
-### [`UUIDv7Mixin`](../reference/models.md#fastapi_toolsets.models.UUIDv7Mixin)
-
-!!! info "Added in `v2.3`"
-
-Adds a `id: UUID` primary key generated server-side by PostgreSQL using `uuidv7()`. It's a time-ordered UUID format that encodes a millisecond-precision timestamp in the most significant bits, making it naturally sortable and index-friendly.
-
-!!! warning "Requires PostgreSQL 18+"
-
-```python
-from fastapi_toolsets.models import UUIDv7Mixin
-
-class Event(Base, UUIDv7Mixin):
-    __tablename__ = "events"
-
-    name: Mapped[str]
-
-# id is None before flush
-event = Event(name="user.signup")
-session.add(event)
-await session.flush()
-print(event.id)  # UUID('019...')
-```
-
-### [`CreatedAtMixin`](../reference/models.md#fastapi_toolsets.models.CreatedAtMixin)
-
-Adds a `created_at: datetime` column set to `clock_timestamp()` 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 `clock_timestamp()` on insert and automatically updated to `clock_timestamp()` 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]
-```
-
-## Lifecycle events
-
-The event system provides lifecycle callbacks that fire **after commit**. If the transaction rolls back, no callback fires.
-
-### Setup
-
-Event dispatch requires [`EventSession`](../reference/models.md#fastapi_toolsets.models.EventSession). Pass it as the session class when creating your session factory:
-
-```python
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from fastapi_toolsets.models import EventSession
-
-engine = create_async_engine("postgresql+asyncpg://...")
-SessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=EventSession)
-```
-
-!!! info "Callbacks fire on `session.commit()` only — not on savepoints."
-    Savepoints created by [`get_transaction`](db.md) or `begin_nested()` do **not**
-    trigger callbacks. All events accumulated across flushes are dispatched once
-    when the outermost `commit()` is called.
-
-### Events
-
-Three event types are available, each corresponding to a [`ModelEvent`](../reference/models.md#fastapi_toolsets.models.ModelEvent) value:
-
-| Event | Trigger |
-|---|---|
-| `ModelEvent.CREATE` | After `INSERT` commit |
-| `ModelEvent.DELETE` | After `DELETE` commit |
-| `ModelEvent.UPDATE` | After `UPDATE` commit on a watched field |
-
-!!! warning "Callbacks fire only for ORM-level changes. Rows updated via raw SQL (`UPDATE ... SET ...`) are not detected."
-
-### Watched fields
-
-Set `__watched_fields__` on the model to restrict which field changes trigger `UPDATE` events. It must be a `tuple[str, ...]` — any other type raises `TypeError`:
-
-| Class attribute | `UPDATE` behaviour |
-|---|---|
-| `__watched_fields__ = ("status", "role")` | Only fires when `status` or `role` changes |
-| *(not set)* | Fires when **any** mapped field changes |
-
-`__watched_fields__` is inherited through the class hierarchy via normal Python MRO. A subclass can override it:
-
-```python
-class Order(Base, UUIDMixin):
-    __watched_fields__ = ("status",)
-    ...
-
-class UrgentOrder(Order):
-    # inherits __watched_fields__ = ("status",)
-    ...
-
-class PriorityOrder(Order):
-    __watched_fields__ = ("priority",)
-    # overrides parent — UPDATE fires only for priority changes
-    ...
-```
-
-### Registering handlers
-
-Register handlers with the [`listens_for`](../reference/models.md#fastapi_toolsets.models.listens_for) decorator. Every callback receives three arguments: the model instance, the [`ModelEvent`](../reference/models.md#fastapi_toolsets.models.ModelEvent) that triggered it, and a `changes` dict (`None` for `CREATE` and `DELETE`):
-
-```python
-from fastapi_toolsets.models import ModelEvent, UUIDMixin, listens_for
-
-class Order(Base, UUIDMixin):
-    __tablename__ = "orders"
-    __watched_fields__ = ("status",)
-
-    status: Mapped[str]
-
-@listens_for(Order, [ModelEvent.CREATE])
-async def on_order_created(order: Order, event_type: ModelEvent, changes: None):
-    await notify_new_order(order.id)
-
-@listens_for(Order, [ModelEvent.DELETE])
-async def on_order_deleted(order: Order, event_type: ModelEvent, changes: None):
-    await notify_order_cancelled(order.id)
-
-@listens_for(Order, [ModelEvent.UPDATE])
-async def on_order_updated(order: Order, event_type: ModelEvent, changes: dict):
-    if "status" in changes:
-        await notify_status_change(order.id, changes["status"])
-```
-
-Multiple handlers can be registered for the same model and event. Handlers registered on a parent class also fire for subclass instances.
-
-A single handler can listen for multiple events at once. When `event_types` is omitted, the handler fires for all events:
-
-```python
-@listens_for(Order, [ModelEvent.CREATE, ModelEvent.UPDATE])
-async def on_order_changed(order: Order, event_type: ModelEvent, changes: dict | None):
-    await invalidate_cache(order.id)
-
-@listens_for(Order)  # all events
-async def on_any_order_event(order: Order, event_type: ModelEvent, changes: dict | None):
-    await audit_log(order.id, event_type)
-```
-
-### Field changes format
-
-The `changes` dict maps each watched field that changed to `{"old": ..., "new": ...}`. Only fields that actually changed are included. For `CREATE` and `DELETE` events, `changes` is `None`:
-
-```python
-# CREATE / DELETE → changes is None
-# status changed   → {"status": {"old": "pending", "new": "shipped"}}
-# two fields changed → {"status": {...}, "assigned_to": {...}}
-```
-
-!!! info "Multiple flushes in one transaction are merged: the earliest `old` and latest `new` are preserved, and `on_update` fires only once per commit."
-
---
-
-[:material-api: API Reference](../reference/models.md)
@@ -1,95 +0,0 @@
-# Pytest
-
-Testing helpers for FastAPI applications with async client, database sessions, and parallel worker support.
-
-## Installation
-
-=== "uv"
-    ``` bash
-    uv add "fastapi-toolsets[pytest]"
-    ```
-
-=== "pip"
-    ``` bash
-    pip install "fastapi-toolsets[pytest]"
-    ```
-
-## Overview
-
-The `pytest` module provides utilities for setting up async test clients, managing test database sessions, and supporting parallel test execution with `pytest-xdist`.
-
-## Creating an async client
-
-Use [`create_async_client`](../reference/pytest.md#fastapi_toolsets.pytest.utils.create_async_client) to get an `httpx.AsyncClient` configured for your FastAPI app:
-
-```python
-from fastapi_toolsets.pytest import create_async_client
-
-@pytest.fixture
-async def http_client(db_session):
-    async def _override_get_db():
-        yield db_session
-
-    async with create_async_client(
-        app=app,
-        base_url="http://127.0.0.1/api/v1",
-        dependency_overrides={get_db: _override_get_db},
-    ) as c:
-        yield c
-```
-
-## 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:
-
-```python
-from fastapi_toolsets.pytest import create_worker_database, create_db_session
-
-@pytest.fixture(scope="session")
-async def worker_db_url():
-    async with create_worker_database(
-        database_url=str(settings.SQLALCHEMY_DATABASE_URI)
-    ) as url:
-        yield url
-
-
-@pytest.fixture
-async def db_session(worker_db_url):
-    async with create_db_session(
-        database_url=worker_db_url, base=Base, cleanup=True
-    ) as session:
-        yield session
-```
-
-!!! 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
-
-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:
-
-```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/pytest.md)
@@ -1,140 +0,0 @@
-# Schemas
-
-Standardized Pydantic response models for consistent API responses across your FastAPI application.
-
-## Overview
-
-The `schemas` module provides generic response wrappers that enforce a uniform response structure. All models use `from_attributes=True` for ORM compatibility and `validate_assignment=True` for runtime type safety.
-
-## Response models
-
-### [`Response[T]`](../reference/schemas.md#fastapi_toolsets.schemas.Response)
-
-The most common wrapper for a single resource response.
-
-```python
-from fastapi_toolsets.schemas import Response
-
-@router.get("/users/{id}")
-async def get_user(user: User = UserDep) -> Response[UserSchema]:
-    return Response(data=user, message="User retrieved")
-```
-
-### Paginated response models
-
-Three classes wrap paginated list results. Pick the one that matches your endpoint's strategy:
-
-| Class | `pagination` type | `pagination_type` field | Use when |
-|---|---|---|---|
-| [`OffsetPaginatedResponse[T]`](#offsetpaginatedresponset) | `OffsetPagination` | `"offset"` (fixed) | endpoint always uses offset |
-| [`CursorPaginatedResponse[T]`](#cursorpaginatedresponset) | `CursorPagination` | `"cursor"` (fixed) | endpoint always uses cursor |
-| [`PaginatedResponse[T]`](#paginatedresponset) | `OffsetPagination \| CursorPagination` | — | unified endpoint supporting both strategies |
-
-#### [`OffsetPaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPaginatedResponse)
-
-!!! info "Added in `v2.3.0`"
-
-Use as the return type when the endpoint always uses [`offset_paginate`](crud.md#offset-pagination).  The `pagination` field is guaranteed to be an [`OffsetPagination`](../reference/schemas.md#fastapi_toolsets.schemas.OffsetPagination) object; the response always includes a `pagination_type: "offset"` discriminator.
-
-```python
-from fastapi_toolsets.schemas import OffsetPaginatedResponse
-
-@router.get("/users")
-async def list_users(
-    page: int = 1,
-    items_per_page: int = 20,
-) -> OffsetPaginatedResponse[UserSchema]:
-    return await UserCrud.offset_paginate(
-        session, page=page, items_per_page=items_per_page, schema=UserSchema
-    )
-```
-
-**Response shape:**
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "offset",
-  "data": ["..."],
-  "pagination": {
-    "total_count": 100,
-    "page": 1,
-    "items_per_page": 20,
-    "has_more": true
-  }
-}
-```
-
-#### [`CursorPaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPaginatedResponse)
-
-!!! info "Added in `v2.3.0`"
-
-Use as the return type when the endpoint always uses [`cursor_paginate`](crud.md#cursor-pagination).  The `pagination` field is guaranteed to be a [`CursorPagination`](../reference/schemas.md#fastapi_toolsets.schemas.CursorPagination) object; the response always includes a `pagination_type: "cursor"` discriminator.
-
-```python
-from fastapi_toolsets.schemas import CursorPaginatedResponse
-
-@router.get("/events")
-async def list_events(
-    cursor: str | None = None,
-    items_per_page: int = 20,
-) -> CursorPaginatedResponse[EventSchema]:
-    return await EventCrud.cursor_paginate(
-        session, cursor=cursor, items_per_page=items_per_page, schema=EventSchema
-    )
-```
-
-**Response shape:**
-
-```json
-{
-  "status": "SUCCESS",
-  "pagination_type": "cursor",
-  "data": ["..."],
-  "pagination": {
-    "next_cursor": "eyJpZCI6IDQyfQ==",
-    "prev_cursor": null,
-    "items_per_page": 20,
-    "has_more": true
-  }
-}
-```
-
-#### [`PaginatedResponse[T]`](../reference/schemas.md#fastapi_toolsets.schemas.PaginatedResponse)
-
-Return type for endpoints that support **both** pagination strategies via a `pagination_type` query parameter (using [`paginate()`](crud.md#unified-paginate--both-strategies-on-one-endpoint)).
-
-When used as a return annotation, `PaginatedResponse[T]` automatically expands to `Annotated[Union[CursorPaginatedResponse[T], OffsetPaginatedResponse[T]], Field(discriminator="pagination_type")]`, so FastAPI emits a proper `oneOf` + discriminator in the OpenAPI schema with no extra boilerplate:
-
-```python
-from fastapi_toolsets.crud import PaginationType
-from fastapi_toolsets.schemas import PaginatedResponse
-
-@router.get("/users")
-async def list_users(
-    pagination_type: PaginationType = PaginationType.OFFSET,
-    page: int = 1,
-    cursor: str | None = None,
-    items_per_page: int = 20,
-) -> PaginatedResponse[UserSchema]:
-    return await UserCrud.paginate(
-        session,
-        pagination_type=pagination_type,
-        page=page,
-        cursor=cursor,
-        items_per_page=items_per_page,
-        schema=UserSchema,
-    )
-```
-
-#### Pagination metadata models
-
-The optional `filter_attributes` field is populated when `facet_fields` are configured on the CRUD class (see [Filter attributes](crud.md#filter-attributes-facets)). It is `None` by default and can be hidden from API responses with `response_model_exclude_none=True`.
-
-### [`ErrorResponse`](../reference/schemas.md#fastapi_toolsets.schemas.ErrorResponse)
-
-Returned automatically by the exceptions handler.
-
---
-
-[:material-api: API Reference](../reference/schemas.md)
@@ -1,27 +0,0 @@
-# `cli`
-
-Here's the reference for the CLI configuration helpers used to load settings from `pyproject.toml`.
-
-You can import them directly from `fastapi_toolsets.cli.config`:
-
-```python
-from fastapi_toolsets.cli.config import (
-    import_from_string,
-    get_config_value,
-    get_fixtures_registry,
-    get_db_context,
-    get_custom_cli,
-)
-```
-
-## ::: fastapi_toolsets.cli.config.import_from_string
-
-## ::: fastapi_toolsets.cli.config.get_config_value
-
-## ::: fastapi_toolsets.cli.config.get_fixtures_registry
-
-## ::: fastapi_toolsets.cli.config.get_db_context
-
-## ::: fastapi_toolsets.cli.config.get_custom_cli
-
-## ::: fastapi_toolsets.cli.utils.async_command
@@ -1,20 +0,0 @@
-# `crud`
-
-Here's the reference for the CRUD classes, factory, and search utilities.
-
-You can import the main symbols from `fastapi_toolsets.crud`:
-
-```python
-from fastapi_toolsets.crud import CrudFactory, AsyncCrud
-from fastapi_toolsets.crud.search import SearchConfig, get_searchable_fields, build_search_filters
-```
-
-## ::: fastapi_toolsets.crud.factory.AsyncCrud
-
-## ::: fastapi_toolsets.crud.factory.CrudFactory
-
-## ::: fastapi_toolsets.crud.search.SearchConfig
-
-## ::: fastapi_toolsets.crud.search.get_searchable_fields
-
-## ::: fastapi_toolsets.crud.search.build_search_filters
@@ -1,43 +0,0 @@
-# `db`
-
-Here's the reference for all database session utilities, transaction helpers, and locking functions.
-
-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,
-    lock_tables,
-    m2m_add,
-    m2m_remove,
-    m2m_set,
-    wait_for_row_change,
-)
-```
-
-## ::: fastapi_toolsets.db.LockMode
-
-## ::: fastapi_toolsets.db.create_db_dependency
-
-## ::: fastapi_toolsets.db.create_db_context
-
-## ::: fastapi_toolsets.db.get_transaction
-
-## ::: fastapi_toolsets.db.lock_tables
-
-## ::: fastapi_toolsets.db.wait_for_row_change
-
-## ::: fastapi_toolsets.db.create_database
-
-## ::: fastapi_toolsets.db.cleanup_tables
-
-## ::: fastapi_toolsets.db.m2m_add
-
-## ::: fastapi_toolsets.db.m2m_remove
-
-## ::: fastapi_toolsets.db.m2m_set
@@ -1,13 +0,0 @@
-# `dependencies`
-
-Here's the reference for the FastAPI dependency factory functions.
-
-You can import them directly from `fastapi_toolsets.dependencies`:
-
-```python
-from fastapi_toolsets.dependencies import PathDependency, BodyDependency
-```
-
-## ::: fastapi_toolsets.dependencies.PathDependency
-
-## ::: fastapi_toolsets.dependencies.BodyDependency
@@ -1,40 +0,0 @@
-# `exceptions`
-
-Here's the reference for all exception classes and handler utilities.
-
-You can import them directly from `fastapi_toolsets.exceptions`:
-
-```python
-from fastapi_toolsets.exceptions import (
-    ApiException,
-    UnauthorizedError,
-    ForbiddenError,
-    NotFoundError,
-    ConflictError,
-    NoSearchableFieldsError,
-    InvalidFacetFilterError,
-    InvalidOrderFieldError,
-    generate_error_responses,
-    init_exceptions_handlers,
-)
-```
-
-## ::: fastapi_toolsets.exceptions.exceptions.ApiException
-
-## ::: fastapi_toolsets.exceptions.exceptions.UnauthorizedError
-
-## ::: fastapi_toolsets.exceptions.exceptions.ForbiddenError
-
-## ::: fastapi_toolsets.exceptions.exceptions.NotFoundError
-
-## ::: fastapi_toolsets.exceptions.exceptions.ConflictError
-
-## ::: fastapi_toolsets.exceptions.exceptions.NoSearchableFieldsError
-
-## ::: fastapi_toolsets.exceptions.exceptions.InvalidFacetFilterError
-
-## ::: fastapi_toolsets.exceptions.exceptions.InvalidOrderFieldError
-
-## ::: fastapi_toolsets.exceptions.exceptions.generate_error_responses
-
-## ::: fastapi_toolsets.exceptions.handler.init_exceptions_handlers
@@ -1,31 +0,0 @@
-# `fixtures`
-
-Here's the reference for the fixture registry, enums, and loading utilities.
-
-You can import them directly from `fastapi_toolsets.fixtures`:
-
-```python
-from fastapi_toolsets.fixtures import (
-    Context,
-    LoadStrategy,
-    Fixture,
-    FixtureRegistry,
-    load_fixtures,
-    load_fixtures_by_context,
-    get_obj_by_attr,
-)
-```
-
-## ::: fastapi_toolsets.fixtures.enum.Context
-
-## ::: fastapi_toolsets.fixtures.enum.LoadStrategy
-
-## ::: fastapi_toolsets.fixtures.registry.Fixture
-
-## ::: fastapi_toolsets.fixtures.registry.FixtureRegistry
-
-## ::: fastapi_toolsets.fixtures.utils.load_fixtures
-
-## ::: fastapi_toolsets.fixtures.utils.load_fixtures_by_context
-
-## ::: fastapi_toolsets.fixtures.utils.get_obj_by_attr
@@ -1,13 +0,0 @@
-# `logger`
-
-Here's the reference for the logging utilities.
-
-You can import them directly from `fastapi_toolsets.logger`:
-
-```python
-from fastapi_toolsets.logger import configure_logging, get_logger
-```
-
-## ::: fastapi_toolsets.logger.configure_logging
-
-## ::: fastapi_toolsets.logger.get_logger
@@ -1,15 +0,0 @@
-# `metrics`
-
-Here's the reference for the Prometheus metrics registry and endpoint handler.
-
-You can import them directly from `fastapi_toolsets.metrics`:
-
-```python
-from fastapi_toolsets.metrics import Metric, MetricsRegistry, init_metrics
-```
-
-## ::: fastapi_toolsets.metrics.registry.Metric
-
-## ::: fastapi_toolsets.metrics.registry.MetricsRegistry
-
-## ::: fastapi_toolsets.metrics.handler.init_metrics
@@ -1,34 +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 (
-    EventSession,
-    ModelEvent,
-    UUIDMixin,
-    UUIDv7Mixin,
-    CreatedAtMixin,
-    UpdatedAtMixin,
-    TimestampMixin,
-    listens_for,
-)
-```
-
-## ::: fastapi_toolsets.models.EventSession
-
-## ::: fastapi_toolsets.models.ModelEvent
-
-## ::: fastapi_toolsets.models.UUIDMixin
-
-## ::: fastapi_toolsets.models.UUIDv7Mixin
-
-## ::: fastapi_toolsets.models.CreatedAtMixin
-
-## ::: fastapi_toolsets.models.UpdatedAtMixin
-
-## ::: fastapi_toolsets.models.TimestampMixin
-
-## ::: fastapi_toolsets.models.listens_for
@@ -1,26 +0,0 @@
-# `pytest`
-
-Here's the reference for all testing utilities and pytest fixtures.
-
-You can import them directly from `fastapi_toolsets.pytest`:
-
-```python
-from fastapi_toolsets.pytest import (
-    register_fixtures,
-    create_async_client,
-    create_db_session,
-    worker_database_url,
-    create_worker_database,
-    cleanup_tables,
-)
-```
-
-## ::: fastapi_toolsets.pytest.plugin.register_fixtures
-
-## ::: fastapi_toolsets.pytest.utils.create_async_client
-
-## ::: fastapi_toolsets.pytest.utils.create_db_session
-
-## ::: fastapi_toolsets.pytest.utils.worker_database_url
-
-## ::: fastapi_toolsets.pytest.utils.create_worker_database
@@ -1,46 +0,0 @@
-# `schemas`
-
-Here's the reference for all response models and types provided by the `schemas` module.
-
-You can import them directly from `fastapi_toolsets.schemas`:
-
-```python
-from fastapi_toolsets.schemas import (
-    PydanticBase,
-    ResponseStatus,
-    ApiError,
-    BaseResponse,
-    Response,
-    ErrorResponse,
-    OffsetPagination,
-    CursorPagination,
-    PaginationType,
-    PaginatedResponse,
-    OffsetPaginatedResponse,
-    CursorPaginatedResponse,
-)
-```
-
-## ::: fastapi_toolsets.schemas.PydanticBase
-
-## ::: fastapi_toolsets.schemas.ResponseStatus
-
-## ::: fastapi_toolsets.schemas.ApiError
-
-## ::: fastapi_toolsets.schemas.BaseResponse
-
-## ::: fastapi_toolsets.schemas.Response
-
-## ::: fastapi_toolsets.schemas.ErrorResponse
-
-## ::: fastapi_toolsets.schemas.OffsetPagination
-
-## ::: fastapi_toolsets.schemas.CursorPagination
-
-## ::: fastapi_toolsets.schemas.PaginationType
-
-## ::: fastapi_toolsets.schemas.PaginatedResponse
-
-## ::: fastapi_toolsets.schemas.OffsetPaginatedResponse
-
-## ::: fastapi_toolsets.schemas.CursorPaginatedResponse
@@ -1,9 +0,0 @@
-from fastapi import FastAPI
-
-from fastapi_toolsets.exceptions import init_exceptions_handlers
-
-from .routes import router
-
-app = FastAPI()
-init_exceptions_handlers(app=app)
-app.include_router(router=router)
@@ -1,21 +0,0 @@
-from fastapi_toolsets.crud import CrudFactory
-
-from .models import Article, Category
-
-ArticleCrud = CrudFactory(
-    model=Article,
-    cursor_column=Article.created_at,
-    searchable_fields=[  # default fields for full-text search
-        Article.title,
-        Article.body,
-        (Article.category, Category.name),
-    ],
-    facet_fields=[  # fields exposed as filter dropdowns
-        Article.status,
-        (Article.category, Category.name),
-    ],
-    order_fields=[  # fields exposed for client-driven ordering
-        Article.title,
-        Article.created_at,
-    ],
-)
@@ -1,17 +0,0 @@
-from typing import Annotated
-
-from fastapi import Depends
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-
-from fastapi_toolsets.db import create_db_context, create_db_dependency
-
-DATABASE_URL = "postgresql+asyncpg://postgres:postgres@localhost:5432/postgres"
-
-engine = create_async_engine(url=DATABASE_URL, future=True)
-async_session_maker = async_sessionmaker(bind=engine, expire_on_commit=False)
-
-get_db = create_db_dependency(session_maker=async_session_maker)
-get_db_context = create_db_context(session_maker=async_session_maker)
-
-
-SessionDep = Annotated[AsyncSession, Depends(get_db)]
@@ -1,34 +0,0 @@
-import uuid
-
-from sqlalchemy import Boolean, ForeignKey, String, Text
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
-
-from fastapi_toolsets.models import CreatedAtMixin
-
-
-class Base(DeclarativeBase):
-    pass
-
-
-class Category(Base):
-    __tablename__ = "categories"
-
-    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(64), unique=True)
-
-    articles: Mapped[list["Article"]] = relationship(back_populates="category")
-
-
-class Article(Base, CreatedAtMixin):
-    __tablename__ = "articles"
-
-    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
-    title: Mapped[str] = mapped_column(String(256))
-    body: Mapped[str] = mapped_column(Text)
-    status: Mapped[str] = mapped_column(String(32))
-    published: Mapped[bool] = mapped_column(Boolean, default=False)
-    category_id: Mapped[uuid.UUID | None] = mapped_column(
-        ForeignKey("categories.id"), nullable=True
-    )
-
-    category: Mapped["Category | None"] = relationship(back_populates="articles")
@@ -1,79 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends
-
-from fastapi_toolsets.schemas import (
-    CursorPaginatedResponse,
-    OffsetPaginatedResponse,
-    PaginatedResponse,
-)
-
-from .crud import ArticleCrud
-from .db import SessionDep
-from .models import Article
-from .schemas import ArticleRead
-
-router = APIRouter(prefix="/articles")
-
-
-@router.get("/offset")
-async def list_articles_offset(
-    session: SessionDep,
-    params: Annotated[
-        dict,
-        Depends(
-            ArticleCrud.offset_paginate_params(
-                default_page_size=20,
-                max_page_size=100,
-                default_order_field=Article.created_at,
-            )
-        ),
-    ],
-) -> OffsetPaginatedResponse[ArticleRead]:
-    return await ArticleCrud.offset_paginate(
-        session=session,
-        **params,
-        schema=ArticleRead,
-    )
-
-
-@router.get("/cursor")
-async def list_articles_cursor(
-    session: SessionDep,
-    params: Annotated[
-        dict,
-        Depends(
-            ArticleCrud.cursor_paginate_params(
-                default_page_size=20,
-                max_page_size=100,
-                default_order_field=Article.created_at,
-            )
-        ),
-    ],
-) -> CursorPaginatedResponse[ArticleRead]:
-    return await ArticleCrud.cursor_paginate(
-        session=session,
-        **params,
-        schema=ArticleRead,
-    )
-
-
-@router.get("/")
-async def list_articles(
-    session: SessionDep,
-    params: Annotated[
-        dict,
-        Depends(
-            ArticleCrud.paginate_params(
-                default_page_size=20,
-                max_page_size=100,
-                default_order_field=Article.created_at,
-            )
-        ),
-    ],
-) -> PaginatedResponse[ArticleRead]:
-    return await ArticleCrud.paginate(
-        session,
-        **params,
-        schema=ArticleRead,
-    )
@@ -1,13 +0,0 @@
-import datetime
-import uuid
-
-from fastapi_toolsets.schemas import PydanticBase
-
-
-class ArticleRead(PydanticBase):
-    id: uuid.UUID
-    created_at: datetime.datetime
-    title: str
-    status: str
-    published: bool
-    category_id: uuid.UUID | None
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Redirecting</title>
+  <noscript>
+    <meta http-equiv="refresh" content="1; url=stable/" />
+  </noscript>
+  <script>
+    window.location.replace(
+      "stable/" + window.location.search + window.location.hash
+    );
+  </script>
+</head>
+<body>
+  Redirecting to <a href="stable/">stable/</a>...
+</body>
+</html>
@@ -1,110 +0,0 @@
-[project]
-name = "fastapi-toolsets"
-version = "3.1.1"
-description = "Production-ready utilities for FastAPI applications"
-readme = "README.md"
-license = "MIT"
-license-files = ["LICENSE"]
-requires-python = ">=3.11"
-authors = [
-    { name = "d3vyce", email = "contact@d3vyce.fr" }
-]
-keywords = ["fastapi", "sqlalchemy", "postgresql"]
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Framework :: AsyncIO",
-    "Framework :: FastAPI",
-    "Framework :: Pydantic",
-    "Intended Audience :: Developers",
-    "Intended Audience :: Information Technology",
-    "Intended Audience :: System Administrators",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Software Development :: Libraries",
-    "Topic :: Software Development",
-    "Typing :: Typed",
-]
-dependencies = [
-    "asyncpg>=0.29.0",
-    "fastapi>=0.100.0",
-    "pydantic>=2.0",
-    "sqlalchemy[asyncio]>=2.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/d3vyce/fastapi-toolsets"
-Documentation = "https://fastapi-toolsets.d3vyce.fr/"
-Repository = "https://github.com/d3vyce/fastapi-toolsets"
-Issues = "https://github.com/d3vyce/fastapi-toolsets/issues"
-
-[project.optional-dependencies]
-cli = [
-    "typer>=0.9.0",
-]
-metrics = [
-    "prometheus_client>=0.20.0",
-]
-pytest = [
-    "httpx>=0.25.0",
-    "pytest-xdist>=3.0.0",
-    "pytest>=8.0.0",
-]
-all = [
-    "fastapi-toolsets[cli,metrics,pytest]",
-]
-
-[project.scripts]
-manager = "fastapi_toolsets.cli.app:cli"
-
-[dependency-groups]
-dev = [
-    {include-group = "tests"},
-    {include-group = "docs"},
-    "fastapi-toolsets[all]",
-    "prek>=0.3.8",
-    "ruff>=0.1.0",
-    "ty>=0.0.1a0",
-]
-tests = [
-    "coverage>=7.0.0",
-    "httpx>=0.25.0",
-    "pytest-anyio>=0.0.0",
-    "pytest-cov>=4.0.0",
-    "pytest-xdist>=3.0.0",
-    "pytest>=8.0.0",
-]
-docs = [
-    "mike",
-    "mkdocstrings-python>=2.0.2",
-    "zensical>=0.0.30",
-]
-
-[build-system]
-requires = ["uv_build>=0.10,<0.12.0"]
-build-backend = "uv_build"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-filterwarnings = [
-    "ignore::DeprecationWarning",
-]
-
-[tool.coverage.run]
-source = ["src/fastapi_toolsets"]
-branch = true
-
-[tool.coverage.report]
-exclude_lines = [
-    "pragma: no cover",
-    "if TYPE_CHECKING:",
-    "raise NotImplementedError",
-]
-
-[tool.uv.sources]
-mike = { git = "https://github.com/squidfunk/mike.git", tag = "2.2.0+zensical-0.1.0" }
@@ -1,24 +0,0 @@
-"""FastAPI utilities package.
-
-Provides CRUD operations, fixtures, CLI, and standardized API responses
-for FastAPI with async SQLAlchemy and PostgreSQL.
-
-Example usage:
-    from fastapi import FastAPI, Depends
-    from fastapi_toolsets.exceptions import init_exceptions_handlers
-    from fastapi_toolsets.crud import CrudFactory
-    from fastapi_toolsets.db import create_db_dependency
-    from fastapi_toolsets.schemas import Response
-
-    app = FastAPI()
-    init_exceptions_handlers(app)
-
-    UserCrud = CrudFactory(User)
-
-    @app.get("/users/{user_id}", response_model=Response[dict])
-    async def get_user(user_id: int, session = Depends(get_db)):
-        user = await UserCrud.get(session, [User.id == user_id])
-        return Response(data={"user": user.username}, message="Success")
-"""
-
-__version__ = "3.1.1"
@@ -1,9 +0,0 @@
-"""Optional dependency helpers."""
-
-
-def require_extra(package: str, extra: str) -> None:
-    """Raise *ImportError* with an actionable install instruction."""
-    raise ImportError(
-        f"'{package}' is required to use this module. "
-        f"Install it with: pip install fastapi-toolsets[{extra}]"
-    )
@@ -1,5 +0,0 @@
-"""CLI for FastAPI projects."""
-
-from .utils import async_command
-
-__all__ = ["async_command"]
@@ -1,37 +0,0 @@
-"""Main CLI application."""
-
-try:
-    import typer
-except ImportError:
-    from .._imports import require_extra
-
-    require_extra(package="typer", extra="cli")
-
-from ..logger import configure_logging
-from .config import get_custom_cli
-from .pyproject import load_pyproject
-
-# Use custom CLI if configured, otherwise create default one
-_custom_cli = get_custom_cli()
-
-if _custom_cli is not None:
-    cli = _custom_cli
-else:
-    cli = typer.Typer(
-        name="manager",
-        help="CLI utilities for FastAPI projects.",
-        no_args_is_help=True,
-    )
-
-_config = load_pyproject()
-if _config.get("fixtures") and _config.get("db_context"):
-    from .commands.fixtures import fixture_cli
-
-    cli.add_typer(fixture_cli, name="fixtures")
-
-
-@cli.callback()
-def main(ctx: typer.Context) -> None:
-    """FastAPI utilities CLI."""
-    configure_logging()
-    ctx.ensure_object(dict)
@@ -1 +0,0 @@
-"""Built-in CLI commands."""
@@ -1,100 +0,0 @@
-"""Fixture management commands."""
-
-from typing import Annotated
-
-import typer
-from rich.console import Console
-from rich.table import Table
-
-from ...fixtures import Context, LoadStrategy, load_fixtures_by_context
-from ..config import get_db_context, get_fixtures_registry
-from ..utils import async_command
-
-fixture_cli = typer.Typer(
-    name="fixtures",
-    help="Manage database fixtures.",
-    no_args_is_help=True,
-)
-console = Console()
-
-
-@fixture_cli.command("list")
-def list_fixtures(
-    ctx: typer.Context,
-    context: Annotated[
-        Context | None,
-        typer.Option(
-            "--context",
-            "-c",
-            help="Filter by context.",
-        ),
-    ] = None,
-) -> None:
-    """List all registered fixtures."""
-    registry = get_fixtures_registry()
-    fixtures = registry.get_by_context(context.value) if context else registry.get_all()
-
-    if not fixtures:
-        print("No fixtures found.")
-        return
-
-    table = Table("Name", "Contexts", "Dependencies")
-
-    for fixture in fixtures:
-        contexts = ", ".join(fixture.contexts)
-        deps = ", ".join(fixture.depends_on) if fixture.depends_on else "-"
-        table.add_row(fixture.name, contexts, deps)
-
-    console.print(table)
-    print(f"\nTotal: {len(fixtures)} fixture(s)")
-
-
-@fixture_cli.command("load")
-@async_command
-async def load(
-    ctx: typer.Context,
-    contexts: Annotated[
-        list[Context] | None,
-        typer.Argument(help="Contexts to load."),
-    ] = None,
-    strategy: Annotated[
-        LoadStrategy,
-        typer.Option("--strategy", "-s", help="Load strategy."),
-    ] = LoadStrategy.MERGE,
-    dry_run: Annotated[
-        bool,
-        typer.Option(
-            "--dry-run", "-n", help="Show what would be loaded without loading."
-        ),
-    ] = False,
-) -> None:
-    """Load fixtures into the database."""
-    registry = get_fixtures_registry()
-    db_context = get_db_context()
-
-    context_list = list(contexts) if contexts else [Context.BASE]
-
-    ordered = registry.resolve_context_dependencies(*context_list)
-
-    if not ordered:
-        print("No fixtures to load for the specified context(s).")
-        return
-
-    print(f"\nFixtures to load ({strategy.value} strategy):")
-    for name in ordered:
-        fixture = registry.get(name)
-        instances = list(fixture.func())
-        model_name = type(instances[0]).__name__ if instances else "?"
-        print(f"  - {name}: {len(instances)} {model_name}(s)")
-
-    if dry_run:
-        print("\n[Dry run - no changes made]")
-        return
-
-    async with db_context() as session:
-        result = await load_fixtures_by_context(
-            session, registry, *context_list, strategy=strategy
-        )
-
-    total = sum(len(items) for items in result.values())
-    print(f"\nLoaded {total} record(s) successfully.")
@@ -1,125 +0,0 @@
-"""CLI configuration and dynamic imports."""
-
-from __future__ import annotations
-
-import importlib
-import sys
-from typing import TYPE_CHECKING, Any, Literal, overload
-
-import typer
-
-from .pyproject import find_pyproject, load_pyproject
-
-if TYPE_CHECKING:
-    from ..fixtures import FixtureRegistry
-
-
-def _ensure_project_in_path():
-    """Add project root to sys.path if not installed in editable mode."""
-    pyproject = find_pyproject()
-    if pyproject:
-        project_root = str(pyproject.parent)
-        if project_root not in sys.path:
-            sys.path.insert(0, project_root)
-
-
-def import_from_string(import_path: str) -> Any:
-    """Import an object from a dotted string path.
-
-    Args:
-        import_path: Import path in ``"module.submodule:attribute"`` format
-
-    Returns:
-        The imported attribute
-
-    Raises:
-        typer.BadParameter: If the import path is invalid or import fails
-    """
-    if ":" not in import_path:
-        raise typer.BadParameter(
-            f"Invalid import path '{import_path}'. Expected format: 'module:attribute'"
-        )
-
-    module_path, attr_name = import_path.rsplit(":", 1)
-
-    _ensure_project_in_path()
-
-    try:
-        module = importlib.import_module(module_path)
-    except ImportError as e:
-        raise typer.BadParameter(f"Cannot import module '{module_path}': {e}")
-
-    if not hasattr(module, attr_name):
-        raise typer.BadParameter(
-            f"Module '{module_path}' has no attribute '{attr_name}'"
-        )
-
-    return getattr(module, attr_name)
-
-
-@overload
-def get_config_value(key: str, required: Literal[True]) -> Any: ...  # pragma: no cover
-@overload
-def get_config_value(
-    key: str, required: bool = False
-) -> Any | None: ...  # pragma: no cover
-def get_config_value(key: str, required: bool = False) -> Any | None:
-    """Get a configuration value from pyproject.toml.
-
-    Args:
-        key: The configuration key in [tool.fastapi-toolsets].
-        required: If True, raises an error when the key is missing.
-
-    Returns:
-        The configuration value, or None if not found and not required.
-
-    Raises:
-        typer.BadParameter: If required=True and the key is missing.
-    """
-    config = load_pyproject()
-    value = config.get(key)
-
-    if required and value is None:
-        raise typer.BadParameter(
-            f"No '{key}' configured. "
-            f"Add '{key}' to [tool.fastapi-toolsets] in pyproject.toml."
-        )
-
-    return value
-
-
-def get_fixtures_registry() -> FixtureRegistry:
-    """Import and return the fixtures registry from config."""
-    from ..fixtures import FixtureRegistry
-
-    import_path = get_config_value("fixtures", required=True)
-    registry = import_from_string(import_path)
-
-    if not isinstance(registry, FixtureRegistry):
-        raise typer.BadParameter(
-            f"'fixtures' must be a FixtureRegistry instance, got {type(registry).__name__}"
-        )
-
-    return registry
-
-
-def get_db_context() -> Any:
-    """Import and return the db_context function from config."""
-    import_path = get_config_value("db_context", required=True)
-    return import_from_string(import_path)
-
-
-def get_custom_cli() -> typer.Typer | None:
-    """Import and return the custom CLI Typer instance from config."""
-    import_path = get_config_value("custom_cli")
-    if not import_path:
-        return None
-
-    custom = import_from_string(import_path)
-
-    if not isinstance(custom, typer.Typer):
-        raise typer.BadParameter(
-            f"'custom_cli' must be a Typer instance, got {type(custom).__name__}"
-        )
-
-    return custom
@@ -1,49 +0,0 @@
-"""Pyproject.toml discovery and loading."""
-
-import tomllib
-from pathlib import Path
-
-TOOL_NAME = "fastapi-toolsets"
-
-
-def find_pyproject(start_path: Path | None = None) -> Path | None:
-    """Find pyproject.toml by walking up the directory tree.
-
-    Similar to how pytest, black, and ruff discover their config files.
-
-    Args:
-        start_path: Directory to start searching from. Defaults to cwd.
-
-    Returns:
-        Path to pyproject.toml, or None if not found.
-    """
-    path = (start_path or Path.cwd()).resolve()
-
-    for directory in [path, *path.parents]:
-        pyproject = directory / "pyproject.toml"
-        if pyproject.is_file():
-            return pyproject
-
-    return None
-
-
-def load_pyproject(path: Path | None = None) -> dict:
-    """Load tool configuration from pyproject.toml.
-
-    Args:
-        path: Explicit path to pyproject.toml. If None, searches up from cwd.
-
-    Returns:
-        The [tool.fastapi-toolsets] section as a dict, or empty dict if not found.
-    """
-    pyproject_path = path or find_pyproject()
-
-    if not pyproject_path:
-        return {}
-
-    try:
-        with open(pyproject_path, "rb") as f:
-            data = tomllib.load(f)
-        return data.get("tool", {}).get(TOOL_NAME, {})
-    except (OSError, tomllib.TOMLDecodeError):
-        return {}
@@ -1,29 +0,0 @@
-"""CLI utility functions."""
-
-import asyncio
-import functools
-from collections.abc import Callable, Coroutine
-from typing import Any, ParamSpec, TypeVar
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-def async_command(func: Callable[P, Coroutine[Any, Any, T]]) -> Callable[P, T]:
-    """Decorator to run an async function as a sync CLI command.
-
-    Example:
-        ```python
-        @fixture_cli.command("load")
-        @async_command
-        async def load(ctx: typer.Context) -> None:
-            async with get_db_context() as session:
-                await load_fixtures(session, registry)
-        ```
-    """
-
-    @functools.wraps(func)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-        return asyncio.run(func(*args, **kwargs))
-
-    return wrapper
@@ -1,37 +0,0 @@
-"""Generic async CRUD operations for SQLAlchemy models."""
-
-from ..exceptions import (
-    InvalidFacetFilterError,
-    InvalidSearchColumnError,
-    NoSearchableFieldsError,
-    UnsupportedFacetTypeError,
-)
-from ..schemas import PaginationType
-from ..types import (
-    FacetFieldType,
-    JoinType,
-    M2MFieldType,
-    OrderByClause,
-    OrderFieldType,
-    SearchFieldType,
-)
-from .factory import AsyncCrud, CrudFactory
-from .search import SearchConfig, get_searchable_fields
-
-__all__ = [
-    "AsyncCrud",
-    "CrudFactory",
-    "FacetFieldType",
-    "get_searchable_fields",
-    "InvalidFacetFilterError",
-    "InvalidSearchColumnError",
-    "JoinType",
-    "M2MFieldType",
-    "NoSearchableFieldsError",
-    "OrderByClause",
-    "OrderFieldType",
-    "PaginationType",
-    "SearchConfig",
-    "SearchFieldType",
-    "UnsupportedFacetTypeError",
-]
@@ -1,384 +0,0 @@
-"""Search utilities for AsyncCrud."""
-
-import asyncio
-import functools
-from collections.abc import Sequence
-from dataclasses import dataclass, replace
-from typing import TYPE_CHECKING, Any, Literal
-
-from sqlalchemy import String, and_, func, or_, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase
-from sqlalchemy.orm.attributes import InstrumentedAttribute
-from sqlalchemy.types import (
-    ARRAY,
-    Boolean,
-    Date,
-    DateTime,
-    Enum,
-    Integer,
-    Numeric,
-    Time,
-    Uuid,
-)
-
-from ..exceptions import (
-    InvalidFacetFilterError,
-    InvalidSearchColumnError,
-    NoSearchableFieldsError,
-    UnsupportedFacetTypeError,
-)
-from ..types import FacetFieldType, SearchFieldType
-
-if TYPE_CHECKING:
-    from sqlalchemy.sql.elements import ColumnElement
-
-
-@dataclass
-class SearchConfig:
-    """Advanced search configuration.
-
-    Attributes:
-        query: The search string
-        fields: Fields to search (columns or tuples for relationships)
-        case_sensitive: Case-sensitive search (default: False)
-        match_mode: "any" (OR) or "all" (AND) to combine fields
-    """
-
-    query: str
-    fields: Sequence[SearchFieldType] | None = None
-    case_sensitive: bool = False
-    match_mode: Literal["any", "all"] = "any"
-
-
-@functools.lru_cache(maxsize=128)
-def get_searchable_fields(
-    model: type[DeclarativeBase],
-    *,
-    include_relationships: bool = True,
-    max_depth: int = 1,
-) -> list[SearchFieldType]:
-    """Auto-detect String fields on a model and its relationships.
-
-    Args:
-        model: SQLAlchemy model class
-        include_relationships: Include fields from many-to-one/one-to-one relationships
-        max_depth: Max depth for relationship traversal (default: 1)
-
-    Returns:
-        List of columns and tuples (relationship, column)
-    """
-    fields: list[SearchFieldType] = []
-    mapper = model.__mapper__
-
-    # Direct String columns
-    for col in mapper.columns:
-        if isinstance(col.type, String):
-            fields.append(getattr(model, col.key))
-
-    # Relationships (one-to-one, many-to-one only)
-    if include_relationships and max_depth > 0:
-        for rel_name, rel_prop in mapper.relationships.items():
-            if rel_prop.uselist:  # Skip collections (one-to-many, many-to-many)
-                continue
-
-            rel_attr = getattr(model, rel_name)
-            related_model = rel_prop.mapper.class_
-
-            for col in related_model.__mapper__.columns:
-                if isinstance(col.type, String):
-                    fields.append((rel_attr, getattr(related_model, col.key)))
-
-    return fields
-
-
-def build_search_filters(
-    model: type[DeclarativeBase],
-    search: str | SearchConfig,
-    search_fields: Sequence[SearchFieldType] | None = None,
-    default_fields: Sequence[SearchFieldType] | None = None,
-    search_column: str | None = None,
-) -> tuple[list["ColumnElement[bool]"], list[InstrumentedAttribute[Any]]]:
-    """Build SQLAlchemy filter conditions for search.
-
-    Args:
-        model: SQLAlchemy model class
-        search: Search string or SearchConfig
-        search_fields: Fields specified per-call (takes priority)
-        default_fields: Default fields (from ClassVar)
-        search_column: Optional key to narrow search to a single field.
-            Must match one of the resolved search field keys.
-
-    Returns:
-        Tuple of (filter_conditions, joins_needed)
-
-    Raises:
-        NoSearchableFieldsError: If no searchable field has been configured
-    """
-    # Normalize input
-    if isinstance(search, str):
-        config = SearchConfig(query=search, fields=search_fields)
-    else:
-        config = (
-            replace(search, fields=search_fields)
-            if search_fields is not None
-            else search
-        )
-
-    if not config.query or not config.query.strip():
-        return [], []
-
-    # Determine which fields to search
-    fields = config.fields or default_fields or get_searchable_fields(model)
-
-    if not fields:
-        raise NoSearchableFieldsError(model)
-
-    # Narrow to a single column when search_column is specified
-    if search_column is not None:
-        keys = search_field_keys(fields)
-        index = {k: f for k, f in zip(keys, fields)}
-        if search_column not in index:
-            raise InvalidSearchColumnError(search_column, sorted(index))
-        fields = [index[search_column]]
-
-    query = config.query.strip()
-    filters: list[ColumnElement[bool]] = []
-    joins: list[InstrumentedAttribute[Any]] = []
-    added_joins: set[str] = set()
-
-    for field in fields:
-        if isinstance(field, tuple):
-            # Relationship: (User.role, Role.name) or deeper
-            for rel in field[:-1]:
-                rel_key = str(rel)
-                if rel_key not in added_joins:
-                    joins.append(rel)
-                    added_joins.add(rel_key)
-            column = field[-1]
-        else:
-            column = field
-
-        # Build the filter (cast to String for non-text columns)
-        column_as_string = column.cast(String)
-        if config.case_sensitive:
-            filters.append(column_as_string.like(f"%{query}%"))
-        else:
-            filters.append(column_as_string.ilike(f"%{query}%"))
-
-    if not filters:  # pragma: no cover
-        return [], []
-
-    # Combine based on match_mode
-    if config.match_mode == "any":
-        return [or_(*filters)], joins
-    else:
-        return filters, joins
-
-
-def search_field_keys(fields: Sequence[SearchFieldType]) -> list[str]:
-    """Return a human-readable key for each search field."""
-    return facet_keys(fields)
-
-
-def facet_keys(facet_fields: Sequence[FacetFieldType]) -> list[str]:
-    """Return a key for each facet field.
-
-    Args:
-        facet_fields: Sequence of facet fields — either direct columns or
-            relationship tuples ``(rel, ..., column)``.
-
-    Returns:
-        A list of string keys, one per facet field, in the same order.
-    """
-    keys: list[str] = []
-    for field in facet_fields:
-        if isinstance(field, tuple):
-            keys.append("__".join(el.key for el in field))
-        else:
-            keys.append(field.key)
-    return keys
-
-
-async def build_facets(
-    session: "AsyncSession",
-    model: type[DeclarativeBase],
-    facet_fields: Sequence[FacetFieldType],
-    *,
-    base_filters: "list[ColumnElement[bool]] | None" = None,
-    base_joins: list[InstrumentedAttribute[Any]] | None = None,
-) -> dict[str, list[Any]]:
-    """Return distinct values for each facet field, respecting current filters.
-
-    Args:
-        session: DB async session
-        model: SQLAlchemy model class
-        facet_fields: Columns or relationship tuples to facet on
-        base_filters: Filter conditions already applied to the main query (search + caller filters)
-        base_joins: Relationship joins already applied to the main query
-
-    Returns:
-        Dict mapping column key to sorted list of distinct non-None values
-    """
-    existing_join_keys: set[str] = {str(j) for j in (base_joins or [])}
-
-    keys = facet_keys(facet_fields)
-
-    async def _query_facet(field: FacetFieldType, key: str) -> tuple[str, list[Any]]:
-        if isinstance(field, tuple):
-            # Relationship chain: (User.role, Role.name) — last element is the column
-            rels = field[:-1]
-            column = field[-1]
-        else:
-            rels = ()
-            column = field
-
-        col_type = column.property.columns[0].type
-        is_array = isinstance(col_type, ARRAY)
-
-        if is_array:
-            unnested = func.unnest(column).label(column.key)
-            q = select(unnested).select_from(model).distinct()
-        else:
-            q = select(column).select_from(model).distinct()
-
-        # Apply base joins (deduplicated) — needed here independently
-        seen_joins: set[str] = set()
-        for rel in base_joins or []:
-            rel_key = str(rel)
-            if rel_key not in seen_joins:
-                seen_joins.add(rel_key)
-                q = q.outerjoin(rel)
-
-        # Add any extra joins required by this facet field that aren't already applied
-        for rel in rels:
-            rel_key = str(rel)
-            if rel_key not in existing_join_keys and rel_key not in seen_joins:
-                seen_joins.add(rel_key)
-                q = q.outerjoin(rel)
-
-        if base_filters:
-            q = q.where(and_(*base_filters))
-
-        if is_array:
-            q = q.order_by(unnested)
-        else:
-            q = q.order_by(column)
-        result = await session.execute(q)
-        col_type = column.property.columns[0].type
-        enum_class = getattr(col_type, "enum_class", None)
-        values = [
-            row[0].name
-            if (enum_class is not None and isinstance(row[0], enum_class))
-            else row[0]
-            for row in result.all()
-            if row[0] is not None
-        ]
-        return key, values
-
-    pairs = await asyncio.gather(
-        *[_query_facet(f, k) for f, k in zip(facet_fields, keys)]
-    )
-    return dict(pairs)
-
-
-_EQUALITY_TYPES = (String, Integer, Numeric, Date, DateTime, Time, Enum, Uuid)
-"""Column types that support equality / IN filtering in build_filter_by."""
-
-
-def _coerce_bool(value: Any) -> bool:
-    """Coerce a string value to a Python bool for Boolean column filtering."""
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, str):
-        if value.lower() == "true":
-            return True
-        if value.lower() == "false":
-            return False
-    raise ValueError(f"Cannot coerce {value!r} to bool")
-
-
-def build_filter_by(
-    filter_by: dict[str, Any],
-    facet_fields: Sequence[FacetFieldType],
-) -> tuple["list[ColumnElement[bool]]", list[InstrumentedAttribute[Any]]]:
-    """Translate a {column_key: value} dict into SQLAlchemy filter conditions.
-
-    Args:
-        filter_by: Mapping of column key to scalar value or list of values
-        facet_fields: Declared facet fields to validate keys against
-
-    Returns:
-        Tuple of (filter_conditions, joins_needed)
-
-    Raises:
-        InvalidFacetFilterError: If a key in filter_by is not a declared facet field
-    """
-    index: dict[
-        str, tuple[InstrumentedAttribute[Any], list[InstrumentedAttribute[Any]]]
-    ] = {}
-    for key, field in zip(facet_keys(facet_fields), facet_fields):
-        if isinstance(field, tuple):
-            rels = list(field[:-1])
-            column = field[-1]
-        else:
-            rels = []
-            column = field
-        index[key] = (column, rels)
-
-    valid_keys = set(index)
-    filters: list[ColumnElement[bool]] = []
-    joins: list[InstrumentedAttribute[Any]] = []
-    added_join_keys: set[str] = set()
-
-    for key, value in filter_by.items():
-        if key not in index:
-            raise InvalidFacetFilterError(key, valid_keys)
-
-        column, rels = index[key]
-
-        for rel in rels:
-            rel_key = str(rel)
-            if rel_key not in added_join_keys:
-                joins.append(rel)
-                added_join_keys.add(rel_key)
-
-        col_type = column.property.columns[0].type
-        if isinstance(col_type, Boolean):
-            coerce = _coerce_bool
-            if isinstance(value, list):
-                filters.append(column.in_([coerce(v) for v in value]))
-            else:
-                filters.append(column == coerce(value))
-        elif isinstance(col_type, ARRAY):
-            if isinstance(value, list):
-                filters.append(column.overlap(value))
-            else:
-                filters.append(column.any(value))
-        elif isinstance(col_type, Enum):
-            enum_class = col_type.enum_class
-            if enum_class is not None:
-
-                def _coerce_enum(v: Any) -> Any:
-                    if isinstance(v, enum_class):
-                        return v
-                    return enum_class[v]  # lookup by name: "PENDING", "RED"
-
-                if isinstance(value, list):
-                    filters.append(column.in_([_coerce_enum(v) for v in value]))
-                else:
-                    filters.append(column == _coerce_enum(value))
-            else:  # pragma: no cover
-                if isinstance(value, list):
-                    filters.append(column.in_(value))
-                else:
-                    filters.append(column == value)
-        elif isinstance(col_type, _EQUALITY_TYPES):
-            if isinstance(value, list):
-                filters.append(column.in_(value))
-            else:
-                filters.append(column == value)
-        else:
-            raise UnsupportedFacetTypeError(key, type(col_type).__name__)
-
-    return filters, joins
@@ -1,483 +0,0 @@
-"""Database utilities: sessions, transactions, and locks."""
-
-import asyncio
-from collections.abc import AsyncGenerator, Callable
-from contextlib import AbstractAsyncContextManager, asynccontextmanager
-from enum import Enum
-from typing import Any, TypeVar, cast
-
-from sqlalchemy import Table, delete, text, tuple_
-from sqlalchemy.dialects.postgresql import insert as pg_insert
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
-from sqlalchemy.orm.relationships import RelationshipProperty
-
-from .exceptions import NotFoundError
-
-__all__ = [
-    "LockMode",
-    "cleanup_tables",
-    "create_database",
-    "create_db_context",
-    "create_db_dependency",
-    "get_transaction",
-    "lock_tables",
-    "m2m_add",
-    "m2m_remove",
-    "m2m_set",
-    "wait_for_row_change",
-]
-
-
-_SessionT = TypeVar("_SessionT", bound=AsyncSession)
-
-
-def create_db_dependency(
-    session_maker: async_sessionmaker[_SessionT],
-) -> Callable[[], AsyncGenerator[_SessionT, None]]:
-    """Create a FastAPI dependency for database sessions.
-
-    Creates a dependency function that yields a session and auto-commits
-    if a transaction is active when the request completes.
-
-    Args:
-        session_maker: Async session factory from create_session_factory()
-
-    Returns:
-        An async generator function usable with FastAPI's Depends()
-
-    Example:
-        ```python
-        from fastapi import Depends
-        from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
-        from fastapi_toolsets.db import create_db_dependency
-
-        engine = create_async_engine("postgresql+asyncpg://...")
-        SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
-        get_db = create_db_dependency(SessionLocal)
-
-        @app.get("/users")
-        async def list_users(session: AsyncSession = Depends(get_db)):
-            ...
-        ```
-    """
-
-    async def get_db() -> AsyncGenerator[_SessionT, None]:
-        async with session_maker() as session:
-            await session.connection()
-            yield session
-            if session.in_transaction():
-                await session.commit()
-
-    return get_db
-
-
-def create_db_context(
-    session_maker: async_sessionmaker[_SessionT],
-) -> Callable[[], AbstractAsyncContextManager[_SessionT]]:
-    """Create a context manager for database sessions.
-
-    Creates a context manager for use outside of FastAPI request handlers,
-    such as in background tasks, CLI commands, or tests.
-
-    Args:
-        session_maker: Async session factory from create_session_factory()
-
-    Returns:
-        An async context manager function
-
-    Example:
-        ```python
-        from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
-        from fastapi_toolsets.db import create_db_context
-
-        engine = create_async_engine("postgresql+asyncpg://...")
-        SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
-        get_db_context = create_db_context(SessionLocal)
-
-        async def background_task():
-            async with get_db_context() as session:
-                user = await UserCrud.get(session, [User.id == 1])
-                ...
-        ```
-    """
-    get_db = create_db_dependency(session_maker)
-    return asynccontextmanager(get_db)
-
-
-@asynccontextmanager
-async def get_transaction(
-    session: AsyncSession,
-) -> AsyncGenerator[AsyncSession, None]:
-    """Get a transaction context, handling nested transactions.
-
-    If already in a transaction, creates a savepoint (nested transaction).
-    Otherwise, starts a new transaction.
-
-    Args:
-        session: AsyncSession instance
-
-    Yields:
-        The session within the transaction context
-
-    Example:
-        ```python
-        async with get_transaction(session):
-            session.add(model)
-            # Auto-commits on exit, rolls back on exception
-        ```
-    """
-    if session.in_transaction():
-        async with session.begin_nested():
-            yield session
-    else:
-        async with session.begin():
-            yield session
-
-
-class LockMode(str, Enum):
-    """PostgreSQL table lock modes.
-
-    See: https://www.postgresql.org/docs/current/explicit-locking.html
-    """
-
-    ACCESS_SHARE = "ACCESS SHARE"
-    ROW_SHARE = "ROW SHARE"
-    ROW_EXCLUSIVE = "ROW EXCLUSIVE"
-    SHARE_UPDATE_EXCLUSIVE = "SHARE UPDATE EXCLUSIVE"
-    SHARE = "SHARE"
-    SHARE_ROW_EXCLUSIVE = "SHARE ROW EXCLUSIVE"
-    EXCLUSIVE = "EXCLUSIVE"
-    ACCESS_EXCLUSIVE = "ACCESS EXCLUSIVE"
-
-
-@asynccontextmanager
-async def lock_tables(
-    session: AsyncSession,
-    tables: list[type[DeclarativeBase]],
-    *,
-    mode: LockMode = LockMode.SHARE_UPDATE_EXCLUSIVE,
-    timeout: str = "5s",
-) -> AsyncGenerator[AsyncSession, None]:
-    """Lock PostgreSQL tables for the duration of a transaction.
-
-    Acquires table-level locks that are held until the transaction ends.
-    Useful for preventing concurrent modifications during critical operations.
-
-    Args:
-        session: AsyncSession instance
-        tables: List of SQLAlchemy model classes to lock
-        mode: Lock mode (default: SHARE UPDATE EXCLUSIVE)
-        timeout: Lock timeout (default: "5s")
-
-    Yields:
-        The session with locked tables
-
-    Raises:
-        SQLAlchemyError: If lock cannot be acquired within timeout
-
-    Example:
-        ```python
-        from fastapi_toolsets.db import lock_tables, LockMode
-
-        async with lock_tables(session, [User, Account]):
-            # Tables are locked with SHARE UPDATE EXCLUSIVE mode
-            user = await UserCrud.get(session, [User.id == 1])
-            user.balance += 100
-
-        # With custom lock mode
-        async with lock_tables(session, [Order], mode=LockMode.EXCLUSIVE):
-            # Exclusive lock - no other transactions can access
-            await process_order(session, order_id)
-        ```
-    """
-    table_names = ",".join(table.__tablename__ for table in tables)
-
-    async with get_transaction(session):
-        await session.execute(text(f"SET LOCAL lock_timeout='{timeout}'"))
-        await session.execute(text(f"LOCK {table_names} IN {mode.value} MODE"))
-        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)
-
-
-async def wait_for_row_change(
-    session: AsyncSession,
-    model: type[_M],
-    pk_value: Any,
-    *,
-    columns: list[str] | None = None,
-    interval: float = 0.5,
-    timeout: float | None = None,
-) -> _M:
-    """Poll a database row until a change is detected.
-
-    Queries the row every ``interval`` seconds and returns the model instance
-    once a change is detected in any column (or only the specified ``columns``).
-
-    Args:
-        session: AsyncSession instance
-        model: SQLAlchemy model class
-        pk_value: Primary key value of the row to watch
-        columns: Optional list of column names to watch. If None, all columns
-                 are watched.
-        interval: Polling interval in seconds (default: 0.5)
-        timeout: Maximum time to wait in seconds. None means wait forever.
-
-    Returns:
-        The refreshed model instance with updated values
-
-    Raises:
-        NotFoundError: If the row does not exist or is deleted during polling
-        TimeoutError: If timeout expires before a change is detected
-
-    Example:
-        ```python
-        from fastapi_toolsets.db import wait_for_row_change
-
-        # Wait for any column to change
-        updated = await wait_for_row_change(session, User, user_id)
-
-        # Watch specific columns with a timeout
-        updated = await wait_for_row_change(
-            session, User, user_id,
-            columns=["status", "email"],
-            interval=1.0,
-            timeout=30.0,
-        )
-        ```
-    """
-    instance = await session.get(model, pk_value)
-    if instance is None:
-        raise NotFoundError(f"{model.__name__} with pk={pk_value!r} not found")
-
-    if columns is not None:
-        watch_cols = columns
-    else:
-        watch_cols = [attr.key for attr in model.__mapper__.column_attrs]
-
-    initial = {col: getattr(instance, col) for col in watch_cols}
-
-    elapsed = 0.0
-    while True:
-        await asyncio.sleep(interval)
-        elapsed += interval
-
-        if timeout is not None and elapsed >= timeout:
-            raise TimeoutError(
-                f"No change detected on {model.__name__} "
-                f"with pk={pk_value!r} within {timeout}s"
-            )
-
-        session.expunge(instance)
-        instance = await session.get(model, pk_value)
-
-        if instance is None:
-            raise NotFoundError(f"{model.__name__} with pk={pk_value!r} was deleted")
-
-        current = {col: getattr(instance, col) for col in watch_cols}
-        if current != initial:
-            return instance
-
-
-def _m2m_prop(rel_attr: QueryableAttribute) -> RelationshipProperty:  # type: ignore[type-arg]
-    """Return the validated M2M RelationshipProperty for *rel_attr*.
-
-    Raises TypeError if *rel_attr* is not a Many-to-Many relationship.
-    """
-    prop = rel_attr.property
-    if not isinstance(prop, RelationshipProperty) or prop.secondary is None:
-        raise TypeError(
-            f"m2m helpers require a Many-to-Many relationship attribute, "
-            f"got {rel_attr!r}. Use a relationship with a secondary table."
-        )
-    return prop
-
-
-async def m2m_add(
-    session: AsyncSession,
-    instance: DeclarativeBase,
-    rel_attr: QueryableAttribute,
-    *related: DeclarativeBase,
-    ignore_conflicts: bool = False,
-) -> None:
-    """Insert rows into a Many-to-Many association table without loading the ORM collection.
-
-    Args:
-        session: DB async session.
-        instance: The "owner" side model instance (e.g. the ``A`` in ``A.b_list``).
-        rel_attr: The M2M relationship attribute on the model class (e.g. ``A.b_list``).
-        *related: One or more related instances to associate with ``instance``.
-        ignore_conflicts: When ``True``, silently skip rows that already exist
-            in the association table (``ON CONFLICT DO NOTHING``).
-
-    Raises:
-        TypeError: If ``rel_attr`` is not a Many-to-Many relationship.
-    """
-    prop = _m2m_prop(rel_attr)
-    if not related:
-        return
-
-    secondary = cast(Table, prop.secondary)
-    assert secondary is not None  # guaranteed by _m2m_prop
-    sync_pairs = prop.secondary_synchronize_pairs
-    assert sync_pairs is not None  # set whenever secondary is set
-
-    # synchronize_pairs:           [(parent_col, assoc_col), ...]
-    # secondary_synchronize_pairs: [(related_col, assoc_col), ...]
-    rows: list[dict[str, Any]] = []
-    for rel_instance in related:
-        row: dict[str, Any] = {}
-        for parent_col, assoc_col in prop.synchronize_pairs:
-            row[assoc_col.name] = getattr(instance, cast(str, parent_col.key))
-        for related_col, assoc_col in sync_pairs:
-            row[assoc_col.name] = getattr(rel_instance, cast(str, related_col.key))
-        rows.append(row)
-
-    stmt = pg_insert(secondary).values(rows)
-    if ignore_conflicts:
-        stmt = stmt.on_conflict_do_nothing()
-    await session.execute(stmt)
-
-
-async def m2m_remove(
-    session: AsyncSession,
-    instance: DeclarativeBase,
-    rel_attr: QueryableAttribute,
-    *related: DeclarativeBase,
-) -> None:
-    """Remove rows from a Many-to-Many association table without loading the ORM collection.
-
-    Args:
-        session: DB async session.
-        instance: The "owner" side model instance (e.g. the ``A`` in ``A.b_list``).
-        rel_attr: The M2M relationship attribute on the model class (e.g. ``A.b_list``).
-        *related: One or more related instances to disassociate from ``instance``.
-
-    Raises:
-        TypeError: If ``rel_attr`` is not a Many-to-Many relationship.
-    """
-    prop = _m2m_prop(rel_attr)
-    if not related:
-        return
-
-    secondary = cast(Table, prop.secondary)
-    assert secondary is not None  # guaranteed by _m2m_prop
-    related_pairs = prop.secondary_synchronize_pairs
-    assert related_pairs is not None  # set whenever secondary is set
-
-    parent_where = [
-        assoc_col == getattr(instance, cast(str, parent_col.key))
-        for parent_col, assoc_col in prop.synchronize_pairs
-    ]
-
-    if len(related_pairs) == 1:
-        related_col, assoc_col = related_pairs[0]
-        related_values = [getattr(r, cast(str, related_col.key)) for r in related]
-        related_where = assoc_col.in_(related_values)
-    else:
-        assoc_cols = [ac for _, ac in related_pairs]
-        rel_cols = [rc for rc, _ in related_pairs]
-        related_values_t = [
-            tuple(getattr(r, cast(str, rc.key)) for rc in rel_cols) for r in related
-        ]
-        related_where = tuple_(*assoc_cols).in_(related_values_t)
-
-    await session.execute(delete(secondary).where(*parent_where, related_where))
-
-
-async def m2m_set(
-    session: AsyncSession,
-    instance: DeclarativeBase,
-    rel_attr: QueryableAttribute,
-    *related: DeclarativeBase,
-) -> None:
-    """Replace the entire Many-to-Many association set atomically.
-
-    Args:
-        session: DB async session.
-        instance: The "owner" side model instance (e.g. the ``A`` in ``A.b_list``).
-        rel_attr: The M2M relationship attribute on the model class (e.g. ``A.b_list``).
-        *related: The new complete set of related instances.
-
-    Raises:
-        TypeError: If ``rel_attr`` is not a Many-to-Many relationship.
-    """
-    prop = _m2m_prop(rel_attr)
-    secondary = cast(Table, prop.secondary)
-    assert secondary is not None  # guaranteed by _m2m_prop
-
-    parent_where = [
-        assoc_col == getattr(instance, cast(str, parent_col.key))
-        for parent_col, assoc_col in prop.synchronize_pairs
-    ]
-    await session.execute(delete(secondary).where(*parent_where))
-
-    if related:
-        await m2m_add(session, instance, rel_attr, *related)
@@ -1,155 +0,0 @@
-"""Dependency factories for FastAPI routes."""
-
-import inspect
-import typing
-from collections.abc import Callable
-from typing import Any, cast
-
-from fastapi import Depends
-from fastapi.params import Depends as DependsClass
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from .crud import CrudFactory
-from .types import ModelType, SessionDependency
-
-__all__ = ["BodyDependency", "PathDependency"]
-
-
-def _unwrap_session_dep(session_dep: SessionDependency) -> Callable[..., Any]:
-    """Extract the plain callable from ``Annotated[AsyncSession, Depends(fn)]`` if needed."""
-    if typing.get_origin(session_dep) is typing.Annotated:
-        for arg in typing.get_args(session_dep)[1:]:
-            if isinstance(arg, DependsClass):
-                return arg.dependency
-    return session_dep
-
-
-def PathDependency(
-    model: type[ModelType],
-    field: Any,
-    *,
-    session_dep: SessionDependency,
-    param_name: str | None = None,
-) -> ModelType:
-    """Create a dependency that fetches a DB object from a path parameter.
-
-    Args:
-        model: SQLAlchemy model class
-        field: Model field to filter by (e.g., User.id)
-        session_dep: Session dependency function (e.g., get_db)
-        param_name: Path parameter name (defaults to model_field, e.g., user_id)
-
-    Returns:
-        A Depends() instance that resolves to the model instance
-
-    Raises:
-        NotFoundError: If no matching record is found
-
-    Example:
-        ```python
-        UserDep = PathDependency(User, User.id, session_dep=get_db)
-
-        @router.get("/user/{id}")
-        async def get(
-            user: User = UserDep,
-        ): ...
-        ```
-    """
-    session_callable = _unwrap_session_dep(session_dep)
-    crud = CrudFactory(model)
-    name = (
-        param_name
-        if param_name is not None
-        else "{}_{}".format(model.__name__.lower(), field.key)
-    )
-    python_type = field.type.python_type
-
-    async def dependency(
-        session: AsyncSession = Depends(session_callable), **kwargs: Any
-    ) -> ModelType:
-        value = kwargs[name]
-        return await crud.get(session, filters=[field == value])
-
-    setattr(
-        dependency,
-        "__signature__",
-        inspect.Signature(
-            parameters=[
-                inspect.Parameter(
-                    name, inspect.Parameter.KEYWORD_ONLY, annotation=python_type
-                ),
-                inspect.Parameter(
-                    "session",
-                    inspect.Parameter.KEYWORD_ONLY,
-                    annotation=AsyncSession,
-                    default=Depends(session_callable),
-                ),
-            ]
-        ),
-    )
-
-    return cast(ModelType, Depends(cast(Callable[..., ModelType], dependency)))
-
-
-def BodyDependency(
-    model: type[ModelType],
-    field: Any,
-    *,
-    session_dep: SessionDependency,
-    body_field: str,
-) -> ModelType:
-    """Create a dependency that fetches a DB object from a body field.
-
-    Args:
-        model: SQLAlchemy model class
-        field: Model field to filter by (e.g., User.id)
-        session_dep: Session dependency function (e.g., get_db)
-        body_field: Name of the field in the request body
-
-    Returns:
-        A Depends() instance that resolves to the model instance
-
-    Raises:
-        NotFoundError: If no matching record is found
-
-    Example:
-        ```python
-        UserDep = BodyDependency(
-            User, User.ctfd_id, session_dep=get_db, body_field="user_id"
-        )
-
-        @router.post("/assign")
-        async def assign(
-            user: User = UserDep,
-        ): ...
-        ```
-    """
-    session_callable = _unwrap_session_dep(session_dep)
-    crud = CrudFactory(model)
-    python_type = field.type.python_type
-
-    async def dependency(
-        session: AsyncSession = Depends(session_callable), **kwargs: Any
-    ) -> ModelType:
-        value = kwargs[body_field]
-        return await crud.get(session, filters=[field == value])
-
-    setattr(
-        dependency,
-        "__signature__",
-        inspect.Signature(
-            parameters=[
-                inspect.Parameter(
-                    body_field, inspect.Parameter.KEYWORD_ONLY, annotation=python_type
-                ),
-                inspect.Parameter(
-                    "session",
-                    inspect.Parameter.KEYWORD_ONLY,
-                    annotation=AsyncSession,
-                    default=Depends(session_callable),
-                ),
-            ]
-        ),
-    )
-
-    return cast(ModelType, Depends(cast(Callable[..., ModelType], dependency)))
@@ -1,33 +0,0 @@
-"""Standardized API exceptions and error response handlers."""
-
-from .exceptions import (
-    ApiError,
-    ApiException,
-    ConflictError,
-    ForbiddenError,
-    InvalidFacetFilterError,
-    InvalidOrderFieldError,
-    InvalidSearchColumnError,
-    NoSearchableFieldsError,
-    NotFoundError,
-    UnauthorizedError,
-    UnsupportedFacetTypeError,
-    generate_error_responses,
-)
-from .handler import init_exceptions_handlers
-
-__all__ = [
-    "ApiError",
-    "ApiException",
-    "ConflictError",
-    "ForbiddenError",
-    "generate_error_responses",
-    "init_exceptions_handlers",
-    "InvalidFacetFilterError",
-    "InvalidOrderFieldError",
-    "InvalidSearchColumnError",
-    "NoSearchableFieldsError",
-    "NotFoundError",
-    "UnauthorizedError",
-    "UnsupportedFacetTypeError",
-]
@@ -1,267 +0,0 @@
-"""Custom exceptions with standardized API error responses."""
-
-from typing import Any, ClassVar
-
-from ..schemas import ApiError, ErrorResponse, ResponseStatus
-
-
-class ApiException(Exception):
-    """Base exception for API errors with structured response."""
-
-    api_error: ClassVar[ApiError]
-
-    def __init_subclass__(cls, abstract: bool = False, **kwargs: Any) -> None:
-        super().__init_subclass__(**kwargs)
-        if not abstract and not hasattr(cls, "api_error"):
-            raise TypeError(
-                f"{cls.__name__} must define an 'api_error' class attribute. "
-                "Pass abstract=True when creating intermediate base classes."
-            )
-
-    def __init__(
-        self,
-        detail: str | None = None,
-        *,
-        desc: str | None = None,
-        data: Any = None,
-    ) -> None:
-        """Initialize the exception.
-
-        Args:
-            detail: Optional human-readable message
-            desc: Optional per-instance override for the ``description`` field
-                in the HTTP response body.
-            data: Optional per-instance override for the ``data`` field in the
-                HTTP response body.
-        """
-        updates: dict[str, Any] = {}
-        if detail is not None:
-            updates["msg"] = detail
-        if desc is not None:
-            updates["desc"] = desc
-        if data is not None:
-            updates["data"] = data
-        if updates:
-            object.__setattr__(
-                self, "api_error", self.__class__.api_error.model_copy(update=updates)
-            )
-        super().__init__(self.api_error.msg)
-
-
-class UnauthorizedError(ApiException):
-    """HTTP 401 - User is not authenticated."""
-
-    api_error = ApiError(
-        code=401,
-        msg="Unauthorized",
-        desc="Authentication credentials were missing or invalid.",
-        err_code="AUTH-401",
-    )
-
-
-class ForbiddenError(ApiException):
-    """HTTP 403 - User lacks required permissions."""
-
-    api_error = ApiError(
-        code=403,
-        msg="Forbidden",
-        desc="You do not have permission to access this resource.",
-        err_code="AUTH-403",
-    )
-
-
-class NotFoundError(ApiException):
-    """HTTP 404 - Resource not found."""
-
-    api_error = ApiError(
-        code=404,
-        msg="Not Found",
-        desc="The requested resource was not found.",
-        err_code="RES-404",
-    )
-
-
-class ConflictError(ApiException):
-    """HTTP 409 - Resource conflict."""
-
-    api_error = ApiError(
-        code=409,
-        msg="Conflict",
-        desc="The request conflicts with the current state of the resource.",
-        err_code="RES-409",
-    )
-
-
-class NoSearchableFieldsError(ApiException):
-    """Raised when search is requested but no searchable fields are available."""
-
-    api_error = ApiError(
-        code=400,
-        msg="No Searchable Fields",
-        desc="No searchable fields configured for this resource.",
-        err_code="SEARCH-400",
-    )
-
-    def __init__(self, model: type) -> None:
-        """Initialize the exception.
-
-        Args:
-            model: The model class that has no searchable fields configured.
-        """
-        self.model = model
-        super().__init__(
-            desc=(
-                f"No searchable fields found for model '{model.__name__}'. "
-                "Provide 'search_fields' parameter or set 'searchable_fields' on the CRUD class."
-            )
-        )
-
-
-class InvalidFacetFilterError(ApiException):
-    """Raised when filter_by contains a key not declared in facet_fields."""
-
-    api_error = ApiError(
-        code=400,
-        msg="Invalid Facet Filter",
-        desc="One or more filter_by keys are not declared as facet fields.",
-        err_code="FACET-400",
-    )
-
-    def __init__(self, key: str, valid_keys: set[str]) -> None:
-        """Initialize the exception.
-
-        Args:
-            key: The unknown filter key provided by the caller.
-            valid_keys: Set of valid keys derived from the declared facet_fields.
-        """
-        self.key = key
-        self.valid_keys = valid_keys
-        super().__init__(
-            desc=(
-                f"'{key}' is not a declared facet field. "
-                f"Valid keys: {sorted(valid_keys) or 'none — set facet_fields on the CRUD class'}."
-            )
-        )
-
-
-class UnsupportedFacetTypeError(ApiException):
-    """Raised when a facet field has a column type not supported by filter_by."""
-
-    api_error = ApiError(
-        code=400,
-        msg="Unsupported Facet Type",
-        desc="The column type is not supported for facet filtering.",
-        err_code="FACET-TYPE-400",
-    )
-
-    def __init__(self, key: str, col_type: str) -> None:
-        """Initialize the exception.
-
-        Args:
-            key: The facet field key.
-            col_type: The unsupported column type name.
-        """
-        self.key = key
-        self.col_type = col_type
-        super().__init__(
-            desc=(
-                f"Facet field '{key}' has unsupported column type '{col_type}'. "
-                f"Supported types: String, Integer, Numeric, Boolean, "
-                f"Date, DateTime, Time, Enum, Uuid, ARRAY."
-            )
-        )
-
-
-class InvalidSearchColumnError(ApiException):
-    """Raised when search_column is not one of the configured searchable fields."""
-
-    api_error = ApiError(
-        code=400,
-        msg="Invalid Search Column",
-        desc="The requested search column is not a configured searchable field.",
-        err_code="SEARCH-COL-400",
-    )
-
-    def __init__(self, column: str, valid_columns: list[str]) -> None:
-        """Initialize the exception.
-
-        Args:
-            column: The unknown search column provided by the caller.
-            valid_columns: List of valid search column keys.
-        """
-        self.column = column
-        self.valid_columns = valid_columns
-        super().__init__(
-            desc=(
-                f"'{column}' is not a searchable column. "
-                f"Valid columns: {valid_columns}."
-            )
-        )
-
-
-class InvalidOrderFieldError(ApiException):
-    """Raised when order_by contains a field not in the allowed order fields."""
-
-    api_error = ApiError(
-        code=422,
-        msg="Invalid Order Field",
-        desc="The requested order field is not allowed for this resource.",
-        err_code="SORT-422",
-    )
-
-    def __init__(self, field: str, valid_fields: list[str]) -> None:
-        """Initialize the exception.
-
-        Args:
-            field: The unknown order field provided by the caller.
-            valid_fields: List of valid field names.
-        """
-        self.field = field
-        self.valid_fields = valid_fields
-        super().__init__(
-            desc=f"'{field}' is not an allowed order field. Valid fields: {valid_fields}."
-        )
-
-
-def generate_error_responses(
-    *errors: type[ApiException],
-) -> dict[int | str, dict[str, Any]]:
-    """Generate OpenAPI response documentation for exceptions.
-
-    Args:
-        *errors: Exception classes that inherit from ApiException.
-
-    Returns:
-        Dict suitable for FastAPI's ``responses`` parameter.
-    """
-    responses: dict[int | str, dict[str, Any]] = {}
-
-    for error in errors:
-        api_error = error.api_error
-        code = api_error.code
-
-        if code not in responses:
-            responses[code] = {
-                "model": ErrorResponse,
-                "description": api_error.msg,
-                "content": {
-                    "application/json": {
-                        "examples": {},
-                    }
-                },
-            }
-
-        responses[code]["content"]["application/json"]["examples"][
-            api_error.err_code
-        ] = {
-            "summary": api_error.msg,
-            "value": {
-                "data": api_error.data,
-                "status": ResponseStatus.FAIL.value,
-                "message": api_error.msg,
-                "description": api_error.desc,
-                "error_code": api_error.err_code,
-            },
-        }
-
-    return responses
@@ -1,180 +0,0 @@
-"""Exception handlers for FastAPI applications."""
-
-from collections.abc import Callable
-from typing import Any
-
-from fastapi import FastAPI, Request, Response, status
-from fastapi.exceptions import (
-    HTTPException,
-    RequestValidationError,
-    ResponseValidationError,
-)
-from fastapi.responses import JSONResponse
-
-from ..schemas import ErrorResponse, ResponseStatus
-from .exceptions import ApiException
-
-_VALIDATION_LOCATION_PARAMS: frozenset[str] = frozenset(
-    {"body", "query", "path", "header", "cookie"}
-)
-
-
-def init_exceptions_handlers(app: FastAPI) -> FastAPI:
-    """Register exception handlers and custom OpenAPI schema on a FastAPI app.
-
-    Args:
-        app: FastAPI application instance.
-
-    Returns:
-        The same FastAPI instance (for chaining).
-    """
-    _register_exception_handlers(app)
-    _original_openapi = app.openapi
-    app.openapi = lambda: _patched_openapi(app, _original_openapi)  # type: ignore[method-assign]  # ty:ignore[invalid-assignment]
-    return app
-
-
-def _register_exception_handlers(app: FastAPI) -> None:
-    """Register all exception handlers on a FastAPI application."""
-
-    @app.exception_handler(ApiException)
-    async def api_exception_handler(request: Request, exc: ApiException) -> Response:
-        """Handle custom API exceptions with structured response."""
-        api_error = exc.api_error
-        error_response = ErrorResponse(
-            data=api_error.data,
-            message=api_error.msg,
-            description=api_error.desc,
-            error_code=api_error.err_code,
-        )
-        return JSONResponse(
-            status_code=api_error.code,
-            content=error_response.model_dump(),
-        )
-
-    @app.exception_handler(HTTPException)
-    async def http_exception_handler(request: Request, exc: HTTPException) -> Response:
-        """Handle Starlette/FastAPI HTTPException with a consistent error format."""
-        detail = exc.detail if isinstance(exc.detail, str) else "HTTP Error"
-        error_response = ErrorResponse(
-            message=detail,
-            error_code=f"HTTP-{exc.status_code}",
-        )
-        return JSONResponse(
-            status_code=exc.status_code,
-            content=error_response.model_dump(),
-            headers=getattr(exc, "headers", None),
-        )
-
-    @app.exception_handler(RequestValidationError)
-    async def request_validation_handler(
-        request: Request, exc: RequestValidationError
-    ) -> Response:
-        """Handle Pydantic request validation errors (422)."""
-        return _format_validation_error(exc)
-
-    @app.exception_handler(ResponseValidationError)
-    async def response_validation_handler(
-        request: Request, exc: ResponseValidationError
-    ) -> Response:
-        """Handle Pydantic response validation errors (422)."""
-        return _format_validation_error(exc)
-
-    @app.exception_handler(Exception)
-    async def generic_exception_handler(request: Request, exc: Exception) -> Response:
-        """Handle all unhandled exceptions with a generic 500 response."""
-        error_response = ErrorResponse(
-            message="Internal Server Error",
-            description="An unexpected error occurred. Please try again later.",
-            error_code="SERVER-500",
-        )
-        return JSONResponse(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            content=error_response.model_dump(),
-        )
-
-
-def _format_validation_error(
-    exc: RequestValidationError | ResponseValidationError,
-) -> JSONResponse:
-    """Format validation errors into a structured response."""
-    errors = exc.errors()
-    formatted_errors = []
-
-    for error in errors:
-        locs = error["loc"]
-        if locs and locs[0] in _VALIDATION_LOCATION_PARAMS:
-            locs = locs[1:]
-        field_path = ".".join(str(loc) for loc in locs)
-        formatted_errors.append(
-            {
-                "field": field_path or "root",
-                "message": error.get("msg", ""),
-                "type": error.get("type", ""),
-            }
-        )
-
-    error_response = ErrorResponse(
-        data={"errors": formatted_errors},
-        message="Validation Error",
-        description=f"{len(formatted_errors)} validation error(s) detected",
-        error_code="VAL-422",
-    )
-
-    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-        content=error_response.model_dump(),
-    )
-
-
-def _patched_openapi(
-    app: FastAPI, original_openapi: Callable[[], dict[str, Any]]
-) -> dict[str, Any]:
-    """Generate the OpenAPI schema and replace default 422 responses.
-
-    Args:
-        app: FastAPI application instance.
-        original_openapi: The previous ``app.openapi`` callable to delegate to.
-
-    Returns:
-        Patched OpenAPI schema dict.
-    """
-    if app.openapi_schema:
-        return app.openapi_schema
-
-    openapi_schema = original_openapi()
-
-    for path_data in openapi_schema.get("paths", {}).values():
-        for operation in path_data.values():
-            if isinstance(operation, dict) and "responses" in operation:
-                if "422" in operation["responses"]:
-                    operation["responses"]["422"] = {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "examples": {
-                                    "VAL-422": {
-                                        "summary": "Validation Error",
-                                        "value": {
-                                            "data": {
-                                                "errors": [
-                                                    {
-                                                        "field": "field_name",
-                                                        "message": "value is not valid",
-                                                        "type": "value_error",
-                                                    }
-                                                ]
-                                            },
-                                            "status": ResponseStatus.FAIL.value,
-                                            "message": "Validation Error",
-                                            "description": "1 validation error(s) detected",
-                                            "error_code": "VAL-422",
-                                        },
-                                    }
-                                }
-                            }
-                        },
-                    }
-
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
@@ -1,21 +0,0 @@
-"""Fixture system for seeding databases with dependency resolution."""
-
-from .enum import LoadStrategy
-from .registry import Context, FixtureRegistry
-from .utils import (
-    get_field_by_attr,
-    get_obj_by_attr,
-    load_fixtures,
-    load_fixtures_by_context,
-)
-
-__all__ = [
-    "Context",
-    "FixtureRegistry",
-    "LoadStrategy",
-    "get_field_by_attr",
-    "get_obj_by_attr",
-    "load_fixtures",
-    "load_fixtures_by_context",
-    "register_fixtures",
-]
@@ -1,32 +0,0 @@
-"""Enums for fixture loading strategies and contexts."""
-
-from enum import Enum
-
-
-class LoadStrategy(str, Enum):
-    """Strategy for loading fixtures into the database."""
-
-    INSERT = "insert"
-    """Insert new records. Fails if record already exists."""
-
-    MERGE = "merge"
-    """Insert or update based on primary key (SQLAlchemy merge)."""
-
-    SKIP_EXISTING = "skip_existing"
-    """Insert only if record doesn't exist (based on primary key)."""
-
-
-class Context(str, Enum):
-    """Predefined fixture contexts."""
-
-    BASE = "base"
-    """Base fixtures loaded in all environments."""
-
-    PRODUCTION = "production"
-    """Production-only fixtures."""
-
-    DEVELOPMENT = "development"
-    """Development fixtures."""
-
-    TESTING = "testing"
-    """Test fixtures."""
@@ -1,311 +0,0 @@
-"""Fixture system with dependency management and context support."""
-
-from collections.abc import Callable, Sequence
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, cast
-
-from sqlalchemy.orm import DeclarativeBase
-
-from ..logger import get_logger
-from .enum import Context
-
-logger = get_logger()
-
-
-def _normalize_contexts(
-    contexts: list[str | Enum] | tuple[str | Enum, ...],
-) -> list[str]:
-    """Convert a sequence of any Enum subclass and/or plain strings to a list of strings."""
-    return [c.value if isinstance(c, Enum) else c for c in contexts]
-
-
-@dataclass
-class Fixture:
-    """A fixture definition with metadata."""
-
-    name: str
-    func: Callable[[], Sequence[DeclarativeBase]]
-    depends_on: list[str] = field(default_factory=list)
-    contexts: list[str] = field(default_factory=lambda: [Context.BASE])
-
-
-class FixtureRegistry:
-    """Registry for managing fixtures with dependencies.
-
-    Example:
-        ```python
-        from fastapi_toolsets.fixtures import FixtureRegistry, Context
-
-        fixtures = FixtureRegistry()
-
-        @fixtures.register
-        def roles():
-            return [
-                Role(id=1, name="admin"),
-                Role(id=2, name="user"),
-            ]
-
-        @fixtures.register(depends_on=["roles"])
-        def users():
-            return [
-                User(id=1, username="admin", role_id=1),
-            ]
-
-        @fixtures.register(depends_on=["users"], contexts=[Context.TESTING])
-        def test_data():
-            return [
-                Post(id=1, title="Test", user_id=1),
-            ]
-        ```
-
-    Fixtures with the same name may be registered for **different** contexts.
-    When multiple contexts are loaded together, their instances are merged:
-
-        ```python
-        @fixtures.register(contexts=[Context.BASE])
-        def users():
-            return [User(id=1, username="admin")]
-
-        @fixtures.register(contexts=[Context.TESTING])
-        def users():
-            return [User(id=2, username="tester")]
-        # load_fixtures_by_context(..., Context.BASE, Context.TESTING)
-        # → loads both User(admin) and User(tester) under the "users" name
-        ```
-    """
-
-    def __init__(
-        self,
-        contexts: list[str | Enum] | None = None,
-    ) -> None:
-        self._fixtures: dict[str, list[Fixture]] = {}
-        self._default_contexts: list[str] | None = (
-            _normalize_contexts(contexts) if contexts else None
-        )
-
-    def _validate_no_context_overlap(self, name: str, new_contexts: list[str]) -> None:
-        """Raise ``ValueError`` if any existing variant for *name* overlaps."""
-        existing_variants = self._fixtures.get(name, [])
-        new_set = set(new_contexts)
-        for variant in existing_variants:
-            if set(variant.contexts) & new_set:
-                raise ValueError(
-                    f"Fixture '{name}' already exists in the current registry "
-                    f"with overlapping contexts. Use distinct context sets for "
-                    f"each variant of the same fixture name."
-                )
-
-    def register(
-        self,
-        func: Callable[[], Sequence[DeclarativeBase]] | None = None,
-        *,
-        name: str | None = None,
-        depends_on: list[str] | None = None,
-        contexts: list[str | Enum] | None = None,
-    ) -> Callable[..., Any]:
-        """Register a fixture function.
-
-        Can be used as a decorator with or without arguments.
-
-        Args:
-            func: Fixture function returning list of model instances
-            name: Fixture name (defaults to function name)
-            depends_on: List of fixture names this depends on
-            contexts: List of contexts this fixture belongs to.  Both
-                :class:`Context` enum values and plain strings are accepted.
-
-        Example:
-            ```python
-            @fixtures.register
-            def roles():
-                return [Role(id=1, name="admin")]
-
-            @fixtures.register(depends_on=["roles"], contexts=[Context.TESTING])
-            def test_users():
-                return [User(id=1, username="test", role_id=1)]
-        """
-
-        def decorator(
-            fn: Callable[[], Sequence[DeclarativeBase]],
-        ) -> Callable[[], Sequence[DeclarativeBase]]:
-            fixture_name = name or cast(Any, fn).__name__
-            if contexts is not None:
-                fixture_contexts = _normalize_contexts(contexts)
-            elif self._default_contexts is not None:
-                fixture_contexts = self._default_contexts
-            else:
-                fixture_contexts = [Context.BASE.value]
-
-            self._validate_no_context_overlap(fixture_name, fixture_contexts)
-            self._fixtures.setdefault(fixture_name, []).append(
-                Fixture(
-                    name=fixture_name,
-                    func=fn,
-                    depends_on=depends_on or [],
-                    contexts=fixture_contexts,
-                )
-            )
-            return fn
-
-        if func is not None:
-            return decorator(func)
-        return decorator
-
-    def include_registry(self, registry: "FixtureRegistry") -> None:
-        """Include another `FixtureRegistry` in the same current `FixtureRegistry`.
-
-        Fixtures with the same name are allowed as long as their context sets
-        do not overlap.  Conflicting contexts raise :class:`ValueError`.
-
-        Args:
-            registry: The `FixtureRegistry` to include
-
-        Raises:
-            ValueError: If a fixture name already exists with overlapping contexts
-
-        Example:
-            ```python
-            registry = FixtureRegistry()
-            dev_registry = FixtureRegistry()
-
-            @dev_registry.register
-            def dev_data():
-                return [...]
-
-            registry.include_registry(registry=dev_registry)
-            ```
-        """
-        for name, variants in registry._fixtures.items():
-            for fixture in variants:
-                self._validate_no_context_overlap(name, fixture.contexts)
-                self._fixtures.setdefault(name, []).append(fixture)
-
-    def get(self, name: str) -> Fixture:
-        """Get a fixture by name.
-
-        Raises:
-            KeyError: If no fixture with *name* is registered.
-            ValueError: If the fixture has multiple context variants — use
-                :meth:`get_variants` in that case.
-        """
-        if name not in self._fixtures:
-            raise KeyError(f"Fixture '{name}' not found")
-        variants = self._fixtures[name]
-        if len(variants) > 1:
-            raise ValueError(
-                f"Fixture '{name}' has {len(variants)} context variants. "
-                f"Use get_variants('{name}') to retrieve them."
-            )
-        return variants[0]
-
-    def get_variants(self, name: str, *contexts: str | Enum) -> list[Fixture]:
-        """Return all registered variants for *name*, optionally filtered by context.
-
-        Args:
-            name: Fixture name.
-            *contexts: If given, only return variants whose context set
-                intersects with these values.  Both :class:`Context` enum
-                values and plain strings are accepted.
-
-        Returns:
-            List of matching :class:`Fixture` objects (may be empty when a
-            context filter is applied and nothing matches).
-
-        Raises:
-            KeyError: If no fixture with *name* is registered.
-        """
-        if name not in self._fixtures:
-            raise KeyError(f"Fixture '{name}' not found")
-        variants = self._fixtures[name]
-        if not contexts:
-            return list(variants)
-        context_values = set(_normalize_contexts(contexts))
-        return [v for v in variants if set(v.contexts) & context_values]
-
-    def get_all(self) -> list[Fixture]:
-        """Get all registered fixtures (all variants of all names)."""
-        return [f for variants in self._fixtures.values() for f in variants]
-
-    def get_by_context(self, *contexts: str | Enum) -> list[Fixture]:
-        """Get fixtures for specific contexts."""
-        context_values = set(_normalize_contexts(contexts))
-        return [
-            f
-            for variants in self._fixtures.values()
-            for f in variants
-            if set(f.contexts) & context_values
-        ]
-
-    def resolve_dependencies(self, *names: str) -> list[str]:
-        """Resolve fixture dependencies in topological order.
-
-        When a fixture name has multiple context variants, the union of all
-        variants' ``depends_on`` lists is used.
-
-        Args:
-            *names: Fixture names to resolve
-
-        Returns:
-            List of fixture names in load order (dependencies first)
-
-        Raises:
-            KeyError: If a fixture is not found
-            ValueError: If circular dependency detected
-        """
-        resolved: list[str] = []
-        seen: set[str] = set()
-        visiting: set[str] = set()
-
-        def visit(name: str) -> None:
-            if name in resolved:
-                return
-            if name in visiting:
-                raise ValueError(f"Circular dependency detected: {name}")
-
-            visiting.add(name)
-            variants = self._fixtures.get(name)
-            if variants is None:
-                raise KeyError(f"Fixture '{name}' not found")
-
-            # Union of depends_on across all variants, preserving first-seen order.
-            seen_deps: set[str] = set()
-            all_deps: list[str] = []
-            for variant in variants:
-                for dep in variant.depends_on:
-                    if dep not in seen_deps:
-                        all_deps.append(dep)
-                        seen_deps.add(dep)
-
-            for dep in all_deps:
-                visit(dep)
-
-            visiting.remove(name)
-            resolved.append(name)
-            seen.add(name)
-
-        for name in names:
-            visit(name)
-
-        return resolved
-
-    def resolve_context_dependencies(self, *contexts: str | Enum) -> list[str]:
-        """Resolve all fixtures for contexts with dependencies.
-
-        Args:
-            *contexts: Contexts to load
-
-        Returns:
-            List of fixture names in load order
-        """
-        context_fixtures = self.get_by_context(*contexts)
-        # Deduplicate names while preserving first-seen order (a name can
-        # appear multiple times if it has variants in different contexts).
-        names = list(dict.fromkeys(f.name for f in context_fixtures))
-
-        all_deps: set[str] = set()
-        for name in names:
-            deps = self.resolve_dependencies(name)
-            all_deps.update(deps)
-
-        return self.resolve_dependencies(*all_deps)
@@ -1,362 +0,0 @@
-"""Fixture loading utilities for database seeding."""
-
-from collections.abc import Callable, Sequence
-from enum import Enum
-from typing import Any
-
-from sqlalchemy import inspect as sa_inspect
-from sqlalchemy.dialects.postgresql import insert as pg_insert
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase
-
-from ..db import get_transaction
-from ..logger import get_logger
-from ..types import ModelType
-from .enum import LoadStrategy
-from .registry import FixtureRegistry, _normalize_contexts
-
-logger = get_logger()
-
-
-def _instance_to_dict(instance: DeclarativeBase) -> dict[str, Any]:
-    """Extract column values from a model instance, skipping unset server-default columns."""
-    state = sa_inspect(instance)
-    state_dict = state.dict
-    result: dict[str, Any] = {}
-    for prop in state.mapper.column_attrs:
-        if prop.key not in state_dict:
-            continue
-        val = state_dict[prop.key]
-        if val is None:
-            col = prop.columns[0]
-
-            if (
-                col.server_default is not None
-                or (col.default is not None and col.default.is_callable)
-                or col.autoincrement is True
-            ):
-                continue
-        result[prop.key] = val
-    return result
-
-
-def _get_table_chain(model_cls: type[DeclarativeBase]) -> list[type[DeclarativeBase]]:
-    """Return [root, ..., model_cls] for joined-table inheritance, or [model_cls]."""
-    chain: list[type[DeclarativeBase]] = []
-    current = sa_inspect(model_cls)
-    while current is not None:
-        chain.append(current.class_)
-        current = current.inherits
-    chain.reverse()
-    seen: set[int] = set()
-    result: list[type[DeclarativeBase]] = []
-    for cls in chain:
-        tid = id(cls.__table__)
-        if tid not in seen:  # pragma: no branch
-            seen.add(tid)
-            result.append(cls)
-    return result
-
-
-def _instance_to_dict_for_cls(
-    instance: DeclarativeBase, cls: type[DeclarativeBase]
-) -> dict[str, Any]:
-    """Like _instance_to_dict but limited to columns belonging to cls's own table."""
-    own_cols = {col.key for col in cls.__table__.columns}
-    return {k: v for k, v in _instance_to_dict(instance).items() if k in own_cols}
-
-
-def _group_by_type(
-    instances: list[DeclarativeBase],
-) -> list[tuple[type[DeclarativeBase], list[DeclarativeBase]]]:
-    """Group instances by their concrete model class, preserving insertion order."""
-    groups: dict[type[DeclarativeBase], list[DeclarativeBase]] = {}
-    for instance in instances:
-        groups.setdefault(type(instance), []).append(instance)
-    return list(groups.items())
-
-
-def _group_by_column_set(
-    dicts: list[dict[str, Any]],
-    instances: list[DeclarativeBase],
-) -> list[tuple[list[dict[str, Any]], list[DeclarativeBase]]]:
-    """Group (dict, instance) pairs by their dict key sets."""
-    groups: dict[
-        frozenset[str], tuple[list[dict[str, Any]], list[DeclarativeBase]]
-    ] = {}
-    for d, inst in zip(dicts, instances):
-        key = frozenset(d)
-        if key not in groups:
-            groups[key] = ([], [])
-        groups[key][0].append(d)
-        groups[key][1].append(inst)
-    return list(groups.values())
-
-
-async def _batch_insert(
-    session: AsyncSession,
-    model_cls: type[DeclarativeBase],
-    instances: list[DeclarativeBase],
-) -> None:
-    """INSERT all instances — raises on conflict (no duplicate handling)."""
-    for cls in _get_table_chain(model_cls):
-        dicts = [_instance_to_dict_for_cls(i, cls) for i in instances]
-        for group_dicts, _ in _group_by_column_set(dicts, instances):
-            if group_dicts and group_dicts[0]:  # pragma: no branch
-                await session.execute(pg_insert(cls).values(group_dicts))
-
-
-async def _batch_merge(
-    session: AsyncSession,
-    model_cls: type[DeclarativeBase],
-    instances: list[DeclarativeBase],
-) -> None:
-    """UPSERT: insert new rows, update existing ones with the provided values."""
-    for cls in _get_table_chain(model_cls):
-        pk_names = [col.name for col in cls.__table__.primary_key]
-        pk_names_set = set(pk_names)
-        own_col_keys = {col.key for col in cls.__table__.columns}
-        non_pk_cols = [k for k in own_col_keys if k not in pk_names_set]
-
-        dicts = [_instance_to_dict_for_cls(i, cls) for i in instances]
-        for group_dicts, _ in _group_by_column_set(dicts, instances):
-            if not group_dicts or not group_dicts[0]:  # pragma: no cover
-                continue
-            stmt = pg_insert(cls).values(group_dicts)
-
-            inserted_keys = set(group_dicts[0])
-            update_cols = [col for col in non_pk_cols if col in inserted_keys]
-
-            if update_cols:
-                stmt = stmt.on_conflict_do_update(
-                    index_elements=pk_names,
-                    set_={col: stmt.excluded[col] for col in update_cols},
-                )
-            else:
-                stmt = stmt.on_conflict_do_nothing(index_elements=pk_names)
-
-            await session.execute(stmt)
-
-
-async def _batch_skip_existing(
-    session: AsyncSession,
-    model_cls: type[DeclarativeBase],
-    instances: list[DeclarativeBase],
-) -> list[DeclarativeBase]:
-    """INSERT only rows that do not already exist; return the inserted ones."""
-    if len(_get_table_chain(model_cls)) > 1:
-        loaded: list[DeclarativeBase] = []
-        for inst in instances:
-            pk = _get_primary_key(inst)
-            if pk is None or not await session.get(model_cls, pk):
-                session.add(inst)
-                loaded.append(inst)
-        await session.flush()
-        return loaded
-
-    mapper = model_cls.__mapper__
-    pk_names = [col.name for col in mapper.primary_key]
-
-    no_pk: list[DeclarativeBase] = []
-    with_pk_pairs: list[tuple[DeclarativeBase, Any]] = []
-    for inst in instances:
-        pk = _get_primary_key(inst)
-        if pk is None:
-            no_pk.append(inst)
-        else:
-            with_pk_pairs.append((inst, pk))
-
-    loaded = list(no_pk)
-    if no_pk:
-        no_pk_dicts = [_instance_to_dict(i) for i in no_pk]
-        for group_dicts, _ in _group_by_column_set(no_pk_dicts, no_pk):
-            await session.execute(pg_insert(model_cls).values(group_dicts))
-
-    if with_pk_pairs:
-        with_pk = [i for i, _ in with_pk_pairs]
-        with_pk_dicts = [_instance_to_dict(i) for i in with_pk]
-        for group_dicts, group_insts in _group_by_column_set(with_pk_dicts, with_pk):
-            stmt = (
-                pg_insert(model_cls)
-                .values(group_dicts)
-                .on_conflict_do_nothing(index_elements=pk_names)
-            )
-            result = await session.execute(stmt.returning(*mapper.primary_key))
-            inserted_pks = {
-                row[0] if len(pk_names) == 1 else tuple(row) for row in result
-            }
-            loaded.extend(
-                inst
-                for inst, pk in zip(
-                    group_insts, [_get_primary_key(i) for i in group_insts]
-                )
-                if pk in inserted_pks
-            )
-
-    return loaded
-
-
-async def _load_ordered(
-    session: AsyncSession,
-    registry: FixtureRegistry,
-    ordered_names: list[str],
-    strategy: LoadStrategy,
-    contexts: tuple[str, ...] | None = None,
-) -> dict[str, list[DeclarativeBase]]:
-    """Load fixtures in order using batch Core INSERT statements."""
-    results: dict[str, list[DeclarativeBase]] = {}
-
-    for name in ordered_names:
-        variants = (
-            registry.get_variants(name, *contexts)
-            if contexts is not None
-            else registry.get_variants(name)
-        )
-
-        if contexts is not None and not variants:
-            variants = registry.get_variants(name)
-
-        if not variants:  # pragma: no cover
-            results[name] = []
-            continue
-
-        instances = [inst for v in variants for inst in v.func()]
-
-        if not instances:
-            results[name] = []
-            continue
-
-        model_name = type(instances[0]).__name__
-        loaded: list[DeclarativeBase] = []
-
-        async with get_transaction(session):
-            for model_cls, group in _group_by_type(instances):
-                match strategy:
-                    case LoadStrategy.INSERT:
-                        await _batch_insert(session, model_cls, group)
-                        loaded.extend(group)
-                    case LoadStrategy.MERGE:
-                        await _batch_merge(session, model_cls, group)
-                        loaded.extend(group)
-                    case LoadStrategy.SKIP_EXISTING:
-                        inserted = await _batch_skip_existing(session, model_cls, group)
-                        loaded.extend(inserted)
-                    case _:  # pragma: no cover
-                        pass
-
-        results[name] = loaded
-        logger.info(f"Loaded fixture '{name}': {len(loaded)} {model_name}(s)")
-
-    return results
-
-
-def _get_primary_key(instance: DeclarativeBase) -> Any | None:
-    """Get the primary key value of a model instance."""
-    mapper = instance.__class__.__mapper__
-    pk_cols = mapper.primary_key
-
-    if len(pk_cols) == 1:
-        return getattr(instance, pk_cols[0].name, None)
-
-    pk_values = tuple(getattr(instance, col.name, None) for col in pk_cols)
-    if all(v is not None for v in pk_values):
-        return pk_values
-    return None
-
-
-def get_obj_by_attr(
-    fixtures: Callable[[], Sequence[ModelType]], attr_name: str, value: Any
-) -> ModelType:
-    """Get a SQLAlchemy model instance by matching an attribute value.
-
-    Args:
-        fixtures: A fixture function registered via ``@registry.register``
-            that returns a sequence of SQLAlchemy model instances.
-        attr_name: Name of the attribute to match against.
-        value: Value to match.
-
-    Returns:
-        The first model instance where the attribute matches the given value.
-
-    Raises:
-        StopIteration: If no matching object is found in the fixture group.
-    """
-    try:
-        return next(obj for obj in fixtures() if getattr(obj, attr_name) == value)
-    except StopIteration:
-        raise StopIteration(
-            f"No object with {attr_name}={value} found in fixture '{getattr(fixtures, '__name__', repr(fixtures))}'"
-        ) from None
-
-
-def get_field_by_attr(
-    fixtures: Callable[[], Sequence[ModelType]],
-    attr_name: str,
-    value: Any,
-    *,
-    field: str = "id",
-) -> Any:
-    """Get a single field value from a fixture object matched by an attribute.
-
-    Args:
-        fixtures: A fixture function registered via ``@registry.register``
-            that returns a sequence of SQLAlchemy model instances.
-        attr_name: Name of the attribute to match against.
-        value: Value to match.
-        field: Attribute name to return from the matched object (default: ``"id"``).
-
-    Returns:
-        The value of ``field`` on the first matching model instance.
-
-    Raises:
-        StopIteration: If no matching object is found in the fixture group.
-    """
-    return getattr(get_obj_by_attr(fixtures, attr_name, value), field)
-
-
-async def load_fixtures(
-    session: AsyncSession,
-    registry: FixtureRegistry,
-    *names: str,
-    strategy: LoadStrategy = LoadStrategy.MERGE,
-) -> dict[str, list[DeclarativeBase]]:
-    """Load specific fixtures by name with dependencies.
-
-    All context variants of each requested fixture are loaded and merged.
-
-    Args:
-        session: Database session
-        registry: Fixture registry
-        *names: Fixture names to load (dependencies auto-resolved)
-        strategy: How to handle existing records
-
-    Returns:
-        Dict mapping fixture names to loaded instances
-    """
-    ordered = registry.resolve_dependencies(*names)
-    return await _load_ordered(session, registry, ordered, strategy)
-
-
-async def load_fixtures_by_context(
-    session: AsyncSession,
-    registry: FixtureRegistry,
-    *contexts: str | Enum,
-    strategy: LoadStrategy = LoadStrategy.MERGE,
-) -> dict[str, list[DeclarativeBase]]:
-    """Load all fixtures for specific contexts.
-
-    Args:
-        session: Database session
-        registry: Fixture registry
-        *contexts: Contexts to load (e.g., ``Context.BASE``, ``Context.TESTING``,
-            or plain strings for custom contexts)
-        strategy: How to handle existing records
-
-    Returns:
-        Dict mapping fixture names to loaded instances
-    """
-    context_strings = tuple(_normalize_contexts(contexts))
-    ordered = registry.resolve_context_dependencies(*contexts)
-    return await _load_ordered(
-        session, registry, ordered, strategy, contexts=context_strings
-    )
@@ -1,98 +0,0 @@
-"""Logging configuration for FastAPI applications and CLI tools."""
-
-import logging
-import sys
-from typing import Literal
-
-__all__ = ["LogLevel", "configure_logging", "get_logger"]
-
-DEFAULT_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-UVICORN_LOGGERS = ("uvicorn", "uvicorn.access", "uvicorn.error")
-
-LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-
-
-def configure_logging(
-    level: LogLevel | int = "INFO",
-    fmt: str = DEFAULT_FORMAT,
-    logger_name: str | None = None,
-) -> logging.Logger:
-    """Configure logging with a stdout handler and consistent format.
-
-    Sets up a :class:`~logging.StreamHandler` writing to stdout with the
-    given format and level.  Also configures the uvicorn loggers so that
-    FastAPI access logs use the same format.
-
-    Calling this function multiple times is safe -- existing handlers are
-    replaced rather than duplicated.
-
-    Args:
-        level: Log level (e.g. ``"DEBUG"``, ``"INFO"``, or ``logging.DEBUG``).
-        fmt: Log format string.  Defaults to
-            ``"%(asctime)s - %(name)s - %(levelname)s - %(message)s"``.
-        logger_name: Logger name to configure.  ``None`` (the default)
-            configures the root logger so all loggers inherit the settings.
-
-    Returns:
-        The configured Logger instance.
-
-    Example:
-        ```python
-        from fastapi_toolsets.logger import configure_logging
-
-        logger = configure_logging("DEBUG")
-        logger.info("Application started")
-        ```
-    """
-    formatter = logging.Formatter(fmt)
-
-    handler = logging.StreamHandler(sys.stdout)
-    handler.setFormatter(formatter)
-
-    logger = logging.getLogger(logger_name)
-    logger.handlers.clear()
-    logger.addHandler(handler)
-    logger.setLevel(level)
-
-    for name in UVICORN_LOGGERS:
-        uv_logger = logging.getLogger(name)
-        uv_logger.handlers.clear()
-        uv_logger.addHandler(handler)
-        uv_logger.setLevel(level)
-
-    return logger
-
-
-_SENTINEL = object()
-
-
-def get_logger(name: str | None = _SENTINEL) -> logging.Logger:  # type: ignore[assignment]  # ty:ignore[invalid-parameter-default]
-    """Return a logger with the given *name*.
-
-    A thin convenience wrapper around :func:`logging.getLogger` that keeps
-    logging imports consistent across the codebase.
-
-    When called without arguments, the caller's ``__name__`` is used
-    automatically, so ``get_logger()`` in a module is equivalent to
-    ``logging.getLogger(__name__)``.  Pass ``None`` explicitly to get the
-    root logger.
-
-    Args:
-        name: Logger name.  Defaults to the caller's ``__name__``.
-            Pass ``None`` to get the root logger.
-
-    Returns:
-        A Logger instance.
-
-    Example:
-        ```python
-        from fastapi_toolsets.logger import get_logger
-
-        logger = get_logger()          # uses caller's __name__
-        logger = get_logger("myapp")   # explicit name
-        logger = get_logger(None)      # root logger
-        ```
-    """
-    if name is _SENTINEL:
-        name = sys._getframe(1).f_globals.get("__name__")
-    return logging.getLogger(name)
@@ -1,21 +0,0 @@
-"""Prometheus metrics integration for FastAPI applications."""
-
-from typing import Any
-
-from .registry import Metric, MetricsRegistry
-
-try:
-    from .handler import init_metrics
-except ImportError:
-
-    def init_metrics(*_args: Any, **_kwargs: Any) -> None:
-        from .._imports import require_extra
-
-        require_extra(package="prometheus_client", extra="metrics")
-
-
-__all__ = [
-    "Metric",
-    "MetricsRegistry",
-    "init_metrics",
-]
@@ -1,81 +0,0 @@
-"""Prometheus metrics endpoint for FastAPI applications."""
-
-import inspect
-import os
-
-from fastapi import FastAPI
-from fastapi.responses import Response
-from prometheus_client import (
-    CONTENT_TYPE_LATEST,
-    CollectorRegistry,
-    generate_latest,
-    multiprocess,
-)
-
-from ..logger import get_logger
-from .registry import MetricsRegistry
-
-logger = get_logger()
-
-
-def _is_multiprocess() -> bool:
-    """Check if prometheus multi-process mode is enabled."""
-    return "PROMETHEUS_MULTIPROC_DIR" in os.environ
-
-
-def init_metrics(
-    app: FastAPI,
-    registry: MetricsRegistry,
-    *,
-    path: str = "/metrics",
-) -> FastAPI:
-    """Register a Prometheus ``/metrics`` endpoint on a FastAPI app.
-
-    Args:
-        app: FastAPI application instance.
-        registry: A :class:`MetricsRegistry` containing providers and collectors.
-        path: URL path for the metrics endpoint (default ``/metrics``).
-
-    Returns:
-        The same FastAPI instance (for chaining).
-
-    Example:
-        ```python
-        from fastapi import FastAPI
-        from fastapi_toolsets.metrics import MetricsRegistry, init_metrics
-
-        metrics = MetricsRegistry()
-        app = FastAPI()
-        init_metrics(app, registry=metrics)
-        ```
-    """
-    for provider in registry.get_providers():
-        logger.debug("Initialising metric provider '%s'", provider.name)
-        registry._instances[provider.name] = provider.func()
-
-    # Partition collectors and cache env check at startup — both are stable for the app lifetime.
-    async_collectors = [
-        c for c in registry.get_collectors() if inspect.iscoroutinefunction(c.func)
-    ]
-    sync_collectors = [
-        c for c in registry.get_collectors() if not inspect.iscoroutinefunction(c.func)
-    ]
-    multiprocess_mode = _is_multiprocess()
-
-    @app.get(path, include_in_schema=False)
-    async def metrics_endpoint() -> Response:
-        for collector in sync_collectors:
-            collector.func()
-        for collector in async_collectors:
-            await collector.func()
-
-        if multiprocess_mode:
-            prom_registry = CollectorRegistry()
-            multiprocess.MultiProcessCollector(prom_registry)
-            output = generate_latest(prom_registry)
-        else:
-            output = generate_latest()
-
-        return Response(content=output, media_type=CONTENT_TYPE_LATEST)
-
-    return app
@@ -1,104 +0,0 @@
-"""Metrics registry with decorator-based registration."""
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any, cast
-
-from ..logger import get_logger
-
-logger = get_logger()
-
-
-@dataclass
-class Metric:
-    """A metric definition with metadata."""
-
-    name: str
-    func: Callable[..., Any]
-    collect: bool = field(default=False)
-
-
-class MetricsRegistry:
-    """Registry for managing Prometheus metric providers and collectors."""
-
-    def __init__(self) -> None:
-        self._metrics: dict[str, Metric] = {}
-        self._instances: dict[str, Any] = {}
-
-    def register(
-        self,
-        func: Callable[..., Any] | None = None,
-        *,
-        name: str | None = None,
-        collect: bool = False,
-    ) -> Callable[..., Any]:
-        """Register a metric provider or collector function.
-
-        Can be used as a decorator with or without arguments.
-
-        Args:
-            func: The metric function to register.
-            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.
-        """
-
-        def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
-            metric_name = name or cast(Any, fn).__name__
-            self._metrics[metric_name] = Metric(
-                name=metric_name,
-                func=fn,
-                collect=collect,
-            )
-            return fn
-
-        if func is not None:
-            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.
-
-        Args:
-            registry: The registry to merge in.
-
-        Raises:
-            ValueError: If a metric name already exists in the current registry.
-        """
-        for metric_name, definition in registry._metrics.items():
-            if metric_name in self._metrics:
-                raise ValueError(
-                    f"Metric '{metric_name}' already exists in the current registry"
-                )
-            self._metrics[metric_name] = definition
-
-    def get_all(self) -> list[Metric]:
-        """Get all registered metric definitions."""
-        return list(self._metrics.values())
-
-    def get_providers(self) -> list[Metric]:
-        """Get metric providers (called once at init)."""
-        return [m for m in self._metrics.values() if not m.collect]
-
-    def get_collectors(self) -> list[Metric]:
-        """Get collectors (called on each scrape)."""
-        return [m for m in self._metrics.values() if m.collect]
@@ -1,21 +0,0 @@
-"""SQLAlchemy model mixins for common column patterns."""
-
-from .columns import (
-    CreatedAtMixin,
-    TimestampMixin,
-    UUIDMixin,
-    UUIDv7Mixin,
-    UpdatedAtMixin,
-)
-from .watched import EventSession, ModelEvent, listens_for
-
-__all__ = [
-    "EventSession",
-    "ModelEvent",
-    "UUIDMixin",
-    "UUIDv7Mixin",
-    "CreatedAtMixin",
-    "UpdatedAtMixin",
-    "TimestampMixin",
-    "listens_for",
-]
@@ -1,50 +0,0 @@
-"""SQLAlchemy column mixins for common column patterns."""
-
-import uuid
-from datetime import datetime
-
-from sqlalchemy import DateTime, Uuid, text
-from sqlalchemy.orm import Mapped, mapped_column
-
-
-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 UUIDv7Mixin:
-    """Mixin that adds a UUIDv7 primary key auto-generated by the database."""
-
-    id: Mapped[uuid.UUID] = mapped_column(
-        Uuid,
-        primary_key=True,
-        server_default=text("uuidv7()"),
-    )
-
-
-class CreatedAtMixin:
-    """Mixin that adds a ``created_at`` timestamp column."""
-
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        server_default=text("clock_timestamp()"),
-    )
-
-
-class UpdatedAtMixin:
-    """Mixin that adds an ``updated_at`` timestamp column."""
-
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        server_default=text("clock_timestamp()"),
-        onupdate=text("clock_timestamp()"),
-    )
-
-
-class TimestampMixin(CreatedAtMixin, UpdatedAtMixin):
-    """Mixin that combines ``created_at`` and ``updated_at`` timestamp columns."""
@@ -1,290 +0,0 @@
-"""Field-change monitoring via SQLAlchemy session events."""
-
-import inspect
-from collections.abc import Callable
-from enum import Enum
-from typing import Any
-
-from sqlalchemy import event
-from sqlalchemy import inspect as sa_inspect
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm.attributes import set_committed_value as _sa_set_committed_value
-
-from ..logger import get_logger
-
-_logger = get_logger()
-
-
-class ModelEvent(str, Enum):
-    """Event types dispatched by :class:`EventSession`."""
-
-    CREATE = "create"
-    DELETE = "delete"
-    UPDATE = "update"
-
-
-_CALLBACK_ERROR_MSG = "Event callback raised an unhandled exception"
-_SESSION_CREATES = "_ft_creates"
-_SESSION_DELETES = "_ft_deletes"
-_SESSION_UPDATES = "_ft_updates"
-_DEFERRED_STRATEGY_KEY = (("deferred", True), ("instrument", True))
-_EVENT_HANDLERS: dict[tuple[type, ModelEvent], list[Callable[..., Any]]] = {}
-_WATCHED_MODELS: set[type] = set()
-_WATCHED_CACHE: dict[type, bool] = {}
-_HANDLER_CACHE: dict[tuple[type, ModelEvent], list[Callable[..., Any]]] = {}
-
-
-def _invalidate_caches() -> None:
-    """Clear lookup caches after handler registration."""
-    _WATCHED_CACHE.clear()
-    _HANDLER_CACHE.clear()
-
-
-def listens_for(
-    model_class: type,
-    event_types: list[ModelEvent] | None = None,
-) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
-    """Register a callback for one or more model lifecycle events.
-
-    Args:
-        model_class: The SQLAlchemy model class to listen on.
-        event_types: List of :class:`ModelEvent` values to listen for.
-            Defaults to all event types.
-    """
-    evs = event_types if event_types is not None else list(ModelEvent)
-
-    def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
-        for ev in evs:
-            _EVENT_HANDLERS.setdefault((model_class, ev), []).append(fn)
-        _WATCHED_MODELS.add(model_class)
-        _invalidate_caches()
-        return fn
-
-    return decorator
-
-
-def _is_watched(obj: Any) -> bool:
-    """Return True if *obj*'s type (or any ancestor) has registered handlers."""
-    cls = type(obj)
-    try:
-        return _WATCHED_CACHE[cls]
-    except KeyError:
-        result = any(klass in _WATCHED_MODELS for klass in cls.__mro__)
-        _WATCHED_CACHE[cls] = result
-        return result
-
-
-def _get_handlers(cls: type, ev: ModelEvent) -> list[Callable[..., Any]]:
-    """Return registered handlers for *cls* and *ev*, walking the MRO."""
-    key = (cls, ev)
-    try:
-        return _HANDLER_CACHE[key]
-    except KeyError:
-        handlers: list[Callable[..., Any]] = []
-        for klass in cls.__mro__:
-            handlers.extend(_EVENT_HANDLERS.get((klass, ev), []))
-        _HANDLER_CACHE[key] = handlers
-        return handlers
-
-
-def _snapshot_column_attrs(obj: Any) -> dict[str, Any]:
-    """Read currently-loaded column values into a plain dict."""
-    state = sa_inspect(obj)  # InstanceState
-    state_dict = state.dict
-    snapshot: dict[str, Any] = {}
-    for prop in state.mapper.column_attrs:
-        if prop.key in state_dict:
-            snapshot[prop.key] = state_dict[prop.key]
-        elif (  # pragma: no cover
-            not state.expired
-            and prop.strategy_key != _DEFERRED_STRATEGY_KEY
-            and all(
-                col.nullable
-                and col.server_default is None
-                and col.server_onupdate is None
-                for col in prop.columns
-            )
-        ):
-            snapshot[prop.key] = None
-    return snapshot
-
-
-def _get_watched_fields(cls: type) -> tuple[str, ...] | None:
-    """Return the watched fields for *cls*."""
-    fields = getattr(cls, "__watched_fields__", None)
-    if fields is not None and (
-        not isinstance(fields, tuple) or not all(isinstance(f, str) for f in fields)
-    ):
-        raise TypeError(
-            f"{cls.__name__}.__watched_fields__ must be a tuple[str, ...], "
-            f"got {type(fields).__name__}"
-        )
-    return fields
-
-
-def _upsert_changes(
-    pending: dict[int, tuple[Any, dict[str, dict[str, Any]]]],
-    obj: Any,
-    changes: dict[str, dict[str, Any]],
-) -> None:
-    """Insert or merge *changes* into *pending* for *obj*."""
-    key = id(obj)
-    if key in pending:
-        existing = pending[key][1]
-        for field, change in changes.items():
-            if field in existing:
-                existing[field]["new"] = change["new"]
-            else:
-                existing[field] = change
-    else:
-        pending[key] = (obj, changes)
-
-
-@event.listens_for(AsyncSession.sync_session_class, "after_flush")
-def _after_flush(session: Any, flush_context: Any) -> None:
-    # New objects: capture reference. Attributes will be refreshed after commit.
-    for obj in session.new:
-        if _is_watched(obj):
-            session.info.setdefault(_SESSION_CREATES, []).append(obj)
-
-    # Deleted objects: snapshot now while attributes are still loaded.
-    for obj in session.deleted:
-        if _is_watched(obj):
-            snapshot = _snapshot_column_attrs(obj)
-            session.info.setdefault(_SESSION_DELETES, []).append((obj, snapshot))
-
-    # Dirty objects: read old/new from SQLAlchemy attribute history.
-    for obj in session.dirty:
-        if not _is_watched(obj):
-            continue
-
-        watched = _get_watched_fields(type(obj))
-        changes: dict[str, dict[str, Any]] = {}
-
-        inst_attrs = sa_inspect(obj).attrs
-        attrs = (
-            ((field, inst_attrs[field]) for field in watched)
-            if watched is not None
-            else ((s.key, s) for s in inst_attrs)
-        )
-        for field, attr_state in attrs:
-            history = attr_state.history
-            if history.has_changes() and history.deleted:
-                changes[field] = {
-                    "old": history.deleted[0],
-                    "new": history.added[0] if history.added else None,
-                }
-
-        if changes:
-            _upsert_changes(
-                session.info.setdefault(_SESSION_UPDATES, {}),
-                obj,
-                changes,
-            )
-
-
-@event.listens_for(AsyncSession.sync_session_class, "after_rollback")
-def _after_rollback(session: Any) -> None:
-    if session.in_transaction():
-        return
-    session.info.pop(_SESSION_CREATES, None)
-    session.info.pop(_SESSION_DELETES, None)
-    session.info.pop(_SESSION_UPDATES, None)
-
-
-async def _invoke_callback(
-    fn: Callable[..., Any],
-    obj: Any,
-    event_type: ModelEvent,
-    changes: dict[str, dict[str, Any]] | None,
-) -> None:
-    """Call *fn* and await the result if it is awaitable."""
-    result = fn(obj, event_type, changes)
-    if inspect.isawaitable(result):
-        await result
-
-
-class EventSession(AsyncSession):
-    """AsyncSession subclass that dispatches lifecycle callbacks after commit."""
-
-    async def commit(self) -> None:  # noqa: C901
-        await super().commit()
-
-        creates: list[Any] = self.info.pop(_SESSION_CREATES, [])
-        deletes: list[tuple[Any, dict[str, Any]]] = self.info.pop(_SESSION_DELETES, [])
-        field_changes: dict[int, tuple[Any, dict[str, dict[str, Any]]]] = self.info.pop(
-            _SESSION_UPDATES, {}
-        )
-
-        if not creates and not deletes and not field_changes:
-            return
-
-        # Suppress transient objects (created + deleted in same transaction).
-        if creates and deletes:
-            created_ids = {id(o) for o in creates}
-            deleted_ids = {id(o) for o, _ in deletes}
-            transient_ids = created_ids & deleted_ids
-            if transient_ids:
-                creates = [o for o in creates if id(o) not in transient_ids]
-                deletes = [(o, s) for o, s in deletes if id(o) not in transient_ids]
-                field_changes = {
-                    k: v for k, v in field_changes.items() if k not in transient_ids
-                }
-
-        # Suppress updates for deleted objects (row is gone, refresh would fail).
-        if deletes and field_changes:
-            deleted_ids = {id(o) for o, _ in deletes}
-            field_changes = {
-                k: v for k, v in field_changes.items() if k not in deleted_ids
-            }
-
-        # Suppress updates for newly created objects (CREATE-only semantics).
-        if creates and field_changes:
-            create_ids = {id(o) for o in creates}
-            field_changes = {
-                k: v for k, v in field_changes.items() if k not in create_ids
-            }
-
-        # Dispatch CREATE callbacks.
-        for obj in creates:
-            try:
-                state = sa_inspect(obj, raiseerr=False)
-                if (
-                    state is None or state.detached or state.transient
-                ):  # pragma: no cover
-                    continue
-                await self.refresh(obj)
-                for handler in _get_handlers(type(obj), ModelEvent.CREATE):
-                    await _invoke_callback(handler, obj, ModelEvent.CREATE, None)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-        # Dispatch DELETE callbacks (restore snapshot; row is gone).
-        for obj, snapshot in deletes:
-            try:
-                for key, value in snapshot.items():
-                    _sa_set_committed_value(obj, key, value)
-                for handler in _get_handlers(type(obj), ModelEvent.DELETE):
-                    await _invoke_callback(handler, obj, ModelEvent.DELETE, None)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-        # Dispatch UPDATE callbacks.
-        for obj, changes in field_changes.values():
-            try:
-                state = sa_inspect(obj, raiseerr=False)
-                if (
-                    state is None or state.detached or state.transient
-                ):  # pragma: no cover
-                    continue
-                await self.refresh(obj)
-                for handler in _get_handlers(type(obj), ModelEvent.UPDATE):
-                    await _invoke_callback(handler, obj, ModelEvent.UPDATE, changes)
-            except Exception as exc:
-                _logger.error(_CALLBACK_ERROR_MSG, exc_info=exc)
-
-    async def rollback(self) -> None:
-        await super().rollback()
-        self.info.pop(_SESSION_CREATES, None)
-        self.info.pop(_SESSION_DELETES, None)
-        self.info.pop(_SESSION_UPDATES, None)
@@ -1,30 +0,0 @@
-"""Pytest helpers for FastAPI testing: sessions, clients, and fixtures."""
-
-try:
-    from .plugin import register_fixtures
-except ImportError:
-    from .._imports import require_extra
-
-    require_extra(package="pytest", extra="pytest")
-
-try:
-    from .utils import (
-        cleanup_tables,
-        create_async_client,
-        create_db_session,
-        create_worker_database,
-        worker_database_url,
-    )
-except ImportError:
-    from .._imports import require_extra
-
-    require_extra(package="httpx", extra="pytest")
-
-__all__ = [
-    "cleanup_tables",
-    "create_async_client",
-    "create_db_session",
-    "create_worker_database",
-    "register_fixtures",
-    "worker_database_url",
-]
@@ -1,210 +0,0 @@
-"""Pytest plugin for using FixtureRegistry fixtures in tests."""
-
-from collections.abc import Callable, Sequence
-from typing import Any, cast
-
-import pytest
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase, selectinload
-from sqlalchemy.orm.interfaces import ExecutableOption, ORMOption
-
-from ..db import get_transaction
-from ..fixtures import FixtureRegistry, LoadStrategy
-
-
-def register_fixtures(
-    registry: FixtureRegistry,
-    namespace: dict[str, Any],
-    *,
-    prefix: str = "fixture_",
-    session_fixture: str = "db_session",
-    strategy: LoadStrategy = LoadStrategy.MERGE,
-) -> list[str]:
-    """Register pytest fixtures from a FixtureRegistry.
-
-    Automatically creates pytest fixtures for each fixture in the registry.
-    Dependencies are resolved via pytest fixture dependencies.
-
-    Args:
-        registry: The FixtureRegistry containing fixtures
-        namespace: The module's globals() dict to add fixtures to
-        prefix: Prefix for generated fixture names (default: "fixture_")
-        session_fixture: Name of the db session fixture (default: "db_session")
-        strategy: Loading strategy for fixtures (default: MERGE)
-
-    Returns:
-        List of created fixture names
-
-    Example:
-        ```python
-        # conftest.py
-        from app.fixtures import fixtures
-        from fastapi_toolsets.pytest_plugin import register_fixtures
-
-        register_fixtures(fixtures, globals())
-
-        # Creates fixtures like:
-        # - fixture_roles
-        # - fixture_users (depends on fixture_roles if users depends on roles)
-        # - fixture_posts (depends on fixture_users if posts depends on users)
-        ```
-    """
-    created_fixtures: list[str] = []
-
-    for fixture in registry.get_all():
-        fixture_name = f"{prefix}{fixture.name}"
-
-        # Build list of pytest fixture dependencies
-        pytest_deps = [session_fixture]
-        for dep in fixture.depends_on:
-            pytest_deps.append(f"{prefix}{dep}")
-
-        # Create the fixture function
-        fixture_func = _create_fixture_function(
-            registry=registry,
-            fixture_name=fixture.name,
-            dependencies=pytest_deps,
-            strategy=strategy,
-        )
-
-        # Apply pytest.fixture decorator
-        decorated = pytest.fixture(fixture_func)
-
-        # Add to namespace
-        namespace[fixture_name] = decorated
-        created_fixtures.append(fixture_name)
-
-    return created_fixtures
-
-
-def _create_fixture_function(
-    registry: FixtureRegistry,
-    fixture_name: str,
-    dependencies: list[str],
-    strategy: LoadStrategy,
-) -> Callable[..., Any]:
-    """Create a fixture function with the correct signature.
-
-    The function signature must include all dependencies as parameters
-    for pytest to resolve them correctly.
-    """
-    # Get the fixture definition
-    fixture_def = registry.get(fixture_name)
-
-    # Build the function dynamically with correct parameters
-    # We need the session as first param, then all dependencies
-    async def fixture_func(**kwargs: Any) -> Sequence[DeclarativeBase]:
-        # Get session from kwargs (first dependency)
-        session: AsyncSession = kwargs[dependencies[0]]
-
-        # Load the fixture data
-        instances = list(fixture_def.func())
-
-        if not instances:
-            return []
-
-        loaded: list[DeclarativeBase] = []
-
-        async with get_transaction(session):
-            for instance in instances:
-                if strategy == LoadStrategy.INSERT:
-                    session.add(instance)
-                    loaded.append(instance)
-                elif strategy == LoadStrategy.MERGE:
-                    merged = await session.merge(instance)
-                    loaded.append(merged)
-                elif strategy == LoadStrategy.SKIP_EXISTING:  # pragma: no branch
-                    pk = _get_primary_key(instance)
-                    if pk is not None:
-                        existing = await session.get(type(instance), pk)
-                        if existing is None:
-                            session.add(instance)
-                            loaded.append(instance)
-                        else:
-                            loaded.append(existing)
-                    else:
-                        session.add(instance)
-                        loaded.append(instance)
-
-        if loaded:  # pragma: no branch
-            load_options = _relationship_load_options(type(loaded[0]))
-            if load_options:
-                return await _reload_with_relationships(session, loaded, load_options)
-
-        return loaded
-
-    # Update function signature to include dependencies
-    # This is needed for pytest to inject the right fixtures
-    params = ", ".join(dependencies)
-    code = f"async def {fixture_name}_fixture({params}):\n    return await _impl({', '.join(f'{d}={d}' for d in dependencies)})"
-
-    local_ns: dict[str, Any] = {"_impl": fixture_func}
-    exec(code, local_ns)  # noqa: S102
-
-    created_func = local_ns[f"{fixture_name}_fixture"]
-    created_func.__doc__ = f"Load {fixture_name} fixture data."
-
-    return created_func
-
-
-def _relationship_load_options(model: type[DeclarativeBase]) -> list[ExecutableOption]:
-    """Build selectinload options for all direct relationships on a model."""
-    return [
-        selectinload(getattr(model, rel.key)) for rel in model.__mapper__.relationships
-    ]
-
-
-async def _reload_with_relationships(
-    session: AsyncSession,
-    instances: list[DeclarativeBase],
-    load_options: list[ExecutableOption],
-) -> list[DeclarativeBase]:
-    """Reload instances in a single bulk query with relationship eager-loading.
-
-    Uses one SELECT … WHERE pk IN (…) so selectinload can batch all relationship
-    queries — 1 + N_relationships round-trips regardless of how many instances
-    there are, instead of one session.get() per instance.
-
-    Preserves the original insertion order.
-    """
-    model = type(instances[0])
-    mapper = model.__mapper__
-    pk_cols = mapper.primary_key
-
-    if len(pk_cols) == 1:
-        pk_attr = getattr(model, pk_cols[0].key)
-        pks = [getattr(inst, pk_cols[0].key) for inst in instances]
-        result = await session.execute(
-            select(model).where(pk_attr.in_(pks)).options(*load_options)
-        )
-        by_pk = {getattr(row, pk_cols[0].key): row for row in result.unique().scalars()}
-        return [by_pk[pk] for pk in pks]
-
-    # Composite PK: fall back to per-instance reload
-    reloaded: list[DeclarativeBase] = []
-    for instance in instances:
-        pk = _get_primary_key(instance)
-        refreshed = await session.get(
-            model,
-            pk,
-            options=cast(list[ORMOption], load_options),
-            populate_existing=True,
-        )
-        if refreshed is not None:  # pragma: no branch
-            reloaded.append(refreshed)
-    return reloaded
-
-
-def _get_primary_key(instance: DeclarativeBase) -> Any | None:
-    """Get the primary key value of a model instance."""
-    mapper = instance.__class__.__mapper__
-    pk_cols = mapper.primary_key
-
-    if len(pk_cols) == 1:
-        return getattr(instance, pk_cols[0].name, None)
-
-    pk_values = tuple(getattr(instance, col.name, None) for col in pk_cols)
-    if all(v is not None for v in pk_values):
-        return pk_values
-    return None
@@ -1,260 +0,0 @@
-"""Pytest helper utilities for FastAPI testing."""
-
-import os
-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,
-    async_sessionmaker,
-    create_async_engine,
-)
-from sqlalchemy.orm import DeclarativeBase
-
-from ..db import cleanup_tables, create_database
-from ..models.watched import EventSession
-
-
-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 = make_url(worker_url).database
-    assert worker_db_name is not None
-
-    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()
-
-
-@asynccontextmanager
-async def create_async_client(
-    app: Any,
-    base_url: str = "http://test",
-    dependency_overrides: dict[Callable[..., Any], Callable[..., Any]] | None = None,
-) -> AsyncGenerator[AsyncClient, None]:
-    """Create an async httpx client for testing FastAPI applications.
-
-    Args:
-        app: FastAPI application instance.
-        base_url: Base URL for requests. Defaults to "http://test".
-        dependency_overrides: Optional mapping of original dependencies to
-            their test replacements. Applied via ``app.dependency_overrides``
-            before yielding and cleaned up after.
-
-    Yields:
-        An AsyncClient configured for the app.
-
-    Example:
-        ```python
-        from fastapi import FastAPI
-        from fastapi_toolsets.pytest import create_async_client
-
-        app = FastAPI()
-
-        @pytest.fixture
-        async def client():
-            async with create_async_client(app) as c:
-                yield c
-
-        async def test_endpoint(client: AsyncClient):
-            response = await client.get("/health")
-            assert response.status_code == 200
-        ```
-
-    Example with dependency overrides:
-        ```python
-        from fastapi_toolsets.pytest import create_async_client, create_db_session
-        from app.db import get_db
-
-        @pytest.fixture
-        async def db_session():
-            async with create_db_session(DATABASE_URL, Base, cleanup=True) as session:
-                yield session
-
-        @pytest.fixture
-        async def client(db_session):
-            async def override():
-                yield db_session
-
-            async with create_async_client(
-                app, dependency_overrides={get_db: override}
-            ) as c:
-                yield c
-        ```
-    """
-    if dependency_overrides:
-        app.dependency_overrides.update(dependency_overrides)
-
-    transport = ASGITransport(app=app)
-    try:
-        async with AsyncClient(transport=transport, base_url=base_url) as client:
-            yield client
-    finally:
-        if dependency_overrides:
-            for key in dependency_overrides:
-                app.dependency_overrides.pop(key, None)
-
-
-@asynccontextmanager
-async def create_db_session(
-    database_url: str,
-    base: type[DeclarativeBase],
-    *,
-    echo: bool = False,
-    expire_on_commit: bool = False,
-    drop_tables: bool = True,
-    cleanup: bool = False,
-) -> AsyncGenerator[AsyncSession, None]:
-    """Create a database session for testing.
-
-    Creates tables before yielding the session and optionally drops them after.
-    Each call creates a fresh engine and session for test isolation.
-
-    Args:
-        database_url: Database connection URL (e.g., "postgresql+asyncpg://...").
-        base: SQLAlchemy DeclarativeBase class containing model metadata.
-        echo: Enable SQLAlchemy query logging. Defaults to False.
-        expire_on_commit: Expire objects after commit. Defaults to False.
-        drop_tables: Drop tables after test. Defaults to True.
-        cleanup: Truncate all tables after test using
-            :func:`cleanup_tables`. Defaults to False.
-
-    Yields:
-        An AsyncSession ready for database operations.
-
-    Example:
-        ```python
-        from fastapi_toolsets.pytest import create_db_session
-        from app.models import Base
-
-        DATABASE_URL = "postgresql+asyncpg://user:pass@localhost/test_db"
-
-        @pytest.fixture
-        async def db_session():
-            async with create_db_session(
-                DATABASE_URL, Base, cleanup=True
-            ) as session:
-                yield session
-
-        async def test_create_user(db_session: AsyncSession):
-            user = User(name="test")
-            db_session.add(user)
-            await db_session.commit()
-        ```
-    """
-    engine = create_async_engine(database_url, echo=echo)
-
-    try:
-        # Create tables
-        async with engine.begin() as conn:
-            await conn.run_sync(base.metadata.create_all)
-
-        session_maker = async_sessionmaker(
-            engine, expire_on_commit=expire_on_commit, class_=EventSession
-        )
-        async with session_maker() as session:
-            yield session
-
-            if cleanup:
-                await cleanup_tables(session=session, base=base)
-
-        if drop_tables:
-            async with engine.begin() as conn:
-                await conn.run_sync(base.metadata.drop_all)
-    finally:
-        await engine.dispose()
@@ -1,206 +0,0 @@
-"""Base Pydantic schemas for API responses."""
-
-import math
-from enum import Enum
-from typing import Annotated, Any, ClassVar, Generic, Literal, TypeVar, Union
-
-from pydantic import BaseModel, ConfigDict, Field, computed_field
-
-from .types import DataT
-
-__all__ = [
-    "ApiError",
-    "CursorPagination",
-    "CursorPaginatedResponse",
-    "ErrorResponse",
-    "OffsetPagination",
-    "OffsetPaginatedResponse",
-    "PaginatedResponse",
-    "PaginationType",
-    "PydanticBase",
-    "Response",
-    "ResponseStatus",
-]
-
-
-class PydanticBase(BaseModel):
-    """Base class for all Pydantic models with common configuration."""
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(
-        from_attributes=True,
-        validate_assignment=True,
-    )
-
-
-class ResponseStatus(str, Enum):
-    """Standard API response status."""
-
-    SUCCESS = "SUCCESS"
-    FAIL = "FAIL"
-
-
-class ApiError(PydanticBase):
-    """Structured API error definition.
-
-    Used to define standard error responses with consistent format.
-
-    Attributes:
-        code: HTTP status code
-        msg: Short error message
-        desc: Detailed error description
-        err_code: Application-specific error code (e.g., "AUTH-401")
-    """
-
-    code: int
-    msg: str
-    desc: str
-    err_code: str
-    data: Any | None = None
-
-
-class BaseResponse(PydanticBase):
-    """Base response structure for all API responses.
-
-    Attributes:
-        status: SUCCESS or FAIL
-        message: Human-readable message
-        error_code: Error code if status is FAIL, None otherwise
-    """
-
-    status: ResponseStatus = ResponseStatus.SUCCESS
-    message: str = "Success"
-    error_code: str | None = None
-
-
-class Response(BaseResponse, Generic[DataT]):
-    """Generic API response with data payload.
-
-    Example:
-        ```python
-        Response[UserRead](data=user, message="User retrieved")
-        ```
-    """
-
-    data: DataT | None = None
-
-
-class ErrorResponse(BaseResponse):
-    """Error response with additional description field.
-
-    Used for error responses that need more context.
-    """
-
-    status: ResponseStatus = ResponseStatus.FAIL
-    description: str | None = None
-    data: Any | None = None
-
-
-class OffsetPagination(PydanticBase):
-    """Pagination metadata for offset-based list responses.
-
-    Attributes:
-        total_count: Total number of items across all pages.
-            ``None`` when ``include_total=False``.
-        items_per_page: Number of items per page
-        page: Current page number (1-indexed)
-        has_more: Whether there are more pages
-        pages: Total number of pages
-    """
-
-    total_count: int | None
-    items_per_page: int
-    page: int
-    has_more: bool
-
-    @computed_field
-    @property
-    def pages(self) -> int | None:
-        """Total number of pages, or ``None`` when ``total_count`` is unknown."""
-        if self.total_count is None:
-            return None
-        if self.items_per_page == 0:
-            return 0
-        return math.ceil(self.total_count / self.items_per_page)
-
-
-class CursorPagination(PydanticBase):
-    """Pagination metadata for cursor-based list responses.
-
-    Attributes:
-        next_cursor: Encoded cursor for the next page, or None on the last page.
-        prev_cursor: Encoded cursor for the previous page, or None on the first page.
-        items_per_page: Number of items requested per page.
-        has_more: Whether there is at least one more page after this one.
-    """
-
-    next_cursor: str | None
-    prev_cursor: str | None = None
-    items_per_page: int
-    has_more: bool
-
-
-class PaginationType(str, Enum):
-    """Pagination strategy selector for :meth:`.AsyncCrud.paginate`."""
-
-    OFFSET = "offset"
-    CURSOR = "cursor"
-
-
-class PaginatedResponse(BaseResponse, Generic[DataT]):
-    """Paginated API response for list endpoints.
-
-    Base class and return type for endpoints that support both pagination
-    strategies.  Use :class:`OffsetPaginatedResponse` or
-    :class:`CursorPaginatedResponse` when the strategy is fixed.
-
-    When used as ``PaginatedResponse[T]`` in a return annotation, subscripting
-    returns ``Annotated[Union[CursorPaginatedResponse[T], OffsetPaginatedResponse[T]], Field(discriminator="pagination_type")]``
-    so FastAPI emits a proper ``oneOf`` + discriminator in the OpenAPI schema.
-    """
-
-    data: list[DataT]
-    pagination: OffsetPagination | CursorPagination
-    pagination_type: PaginationType | None = None
-    filter_attributes: dict[str, list[Any]] | None = None
-    search_columns: list[str] | None = None
-    order_columns: list[str] | None = None
-
-    _discriminated_union_cache: ClassVar[dict[Any, Any]] = {}
-
-    def __class_getitem__(  # ty:ignore[invalid-method-override]
-        cls, item: type[Any] | tuple[type[Any], ...]
-    ) -> type[Any]:
-        if cls is PaginatedResponse and not isinstance(item, TypeVar):
-            cached = cls._discriminated_union_cache.get(item)
-            if cached is None:
-                cached = Annotated[
-                    Union[CursorPaginatedResponse[item], OffsetPaginatedResponse[item]],  # ty:ignore[invalid-type-form]
-                    Field(discriminator="pagination_type"),
-                ]
-                cls._discriminated_union_cache[item] = cached
-            return cached  # ty:ignore[invalid-return-type]
-        return super().__class_getitem__(item)
-
-
-class OffsetPaginatedResponse(PaginatedResponse[DataT]):
-    """Paginated response with typed offset-based pagination metadata.
-
-    The ``pagination_type`` field is always ``"offset"`` and acts as a
-    discriminator, allowing frontend clients to narrow the union type returned
-    by a unified ``paginate()`` endpoint.
-    """
-
-    pagination: OffsetPagination
-    pagination_type: Literal[PaginationType.OFFSET] = PaginationType.OFFSET
-
-
-class CursorPaginatedResponse(PaginatedResponse[DataT]):
-    """Paginated response with typed cursor-based pagination metadata.
-
-    The ``pagination_type`` field is always ``"cursor"`` and acts as a
-    discriminator, allowing frontend clients to narrow the union type returned
-    by a unified ``paginate()`` endpoint.
-    """
-
-    pagination: CursorPagination
-    pagination_type: Literal[PaginationType.CURSOR] = PaginationType.CURSOR
@@ -1,28 +0,0 @@
-"""Shared type aliases for the fastapi-toolsets package."""
-
-from collections.abc import AsyncGenerator, Callable, Mapping
-from typing import Any, TypeVar
-
-from pydantic import BaseModel
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
-from sqlalchemy.orm.attributes import InstrumentedAttribute
-from sqlalchemy.sql.elements import ColumnElement
-
-# Generic TypeVars
-DataT = TypeVar("DataT")
-ModelType = TypeVar("ModelType", bound=DeclarativeBase)
-SchemaType = TypeVar("SchemaType", bound=BaseModel)
-
-# CRUD type aliases
-JoinType = list[tuple[type[DeclarativeBase] | Any, Any]]
-M2MFieldType = Mapping[str, QueryableAttribute[Any]]
-OrderByClause = ColumnElement[Any] | QueryableAttribute[Any]
-
-# Search / facet / order type aliases
-SearchFieldType = InstrumentedAttribute[Any] | tuple[InstrumentedAttribute[Any], ...]
-FacetFieldType = SearchFieldType
-OrderFieldType = SearchFieldType
-
-# Dependency type aliases
-SessionDependency = Callable[[], AsyncGenerator[AsyncSession, None]] | Any
@@ -0,0 +1 @@
+v5.1
@@ -1 +0,0 @@
-"""Tests for fastapi-utils package."""
@@ -1,463 +0,0 @@
-"""Shared pytest fixtures for fastapi-utils tests."""
-
-import os
-import uuid
-from enum import Enum
-
-import pytest
-from pydantic import BaseModel
-import datetime
-import decimal
-
-from sqlalchemy import (
-    Column,
-    Date,
-    DateTime,
-    Enum as SAEnum,
-    ForeignKey,
-    Integer,
-    JSON,
-    Numeric,
-    String,
-    Table,
-    Uuid,
-)
-from sqlalchemy.dialects.postgresql import ARRAY
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
-
-from fastapi_toolsets.crud import CrudFactory
-from fastapi_toolsets.schemas import PydanticBase
-
-DATABASE_URL = os.getenv(
-    key="DATABASE_URL",
-    default="postgresql+asyncpg://postgres:postgres@localhost:5432/postgres",
-)
-
-
-class Base(DeclarativeBase):
-    """Base class for test models."""
-
-    pass
-
-
-class Role(Base):
-    """Test role model."""
-
-    __tablename__ = "roles"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(50), unique=True)
-
-    users: Mapped[list["User"]] = relationship(back_populates="role")
-
-
-class User(Base):
-    """Test user model."""
-
-    __tablename__ = "users"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    username: Mapped[str] = mapped_column(String(50), unique=True)
-    email: Mapped[str] = mapped_column(String(100), unique=True)
-    is_active: Mapped[bool] = mapped_column(default=True)
-    notes: Mapped[str | None]
-    role_id: Mapped[uuid.UUID | None] = mapped_column(
-        ForeignKey("roles.id"), nullable=True
-    )
-
-    role: Mapped[Role | None] = relationship(back_populates="users")
-
-
-class Tag(Base):
-    """Test tag model."""
-
-    __tablename__ = "tags"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(50), unique=True)
-
-
-post_tags = Table(
-    "post_tags",
-    Base.metadata,
-    Column(
-        "post_id", Uuid, ForeignKey("posts.id", ondelete="CASCADE"), primary_key=True
-    ),
-    Column("tag_id", Uuid, ForeignKey("tags.id", ondelete="CASCADE"), primary_key=True),
-)
-
-
-class IntRole(Base):
-    """Test role model with auto-increment integer PK."""
-
-    __tablename__ = "int_roles"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    name: Mapped[str] = mapped_column(String(50), unique=True)
-
-
-class Permission(Base):
-    """Test model with composite primary key."""
-
-    __tablename__ = "permissions"
-
-    subject: Mapped[str] = mapped_column(String(50), primary_key=True)
-    action: Mapped[str] = mapped_column(String(50), primary_key=True)
-
-
-class Event(Base):
-    """Test model with DateTime and Date cursor columns."""
-
-    __tablename__ = "events"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(100))
-    occurred_at: Mapped[datetime.datetime] = mapped_column(DateTime)
-    scheduled_date: Mapped[datetime.date] = mapped_column(Date)
-
-
-class Product(Base):
-    """Test model with Numeric cursor column."""
-
-    __tablename__ = "products"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(100))
-    price: Mapped[decimal.Decimal] = mapped_column(Numeric(10, 2))
-
-
-class Post(Base):
-    """Test post model."""
-
-    __tablename__ = "posts"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    title: Mapped[str] = mapped_column(String(200))
-    content: Mapped[str] = mapped_column(String(1000), default="")
-    is_published: Mapped[bool] = mapped_column(default=False)
-    author_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
-
-    tags: Mapped[list[Tag]] = relationship(secondary=post_tags)
-
-
-class OrderStatus(int, Enum):
-    """Integer-backed enum for order status."""
-
-    PENDING = 1
-    PROCESSING = 2
-    SHIPPED = 3
-    CANCELLED = 4
-
-
-class Color(str, Enum):
-    """String-backed enum for color."""
-
-    RED = "red"
-    GREEN = "green"
-    BLUE = "blue"
-
-
-class Order(Base):
-    """Test model with an IntEnum column (Enum(int, Enum)) and a raw Integer column."""
-
-    __tablename__ = "orders"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(100))
-    status: Mapped[OrderStatus] = mapped_column(SAEnum(OrderStatus))
-    priority: Mapped[int] = mapped_column(Integer)
-    color: Mapped[Color] = mapped_column(SAEnum(Color))
-
-
-class Transfer(Base):
-    """Test model with two FKs to the same table (users)."""
-
-    __tablename__ = "transfers"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    amount: Mapped[str] = mapped_column(String(50))
-    sender_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
-    receiver_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
-
-
-class Article(Base):
-    """Test article model with ARRAY and JSON columns."""
-
-    __tablename__ = "articles"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    title: Mapped[str] = mapped_column(String(200))
-    labels: Mapped[list[str]] = mapped_column(ARRAY(String))
-    metadata_: Mapped[dict | None] = mapped_column("metadata", JSON, nullable=True)
-
-
-class Challenge(Base):
-    """Base challenge model (root of joined-table inheritance hierarchy)."""
-
-    __tablename__ = "challenges"
-
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    title: Mapped[str] = mapped_column(String(200))
-    challenge_type: Mapped[str] = mapped_column(String(50))
-    points: Mapped[int] = mapped_column(Integer, default=0)
-
-    __mapper_args__ = {
-        "polymorphic_on": "challenge_type",
-        "polymorphic_identity": "challenge",
-    }
-
-
-class ChallengeStandard(Challenge):
-    """Standard challenge — child table in joined-table inheritance."""
-
-    __tablename__ = "challenge_standard"
-
-    id: Mapped[uuid.UUID] = mapped_column(ForeignKey("challenges.id"), primary_key=True)
-    difficulty: Mapped[str] = mapped_column(String(50))
-
-    __mapper_args__ = {
-        "polymorphic_identity": "standard",
-    }
-
-
-class RoleCreate(BaseModel):
-    """Schema for creating a role."""
-
-    id: uuid.UUID | None = None
-    name: str
-
-
-class RoleRead(PydanticBase):
-    """Schema for reading a role."""
-
-    id: uuid.UUID
-    name: str
-
-
-class RoleUpdate(BaseModel):
-    """Schema for updating a role."""
-
-    name: str | None = None
-
-
-class UserCreate(BaseModel):
-    """Schema for creating a user."""
-
-    id: uuid.UUID | None = None
-    username: str
-    email: str
-    is_active: bool = True
-    role_id: uuid.UUID | None = None
-
-
-class UserRead(PydanticBase):
-    """Schema for reading a user (subset of fields — no email)."""
-
-    id: uuid.UUID
-    username: str
-    is_active: bool = True
-
-
-class UserUpdate(BaseModel):
-    """Schema for updating a user."""
-
-    username: str | None = None
-    email: str | None = None
-    is_active: bool | None = None
-    role_id: uuid.UUID | None = None
-
-
-class TagCreate(BaseModel):
-    """Schema for creating a tag."""
-
-    id: uuid.UUID | None = None
-    name: str
-
-
-class PostCreate(BaseModel):
-    """Schema for creating a post."""
-
-    id: uuid.UUID | None = None
-    title: str
-    content: str = ""
-    is_published: bool = False
-    author_id: uuid.UUID
-
-
-class PostUpdate(BaseModel):
-    """Schema for updating a post."""
-
-    title: str | None = None
-    content: str | None = None
-    is_published: bool | None = None
-
-
-class PostM2MCreate(BaseModel):
-    """Schema for creating a post with M2M tag IDs."""
-
-    id: uuid.UUID | None = None
-    title: str
-    content: str = ""
-    is_published: bool = False
-    author_id: uuid.UUID
-    tag_ids: list[uuid.UUID] = []
-
-
-class PostM2MUpdate(BaseModel):
-    """Schema for updating a post with M2M tag IDs."""
-
-    title: str | None = None
-    content: str | None = None
-    is_published: bool | None = None
-    tag_ids: list[uuid.UUID] | None = None
-
-
-class IntRoleRead(PydanticBase):
-    """Schema for reading an IntRole."""
-
-    id: int
-    name: str
-
-
-class IntRoleCreate(BaseModel):
-    """Schema for creating an IntRole."""
-
-    name: str
-
-
-class EventRead(PydanticBase):
-    """Schema for reading an Event."""
-
-    id: uuid.UUID
-    name: str
-
-
-class EventCreate(BaseModel):
-    """Schema for creating an Event."""
-
-    name: str
-    occurred_at: datetime.datetime
-    scheduled_date: datetime.date
-
-
-class ProductRead(PydanticBase):
-    """Schema for reading a Product."""
-
-    id: uuid.UUID
-    name: str
-
-
-class ProductCreate(BaseModel):
-    """Schema for creating a Product."""
-
-    name: str
-    price: decimal.Decimal
-
-
-class ArticleCreate(BaseModel):
-    """Schema for creating an article."""
-
-    id: uuid.UUID | None = None
-    title: str
-    labels: list[str] = []
-
-
-class ArticleRead(PydanticBase):
-    """Schema for reading an article."""
-
-    id: uuid.UUID
-    title: str
-    labels: list[str]
-
-
-class OrderCreate(BaseModel):
-    """Schema for creating an order."""
-
-    id: uuid.UUID | None = None
-    name: str
-    status: OrderStatus
-    priority: int = 0
-    color: Color = Color.RED
-
-
-class OrderRead(PydanticBase):
-    """Schema for reading an order."""
-
-    id: uuid.UUID
-    name: str
-    status: OrderStatus
-    priority: int
-    color: Color
-
-
-class TransferCreate(BaseModel):
-    """Schema for creating a transfer."""
-
-    id: uuid.UUID | None = None
-    amount: str
-    sender_id: uuid.UUID
-    receiver_id: uuid.UUID
-
-
-class TransferRead(PydanticBase):
-    """Schema for reading a transfer."""
-
-    id: uuid.UUID
-    amount: str
-
-
-OrderCrud = CrudFactory(Order)
-TransferCrud = CrudFactory(Transfer)
-ArticleCrud = CrudFactory(Article)
-RoleCrud = CrudFactory(Role)
-RoleCursorCrud = CrudFactory(Role, cursor_column=Role.id)
-IntRoleCursorCrud = CrudFactory(IntRole, cursor_column=IntRole.id)
-UserCrud = CrudFactory(User)
-UserCursorCrud = CrudFactory(User, cursor_column=User.id)
-PostCrud = CrudFactory(Post)
-TagCrud = CrudFactory(Tag)
-PostM2MCrud = CrudFactory(Post, m2m_fields={"tag_ids": Post.tags})
-EventCrud = CrudFactory(Event)
-EventDateTimeCursorCrud = CrudFactory(Event, cursor_column=Event.occurred_at)
-EventDateCursorCrud = CrudFactory(Event, cursor_column=Event.scheduled_date)
-ProductCrud = CrudFactory(Product)
-ProductNumericCursorCrud = CrudFactory(Product, cursor_column=Product.price)
-
-
-@pytest.fixture
-def anyio_backend():
-    """Use asyncio for async tests."""
-    return "asyncio"
-
-
-@pytest.fixture(scope="function")
-async def engine():
-    """Create a PostgreSQL test database engine."""
-    engine = create_async_engine(DATABASE_URL, echo=False)
-    yield engine
-    await engine.dispose()
-
-
-@pytest.fixture(scope="function")
-async def db_session(engine):
-    """Create a test database session with tables.
-
-    Creates all tables before the test and drops them after.
-    Each test gets a clean database state.
-    """
-    # Create tables
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-
-    # Create session
-    session_factory = async_sessionmaker(engine, expire_on_commit=False)
-    session = session_factory()
-
-    try:
-        yield session
-    finally:
-        await session.close()
-        # Drop tables after test
-        async with engine.begin() as conn:
-            await conn.run_sync(Base.metadata.drop_all)
@@ -1,543 +0,0 @@
-"""Tests for fastapi_toolsets.cli module."""
-
-import sys
-
-import pytest
-from typer.testing import CliRunner
-
-from fastapi_toolsets.cli.config import (
-    get_config_value,
-    get_custom_cli,
-    get_db_context,
-    get_fixtures_registry,
-    import_from_string,
-)
-from fastapi_toolsets.cli.pyproject import find_pyproject, load_pyproject
-from fastapi_toolsets.cli.utils import async_command
-from fastapi_toolsets.fixtures import FixtureRegistry
-
-runner = CliRunner()
-
-
-class TestPyproject:
-    """Tests for pyproject.toml discovery and loading."""
-
-    def test_find_pyproject_in_current_dir(self, tmp_path, monkeypatch):
-        """Finds pyproject.toml in current directory."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[project]\nname = 'test'\n")
-        monkeypatch.chdir(tmp_path)
-
-        result = find_pyproject()
-        assert result == pyproject
-
-    def test_find_pyproject_in_parent_dir(self, tmp_path, monkeypatch):
-        """Finds pyproject.toml in parent directory."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[project]\nname = 'test'\n")
-        subdir = tmp_path / "src" / "app"
-        subdir.mkdir(parents=True)
-        monkeypatch.chdir(subdir)
-
-        result = find_pyproject()
-        assert result == pyproject
-
-    def test_find_pyproject_not_found(self, tmp_path, monkeypatch):
-        """Returns None when no pyproject.toml exists."""
-        monkeypatch.chdir(tmp_path)
-        result = find_pyproject()
-        assert result is None
-
-    def test_load_pyproject_returns_tool_config(self, tmp_path, monkeypatch):
-        """load_pyproject returns the [tool.fastapi-toolsets] section."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text(
-            '[tool.fastapi-toolsets]\nfixtures = "app.fixtures:registry"\n'
-        )
-        monkeypatch.chdir(tmp_path)
-
-        result = load_pyproject()
-        assert result == {"fixtures": "app.fixtures:registry"}
-
-    def test_load_pyproject_empty_when_no_file(self, tmp_path, monkeypatch):
-        """Returns empty dict when no pyproject.toml exists."""
-        monkeypatch.chdir(tmp_path)
-        result = load_pyproject()
-        assert result == {}
-
-    def test_load_pyproject_empty_when_no_tool_section(self, tmp_path, monkeypatch):
-        """Returns empty dict when no [tool.fastapi-toolsets] section."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[project]\nname = 'test'\n")
-        monkeypatch.chdir(tmp_path)
-
-        result = load_pyproject()
-        assert result == {}
-
-    def test_load_pyproject_invalid_toml(self, tmp_path, monkeypatch):
-        """Returns empty dict when pyproject.toml is invalid."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("invalid toml {{{")
-        monkeypatch.chdir(tmp_path)
-
-        result = load_pyproject()
-        assert result == {}
-
-
-class TestImportFromString:
-    """Tests for import_from_string function."""
-
-    def test_import_valid_path(self):
-        """Import valid module:attribute path."""
-        result = import_from_string("fastapi_toolsets.fixtures:FixtureRegistry")
-        assert result is FixtureRegistry
-
-    def test_import_without_colon_raises_error(self):
-        """Import path without colon raises error."""
-        with pytest.raises(Exception) as exc_info:
-            import_from_string("fastapi_toolsets.fixtures.FixtureRegistry")
-        assert "Expected format: 'module:attribute'" in str(exc_info.value)
-
-    def test_import_nonexistent_module_raises_error(self):
-        """Import nonexistent module raises error."""
-        with pytest.raises(Exception) as exc_info:
-            import_from_string("nonexistent.module:something")
-        assert "Cannot import module" in str(exc_info.value)
-
-    def test_import_nonexistent_attribute_raises_error(self):
-        """Import nonexistent attribute raises error."""
-        with pytest.raises(Exception) as exc_info:
-            import_from_string("fastapi_toolsets.fixtures:NonexistentClass")
-        assert "has no attribute" in str(exc_info.value)
-
-
-class TestGetConfigValue:
-    """Tests for get_config_value function."""
-
-    def test_get_existing_value(self, tmp_path, monkeypatch):
-        """Returns value when key exists."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text('[tool.fastapi-toolsets]\nfixtures = "app:registry"\n')
-        monkeypatch.chdir(tmp_path)
-
-        result = get_config_value("fixtures")
-        assert result == "app:registry"
-
-    def test_get_missing_value_returns_none(self, tmp_path, monkeypatch):
-        """Returns None when key is missing and not required."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[tool.fastapi-toolsets]\n")
-        monkeypatch.chdir(tmp_path)
-
-        result = get_config_value("fixtures")
-        assert result is None
-
-    def test_get_missing_value_required_raises_error(self, tmp_path, monkeypatch):
-        """Raises error when key is missing and required."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[tool.fastapi-toolsets]\n")
-        monkeypatch.chdir(tmp_path)
-
-        with pytest.raises(Exception) as exc_info:
-            get_config_value("fixtures", required=True)
-        assert "No 'fixtures' configured" in str(exc_info.value)
-
-
-class TestGetFixturesRegistry:
-    """Tests for get_fixtures_registry function."""
-
-    def test_raises_when_not_configured(self, tmp_path, monkeypatch):
-        """Raises error when fixtures not configured."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[tool.fastapi-toolsets]\n")
-        monkeypatch.chdir(tmp_path)
-
-        with pytest.raises(Exception) as exc_info:
-            get_fixtures_registry()
-        assert "No 'fixtures' configured" in str(exc_info.value)
-
-    def test_raises_when_not_registry_instance(self, tmp_path, monkeypatch):
-        """Raises error when imported object is not a FixtureRegistry."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text(
-            '[tool.fastapi-toolsets]\nfixtures = "my_fixtures:registry"\n'
-        )
-
-        fixtures_file = tmp_path / "my_fixtures.py"
-        fixtures_file.write_text("registry = 'not a registry'\n")
-
-        monkeypatch.chdir(tmp_path)
-        if str(tmp_path) not in sys.path:
-            sys.path.insert(0, str(tmp_path))
-
-        try:
-            with pytest.raises(Exception) as exc_info:
-                get_fixtures_registry()
-            assert "must be a FixtureRegistry instance" in str(exc_info.value)
-        finally:
-            if str(tmp_path) in sys.path:
-                sys.path.remove(str(tmp_path))
-            if "my_fixtures" in sys.modules:
-                del sys.modules["my_fixtures"]
-
-
-class TestGetDbContext:
-    """Tests for get_db_context function."""
-
-    def test_raises_when_not_configured(self, tmp_path, monkeypatch):
-        """Raises error when db_context not configured."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[tool.fastapi-toolsets]\n")
-        monkeypatch.chdir(tmp_path)
-
-        with pytest.raises(Exception) as exc_info:
-            get_db_context()
-        assert "No 'db_context' configured" in str(exc_info.value)
-
-
-class TestGetCustomCli:
-    """Tests for get_custom_cli function."""
-
-    def test_returns_none_when_not_configured(self, tmp_path, monkeypatch):
-        """Returns None when custom_cli not configured."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("[tool.fastapi-toolsets]\n")
-        monkeypatch.chdir(tmp_path)
-
-        result = get_custom_cli()
-        assert result is None
-
-    def test_raises_when_not_typer_instance(self, tmp_path, monkeypatch):
-        """Raises error when imported object is not a Typer instance."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text('[tool.fastapi-toolsets]\ncustom_cli = "my_cli:cli"\n')
-
-        cli_file = tmp_path / "my_cli.py"
-        cli_file.write_text("cli = 'not a typer'\n")
-
-        monkeypatch.chdir(tmp_path)
-        if str(tmp_path) not in sys.path:
-            sys.path.insert(0, str(tmp_path))
-
-        try:
-            with pytest.raises(Exception) as exc_info:
-                get_custom_cli()
-            assert "must be a Typer instance" in str(exc_info.value)
-        finally:
-            if str(tmp_path) in sys.path:
-                sys.path.remove(str(tmp_path))
-            if "my_cli" in sys.modules:
-                del sys.modules["my_cli"]
-
-
-class TestCliApp:
-    """Tests for CLI application."""
-
-    def test_cli_help(self, tmp_path, monkeypatch):
-        """CLI shows help without fixtures."""
-        monkeypatch.chdir(tmp_path)
-
-        # Need to reload the module to pick up new cwd
-        import importlib
-
-        from fastapi_toolsets.cli import app
-
-        importlib.reload(app)
-
-        result = runner.invoke(app.cli, ["--help"])
-        assert result.exit_code == 0
-        assert "CLI utilities for FastAPI projects" in result.output
-
-
-class TestFixturesCli:
-    """Tests for fixtures CLI commands."""
-
-    @pytest.fixture
-    def cli_env(self, tmp_path, monkeypatch):
-        """Set up CLI environment with fixtures config."""
-        # Create pyproject.toml
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text(
-            "[tool.fastapi-toolsets]\n"
-            'fixtures = "fixtures:registry"\n'
-            'db_context = "db:get_session"\n'
-        )
-
-        # Create fixtures module
-        fixtures_file = tmp_path / "fixtures.py"
-        fixtures_file.write_text(
-            "from fastapi_toolsets.fixtures import FixtureRegistry, Context\n"
-            "\n"
-            "registry = FixtureRegistry()\n"
-            "\n"
-            "@registry.register(contexts=[Context.BASE])\n"
-            "def roles():\n"
-            '    return [{"id": 1, "name": "admin"}, {"id": 2, "name": "user"}]\n'
-            "\n"
-            '@registry.register(depends_on=["roles"], contexts=[Context.TESTING])\n'
-            "def users():\n"
-            '    return [{"id": 1, "name": "alice", "role_id": 1}]\n'
-        )
-
-        # Create db module
-        db_file = tmp_path / "db.py"
-        db_file.write_text(
-            "from contextlib import asynccontextmanager\n"
-            "\n"
-            "@asynccontextmanager\n"
-            "async def get_session():\n"
-            "    yield None\n"
-        )
-
-        monkeypatch.chdir(tmp_path)
-
-        # Add tmp_path to sys.path for imports
-        if str(tmp_path) not in sys.path:
-            sys.path.insert(0, str(tmp_path))
-
-        # Reload the CLI module to pick up new config
-        import importlib
-
-        from fastapi_toolsets.cli import app
-
-        importlib.reload(app)
-
-        yield tmp_path, app.cli
-
-        # Cleanup
-        if str(tmp_path) in sys.path:
-            sys.path.remove(str(tmp_path))
-
-    def test_fixtures_list(self, cli_env):
-        """fixtures list shows registered fixtures."""
-        tmp_path, cli = cli_env
-        result = runner.invoke(cli, ["fixtures", "list"])
-
-        assert result.exit_code == 0
-        assert "roles" in result.output
-        assert "users" in result.output
-        assert "Total: 2 fixture(s)" in result.output
-
-    def test_fixtures_list_with_context(self, cli_env):
-        """fixtures list --context filters by context."""
-        tmp_path, cli = cli_env
-        result = runner.invoke(cli, ["fixtures", "list", "--context", "base"])
-
-        assert result.exit_code == 0
-        assert "roles" in result.output
-        assert "users" not in result.output
-        assert "Total: 1 fixture(s)" in result.output
-
-    def test_fixtures_load_dry_run(self, cli_env):
-        """fixtures load --dry-run shows what would be loaded."""
-        tmp_path, cli = cli_env
-        result = runner.invoke(cli, ["fixtures", "load", "base", "--dry-run"])
-
-        assert result.exit_code == 0
-        assert "Fixtures to load" in result.output
-        assert "roles" in result.output
-        assert "[Dry run - no changes made]" in result.output
-
-    def test_fixtures_load_invalid_strategy(self, cli_env):
-        """fixtures load with invalid strategy shows error."""
-        tmp_path, cli = cli_env
-        result = runner.invoke(
-            cli, ["fixtures", "load", "base", "--strategy", "invalid"]
-        )
-
-        assert result.exit_code != 0
-
-
-class TestCliWithoutFixturesConfig:
-    """Tests for CLI when fixtures is not configured."""
-
-    def test_no_fixtures_command(self, tmp_path, monkeypatch):
-        """fixtures command is not available when not configured."""
-        # Create pyproject.toml without fixtures
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text('[project]\nname = "test"\n')
-
-        monkeypatch.chdir(tmp_path)
-
-        # Reload the CLI module
-        import importlib
-
-        from fastapi_toolsets.cli import app
-
-        importlib.reload(app)
-
-        result = runner.invoke(app.cli, ["--help"])
-
-        assert result.exit_code == 0
-        assert "fixtures" not in result.output
-
-
-class TestCustomCliConfig:
-    """Tests for custom CLI configuration."""
-
-    def test_cli_with_custom_cli(self, tmp_path, monkeypatch):
-        """CLI uses custom Typer instance when configured."""
-        import typer
-
-        # Create pyproject.toml with custom_cli config
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text('[tool.fastapi-toolsets]\ncustom_cli = "my_cli:cli"\n')
-
-        # Create custom CLI module with its own Typer and commands
-        cli_file = tmp_path / "my_cli.py"
-        cli_file.write_text(
-            "import typer\n"
-            "\n"
-            "cli = typer.Typer(name='my-app', help='My custom CLI')\n"
-            "\n"
-            "@cli.command()\n"
-            "def hello():\n"
-            '    print("Hello from custom CLI!")\n'
-        )
-
-        monkeypatch.chdir(tmp_path)
-
-        # Add tmp_path to sys.path for imports
-        if str(tmp_path) not in sys.path:
-            sys.path.insert(0, str(tmp_path))
-
-        # Remove my_cli from sys.modules if it was previously loaded
-        if "my_cli" in sys.modules:
-            del sys.modules["my_cli"]
-
-        # Reload the CLI module to pick up new config
-        import importlib
-
-        from fastapi_toolsets.cli import app
-
-        importlib.reload(app)
-
-        try:
-            # Verify custom CLI is used
-            assert isinstance(app.cli, typer.Typer)
-
-            result = runner.invoke(app.cli, ["--help"])
-            assert result.exit_code == 0
-            assert "My custom CLI" in result.output
-            assert "hello" in result.output
-
-            result = runner.invoke(app.cli, ["hello"])
-            assert result.exit_code == 0
-            assert "Hello from custom CLI!" in result.output
-        finally:
-            if str(tmp_path) in sys.path:
-                sys.path.remove(str(tmp_path))
-            if "my_cli" in sys.modules:
-                del sys.modules["my_cli"]
-
-    def test_custom_cli_with_fixtures(self, tmp_path, monkeypatch):
-        """Custom CLI gets fixtures command added when configured."""
-        # Create pyproject.toml with both custom_cli and fixtures
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text(
-            "[tool.fastapi-toolsets]\n"
-            'custom_cli = "my_cli:cli"\n'
-            'fixtures = "fixtures:registry"\n'
-            'db_context = "db:get_session"\n'
-        )
-
-        # Create custom CLI module
-        cli_file = tmp_path / "my_cli.py"
-        cli_file.write_text(
-            "import typer\n"
-            "\n"
-            "cli = typer.Typer(name='my-app', help='My custom CLI')\n"
-            "\n"
-            "@cli.command()\n"
-            "def hello():\n"
-            '    print("Hello!")\n'
-        )
-
-        # Create fixtures module
-        fixtures_file = tmp_path / "fixtures.py"
-        fixtures_file.write_text(
-            "from fastapi_toolsets.fixtures import FixtureRegistry\n"
-            "\n"
-            "registry = FixtureRegistry()\n"
-        )
-
-        # Create db module
-        db_file = tmp_path / "db.py"
-        db_file.write_text(
-            "from contextlib import asynccontextmanager\n"
-            "\n"
-            "@asynccontextmanager\n"
-            "async def get_session():\n"
-            "    yield None\n"
-        )
-
-        monkeypatch.chdir(tmp_path)
-
-        if str(tmp_path) not in sys.path:
-            sys.path.insert(0, str(tmp_path))
-
-        for mod in ["my_cli", "fixtures", "db"]:
-            if mod in sys.modules:
-                del sys.modules[mod]
-
-        import importlib
-
-        from fastapi_toolsets.cli import app
-
-        importlib.reload(app)
-
-        try:
-            result = runner.invoke(app.cli, ["--help"])
-            assert result.exit_code == 0
-            # Should have both custom command and fixtures
-            assert "hello" in result.output
-            assert "fixtures" in result.output
-        finally:
-            if str(tmp_path) in sys.path:
-                sys.path.remove(str(tmp_path))
-            for mod in ["my_cli", "fixtures", "db"]:
-                if mod in sys.modules:
-                    del sys.modules[mod]
-
-
-class TestAsyncCommand:
-    """Tests for async_command decorator."""
-
-    def test_async_command_runs_coroutine(self):
-        """async_command runs async function synchronously."""
-
-        @async_command
-        async def async_func(value: int) -> int:
-            return value * 2
-
-        result = async_func(21)
-        assert result == 42
-
-    def test_async_command_preserves_signature(self):
-        """async_command preserves function signature."""
-
-        @async_command
-        async def async_func(name: str, count: int = 1) -> str:
-            return f"{name} x {count}"
-
-        result = async_func("test", count=3)
-        assert result == "test x 3"
-
-    def test_async_command_preserves_docstring(self):
-        """async_command preserves function docstring."""
-
-        @async_command
-        async def async_func() -> None:
-            """This is a docstring."""
-            pass
-
-        assert async_func.__doc__ == """This is a docstring."""
-
-    def test_async_command_preserves_name(self):
-        """async_command preserves function name."""
-
-        @async_command
-        async def my_async_function() -> None:
-            pass
-
-        assert my_async_function.__name__ == "my_async_function"
@@ -1,930 +0,0 @@
-"""Tests for fastapi_toolsets.db module."""
-
-import asyncio
-import uuid
-
-import pytest
-from sqlalchemy import (
-    Column,
-    ForeignKey,
-    ForeignKeyConstraint,
-    String,
-    Table,
-    Uuid,
-    select,
-    text,
-)
-from sqlalchemy.engine import make_url
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import (
-    DeclarativeBase,
-    Mapped,
-    mapped_column,
-    relationship,
-    selectinload,
-)
-
-from fastapi_toolsets.db import (
-    LockMode,
-    cleanup_tables,
-    create_database,
-    create_db_context,
-    create_db_dependency,
-    get_transaction,
-    lock_tables,
-    m2m_add,
-    m2m_remove,
-    m2m_set,
-    wait_for_row_change,
-)
-from fastapi_toolsets.exceptions import NotFoundError
-from fastapi_toolsets.pytest import create_db_session
-
-from .conftest import DATABASE_URL, Base, Post, Role, RoleCrud, Tag, User, UserCrud
-
-
-class TestCreateDbDependency:
-    """Tests for create_db_dependency."""
-
-    @pytest.mark.anyio
-    async def test_yields_session(self):
-        """Dependency yields a valid session."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-        get_db = create_db_dependency(session_factory)
-
-        async for session in get_db():
-            assert isinstance(session, AsyncSession)
-            break
-
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_auto_commits_transaction(self):
-        """Dependency auto-commits if transaction is active."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-
-        async with engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
-
-        try:
-            get_db = create_db_dependency(session_factory)
-
-            async for session in get_db():
-                role = Role(name="test_role_dep")
-                session.add(role)
-                await session.flush()
-
-            async with session_factory() as verify_session:
-                result = await RoleCrud.first(
-                    verify_session, [Role.name == "test_role_dep"]
-                )
-                assert result is not None
-        finally:
-            async with engine.begin() as conn:
-                await conn.run_sync(Base.metadata.drop_all)
-            await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_in_transaction_on_yield(self):
-        """Session is already in a transaction when the endpoint body starts."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-        get_db = create_db_dependency(session_factory)
-
-        async for session in get_db():
-            assert session.in_transaction()
-            break
-
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_no_commit_when_not_in_transaction(self):
-        """Dependency skips commit if the session is no longer in a transaction on exit."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-        get_db = create_db_dependency(session_factory)
-
-        async for session in get_db():
-            # Manually commit — session exits the transaction
-            await session.commit()
-            assert not session.in_transaction()
-            # The dependency's post-yield path must not call commit again (no error)
-
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_update_after_lock_tables_is_persisted(self):
-        """Changes made after lock_tables exits (before endpoint returns) are committed.
-
-        Regression: without the auto-begin fix, lock_tables would start and commit a
-        real outer transaction, leaving the session idle. Any modifications after that
-        point were silently dropped.
-        """
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-
-        async with engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
-
-        try:
-            get_db = create_db_dependency(session_factory)
-
-            async for session in get_db():
-                async with lock_tables(session, [Role]):
-                    role = Role(name="lock_then_update")
-                    session.add(role)
-                    await session.flush()
-                # lock_tables has exited — outer transaction must still be open
-                assert session.in_transaction()
-                role.name = "updated_after_lock"
-
-            async with session_factory() as verify:
-                result = await RoleCrud.first(
-                    verify, [Role.name == "updated_after_lock"]
-                )
-                assert result is not None
-        finally:
-            async with engine.begin() as conn:
-                await conn.run_sync(Base.metadata.drop_all)
-            await engine.dispose()
-
-
-class TestCreateDbContext:
-    """Tests for create_db_context."""
-
-    @pytest.mark.anyio
-    async def test_context_manager_yields_session(self):
-        """Context manager yields a valid session."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-        get_db_context = create_db_context(session_factory)
-
-        async with get_db_context() as session:
-            assert isinstance(session, AsyncSession)
-
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_context_manager_commits(self):
-        """Context manager commits on exit."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-
-        async with engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
-
-        try:
-            get_db_context = create_db_context(session_factory)
-
-            async with get_db_context() as session:
-                role = Role(name="context_role")
-                session.add(role)
-                await session.flush()
-
-            async with session_factory() as verify_session:
-                result = await RoleCrud.first(
-                    verify_session, [Role.name == "context_role"]
-                )
-                assert result is not None
-        finally:
-            async with engine.begin() as conn:
-                await conn.run_sync(Base.metadata.drop_all)
-            await engine.dispose()
-
-
-class TestGetTransaction:
-    """Tests for get_transaction context manager."""
-
-    @pytest.mark.anyio
-    async def test_starts_transaction(self, db_session: AsyncSession):
-        """get_transaction starts a new transaction."""
-        async with get_transaction(db_session):
-            role = Role(name="tx_role")
-            db_session.add(role)
-
-        result = await RoleCrud.first(db_session, [Role.name == "tx_role"])
-        assert result is not None
-
-    @pytest.mark.anyio
-    async def test_nested_transaction_uses_savepoint(self, db_session: AsyncSession):
-        """Nested transactions use savepoints."""
-        async with get_transaction(db_session):
-            role1 = Role(name="outer_role")
-            db_session.add(role1)
-            await db_session.flush()
-
-            async with get_transaction(db_session):
-                role2 = Role(name="inner_role")
-                db_session.add(role2)
-
-        results = await RoleCrud.get_multi(db_session)
-        names = {r.name for r in results}
-        assert "outer_role" in names
-        assert "inner_role" in names
-
-    @pytest.mark.anyio
-    async def test_rollback_on_exception(self, db_session: AsyncSession):
-        """Transaction rolls back on exception."""
-        try:
-            async with get_transaction(db_session):
-                role = Role(name="rollback_role")
-                db_session.add(role)
-                await db_session.flush()
-                raise ValueError("Simulated error")
-        except ValueError:
-            pass
-
-        result = await RoleCrud.first(db_session, [Role.name == "rollback_role"])
-        assert result is None
-
-    @pytest.mark.anyio
-    async def test_nested_rollback_preserves_outer(self, db_session: AsyncSession):
-        """Nested rollback preserves outer transaction."""
-        async with get_transaction(db_session):
-            role1 = Role(name="preserved_role")
-            db_session.add(role1)
-            await db_session.flush()
-
-            try:
-                async with get_transaction(db_session):
-                    role2 = Role(name="rolled_back_role")
-                    db_session.add(role2)
-                    await db_session.flush()
-                    raise ValueError("Inner error")
-            except ValueError:
-                pass
-
-        outer = await RoleCrud.first(db_session, [Role.name == "preserved_role"])
-        inner = await RoleCrud.first(db_session, [Role.name == "rolled_back_role"])
-        assert outer is not None
-        assert inner is None
-
-
-class TestLockMode:
-    """Tests for LockMode enum."""
-
-    def test_lock_modes_exist(self):
-        """All expected lock modes are defined."""
-        assert LockMode.ACCESS_SHARE == "ACCESS SHARE"
-        assert LockMode.ROW_SHARE == "ROW SHARE"
-        assert LockMode.ROW_EXCLUSIVE == "ROW EXCLUSIVE"
-        assert LockMode.SHARE_UPDATE_EXCLUSIVE == "SHARE UPDATE EXCLUSIVE"
-        assert LockMode.SHARE == "SHARE"
-        assert LockMode.SHARE_ROW_EXCLUSIVE == "SHARE ROW EXCLUSIVE"
-        assert LockMode.EXCLUSIVE == "EXCLUSIVE"
-        assert LockMode.ACCESS_EXCLUSIVE == "ACCESS EXCLUSIVE"
-
-    def test_lock_mode_is_string(self):
-        """Lock modes are string enums."""
-        assert isinstance(LockMode.EXCLUSIVE, str)
-        assert LockMode.EXCLUSIVE.value == "EXCLUSIVE"
-
-
-class TestLockTables:
-    """Tests for lock_tables context manager (PostgreSQL-specific)."""
-
-    @pytest.mark.anyio
-    async def test_lock_single_table(self, db_session: AsyncSession):
-        """Lock a single table."""
-        async with lock_tables(db_session, [Role]):
-            # Inside the lock, we can still perform operations
-            role = Role(name="locked_role")
-            db_session.add(role)
-            await db_session.flush()
-
-        # After lock is released, verify the data was committed
-        result = await RoleCrud.first(db_session, [Role.name == "locked_role"])
-        assert result is not None
-
-    @pytest.mark.anyio
-    async def test_lock_multiple_tables(self, db_session: AsyncSession):
-        """Lock multiple tables."""
-        async with lock_tables(db_session, [Role, User]):
-            role = Role(name="multi_lock_role")
-            db_session.add(role)
-            await db_session.flush()
-
-        result = await RoleCrud.first(db_session, [Role.name == "multi_lock_role"])
-        assert result is not None
-
-    @pytest.mark.anyio
-    async def test_lock_with_custom_mode(self, db_session: AsyncSession):
-        """Lock with custom lock mode."""
-        async with lock_tables(db_session, [Role], mode=LockMode.EXCLUSIVE):
-            role = Role(name="exclusive_lock_role")
-            db_session.add(role)
-            await db_session.flush()
-
-        result = await RoleCrud.first(db_session, [Role.name == "exclusive_lock_role"])
-        assert result is not None
-
-    @pytest.mark.anyio
-    async def test_lock_rollback_on_exception(self, db_session: AsyncSession):
-        """Lock context rolls back on exception."""
-        try:
-            async with lock_tables(db_session, [Role]):
-                role = Role(name="lock_rollback_role")
-                db_session.add(role)
-                await db_session.flush()
-                raise ValueError("Simulated error")
-        except ValueError:
-            pass
-
-        result = await RoleCrud.first(db_session, [Role.name == "lock_rollback_role"])
-        assert result is None
-
-
-class TestWaitForRowChange:
-    """Tests for wait_for_row_change polling function."""
-
-    @pytest.mark.anyio
-    async def test_detects_update(self, db_session: AsyncSession, engine):
-        """Returns updated instance when a column value changes."""
-        role = Role(name="watch_role")
-        db_session.add(role)
-        await db_session.commit()
-
-        async def update_later():
-            await asyncio.sleep(0.15)
-            factory = async_sessionmaker(engine, expire_on_commit=False)
-            async with factory() as other:
-                r = await other.get(Role, role.id)
-                assert r is not None
-                r.name = "updated_role"
-                await other.commit()
-
-        update_task = asyncio.create_task(update_later())
-        result = await wait_for_row_change(db_session, Role, role.id, interval=0.05)
-        await update_task
-
-        assert result.name == "updated_role"
-
-    @pytest.mark.anyio
-    async def test_watches_specific_columns(self, db_session: AsyncSession, engine):
-        """Only triggers on changes to specified columns."""
-        user = User(username="testuser", email="test@example.com")
-        db_session.add(user)
-        await db_session.commit()
-
-        async def update_later():
-            factory = async_sessionmaker(engine, expire_on_commit=False)
-            # First: change email (not watched) — should not trigger
-            await asyncio.sleep(0.15)
-            async with factory() as other:
-                u = await other.get(User, user.id)
-                assert u is not None
-                u.email = "new@example.com"
-                await other.commit()
-            # Second: change username (watched) — should trigger
-            await asyncio.sleep(0.15)
-            async with factory() as other:
-                u = await other.get(User, user.id)
-                assert u is not None
-                u.username = "newuser"
-                await other.commit()
-
-        update_task = asyncio.create_task(update_later())
-        result = await wait_for_row_change(
-            db_session, User, user.id, columns=["username"], interval=0.05
-        )
-        await update_task
-
-        assert result.username == "newuser"
-        assert result.email == "new@example.com"
-
-    @pytest.mark.anyio
-    async def test_nonexistent_row_raises(self, db_session: AsyncSession):
-        """Raises NotFoundError when the row does not exist."""
-        fake_id = uuid.uuid4()
-        with pytest.raises(NotFoundError, match="not found"):
-            await wait_for_row_change(db_session, Role, fake_id, interval=0.05)
-
-    @pytest.mark.anyio
-    async def test_timeout_raises(self, db_session: AsyncSession):
-        """Raises TimeoutError when no change is detected within timeout."""
-        role = Role(name="timeout_role")
-        db_session.add(role)
-        await db_session.commit()
-
-        with pytest.raises(TimeoutError):
-            await wait_for_row_change(
-                db_session, Role, role.id, interval=0.05, timeout=0.2
-            )
-
-    @pytest.mark.anyio
-    async def test_deleted_row_raises(self, db_session: AsyncSession, engine):
-        """Raises NotFoundError when the row is deleted during polling."""
-        role = Role(name="delete_role")
-        db_session.add(role)
-        await db_session.commit()
-
-        async def delete_later():
-            await asyncio.sleep(0.15)
-            factory = async_sessionmaker(engine, expire_on_commit=False)
-            async with factory() as other:
-                r = await other.get(Role, role.id)
-                await other.delete(r)
-                await other.commit()
-
-        delete_task = asyncio.create_task(delete_later())
-        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 = make_url(target_url).database
-        assert expected_db is not None
-
-        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)
-
-
-class TestM2MAdd:
-    """Tests for m2m_add helper."""
-
-    @pytest.mark.anyio
-    async def test_adds_single_related(self, db_session: AsyncSession):
-        """Associates one related instance via the secondary table."""
-        user = User(username="m2m_author", email="m2m@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post A", author_id=user.id)
-        tag = Tag(name="python")
-        db_session.add_all([post, tag])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag)
-
-        result = await db_session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        loaded = result.scalar_one()
-        assert len(loaded.tags) == 1
-        assert loaded.tags[0].id == tag.id
-
-    @pytest.mark.anyio
-    async def test_adds_multiple_related(self, db_session: AsyncSession):
-        """Associates multiple related instances in a single call."""
-        user = User(username="m2m_author2", email="m2m2@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post B", author_id=user.id)
-        tag1 = Tag(name="web")
-        tag2 = Tag(name="api")
-        tag3 = Tag(name="async")
-        db_session.add_all([post, tag1, tag2, tag3])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag1, tag2, tag3)
-
-        result = await db_session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        loaded = result.scalar_one()
-        assert {t.id for t in loaded.tags} == {tag1.id, tag2.id, tag3.id}
-
-    @pytest.mark.anyio
-    async def test_noop_for_empty_related(self, db_session: AsyncSession):
-        """Calling with no related instances is a no-op."""
-        user = User(username="m2m_author3", email="m2m3@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post C", author_id=user.id)
-        db_session.add(post)
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags)  # no related instances
-
-        result = await db_session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        loaded = result.scalar_one()
-        assert loaded.tags == []
-
-    @pytest.mark.anyio
-    async def test_ignore_conflicts_true(self, db_session: AsyncSession):
-        """Duplicate inserts are silently skipped when ignore_conflicts=True."""
-        user = User(username="m2m_author4", email="m2m4@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post D", author_id=user.id)
-        tag = Tag(name="duplicate_tag")
-        db_session.add_all([post, tag])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag)
-
-        # Second call with ignore_conflicts=True must not raise
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag, ignore_conflicts=True)
-
-        result = await db_session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        loaded = result.scalar_one()
-        assert len(loaded.tags) == 1
-
-    @pytest.mark.anyio
-    async def test_ignore_conflicts_false_raises(self, db_session: AsyncSession):
-        """Duplicate inserts raise IntegrityError when ignore_conflicts=False (default)."""
-        user = User(username="m2m_author5", email="m2m5@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post E", author_id=user.id)
-        tag = Tag(name="conflict_tag")
-        db_session.add_all([post, tag])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag)
-
-        with pytest.raises(IntegrityError):
-            async with get_transaction(db_session):
-                await m2m_add(db_session, post, Post.tags, tag)
-
-    @pytest.mark.anyio
-    async def test_non_m2m_raises_type_error(self, db_session: AsyncSession):
-        """Passing a non-M2M relationship attribute raises TypeError."""
-        user = User(username="m2m_author6", email="m2m6@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        role = Role(name="type_err_role")
-        db_session.add(role)
-        await db_session.flush()
-
-        with pytest.raises(TypeError, match="Many-to-Many"):
-            await m2m_add(db_session, user, User.role, role)
-
-    @pytest.mark.anyio
-    async def test_works_inside_lock_tables(self, db_session: AsyncSession):
-        """m2m_add works correctly inside a lock_tables nested transaction."""
-        user = User(username="m2m_lock_author", email="m2m_lock@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        async with lock_tables(db_session, [Tag]):
-            tag = Tag(name="locked_tag")
-            db_session.add(tag)
-            await db_session.flush()
-
-            post = Post(title="Post Lock", author_id=user.id)
-            db_session.add(post)
-            await db_session.flush()
-
-            await m2m_add(db_session, post, Post.tags, tag)
-
-        result = await db_session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        loaded = result.scalar_one()
-        assert len(loaded.tags) == 1
-        assert loaded.tags[0].name == "locked_tag"
-
-
-class _LocalBase(DeclarativeBase):
-    pass
-
-
-_comp_assoc = Table(
-    "_comp_assoc",
-    _LocalBase.metadata,
-    Column("owner_id", Uuid, ForeignKey("_comp_owners.id"), primary_key=True),
-    Column("item_group", String(50), primary_key=True),
-    Column("item_code", String(50), primary_key=True),
-    ForeignKeyConstraint(
-        ["item_group", "item_code"],
-        ["_comp_items.group_id", "_comp_items.item_code"],
-    ),
-)
-
-
-class _CompOwner(_LocalBase):
-    __tablename__ = "_comp_owners"
-    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
-    items: Mapped[list["_CompItem"]] = relationship(secondary=_comp_assoc)
-
-
-class _CompItem(_LocalBase):
-    __tablename__ = "_comp_items"
-    group_id: Mapped[str] = mapped_column(String(50), primary_key=True)
-    item_code: Mapped[str] = mapped_column(String(50), primary_key=True)
-
-
-class TestM2MRemove:
-    """Tests for m2m_remove helper."""
-
-    async def _setup(
-        self, session: AsyncSession, username: str, email: str, *tag_names: str
-    ):
-        """Create a user, post, and tags; associate all tags with the post."""
-        user = User(username=username, email=email)
-        session.add(user)
-        await session.flush()
-
-        post = Post(title=f"Post {username}", author_id=user.id)
-        tags = [Tag(name=n) for n in tag_names]
-        session.add(post)
-        session.add_all(tags)
-        await session.flush()
-
-        async with get_transaction(session):
-            await m2m_add(session, post, Post.tags, *tags)
-
-        return post, tags
-
-    async def _load_tags(self, session: AsyncSession, post: Post) -> list[Tag]:
-        result = await session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        return result.scalar_one().tags
-
-    @pytest.mark.anyio
-    async def test_removes_single(self, db_session: AsyncSession):
-        """Removes one association, leaving others intact."""
-        post, (tag1, tag2) = await self._setup(
-            db_session, "rm_author1", "rm1@test.com", "tag_rm_a", "tag_rm_b"
-        )
-
-        async with get_transaction(db_session):
-            await m2m_remove(db_session, post, Post.tags, tag1)
-
-        remaining = await self._load_tags(db_session, post)
-        assert len(remaining) == 1
-        assert remaining[0].id == tag2.id
-
-    @pytest.mark.anyio
-    async def test_removes_multiple(self, db_session: AsyncSession):
-        """Removes multiple associations in one call."""
-        post, (tag1, tag2, tag3) = await self._setup(
-            db_session, "rm_author2", "rm2@test.com", "tag_rm_c", "tag_rm_d", "tag_rm_e"
-        )
-
-        async with get_transaction(db_session):
-            await m2m_remove(db_session, post, Post.tags, tag1, tag3)
-
-        remaining = await self._load_tags(db_session, post)
-        assert len(remaining) == 1
-        assert remaining[0].id == tag2.id
-
-    @pytest.mark.anyio
-    async def test_noop_for_empty_related(self, db_session: AsyncSession):
-        """Calling with no related instances is a no-op."""
-        post, (tag,) = await self._setup(
-            db_session, "rm_author3", "rm3@test.com", "tag_rm_f"
-        )
-
-        async with get_transaction(db_session):
-            await m2m_remove(db_session, post, Post.tags)
-
-        remaining = await self._load_tags(db_session, post)
-        assert len(remaining) == 1
-
-    @pytest.mark.anyio
-    async def test_idempotent_for_missing_association(self, db_session: AsyncSession):
-        """Removing a non-existent association does not raise."""
-        post, (tag1,) = await self._setup(
-            db_session, "rm_author4", "rm4@test.com", "tag_rm_g"
-        )
-        tag2 = Tag(name="tag_rm_h")
-        db_session.add(tag2)
-        await db_session.flush()
-
-        # tag2 was never associated — should not raise
-        async with get_transaction(db_session):
-            await m2m_remove(db_session, post, Post.tags, tag2)
-
-        remaining = await self._load_tags(db_session, post)
-        assert len(remaining) == 1
-
-    @pytest.mark.anyio
-    async def test_non_m2m_raises_type_error(self, db_session: AsyncSession):
-        """Passing a non-M2M relationship attribute raises TypeError."""
-        user = User(username="rm_author5", email="rm5@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        role = Role(name="rm_type_err_role")
-        db_session.add(role)
-        await db_session.flush()
-
-        with pytest.raises(TypeError, match="Many-to-Many"):
-            await m2m_remove(db_session, user, User.role, role)
-
-    @pytest.mark.anyio
-    async def test_removes_composite_pk_related(self):
-        """Composite-PK branch: DELETE uses tuple IN when related side has multi-col PK."""
-        engine = create_async_engine(DATABASE_URL, echo=False)
-        async with engine.begin() as conn:
-            await conn.run_sync(_LocalBase.metadata.create_all)
-
-        session_factory = async_sessionmaker(engine, expire_on_commit=False)
-        try:
-            async with session_factory() as session:
-                owner = _CompOwner()
-                item1 = _CompItem(group_id="g1", item_code="c1")
-                item2 = _CompItem(group_id="g1", item_code="c2")
-                session.add_all([owner, item1, item2])
-                await session.flush()
-
-                async with get_transaction(session):
-                    await m2m_add(session, owner, _CompOwner.items, item1, item2)
-
-                async with get_transaction(session):
-                    await m2m_remove(session, owner, _CompOwner.items, item1)
-
-                await session.commit()
-
-            async with session_factory() as verify:
-                from sqlalchemy import select
-                from sqlalchemy.orm import selectinload
-
-                result = await verify.execute(
-                    select(_CompOwner)
-                    .where(_CompOwner.id == owner.id)
-                    .options(selectinload(_CompOwner.items))
-                )
-                loaded = result.scalar_one()
-                assert len(loaded.items) == 1
-                assert (loaded.items[0].group_id, loaded.items[0].item_code) == (
-                    "g1",
-                    "c2",
-                )
-        finally:
-            async with engine.begin() as conn:
-                await conn.run_sync(_LocalBase.metadata.drop_all)
-            await engine.dispose()
-
-
-class TestM2MSet:
-    """Tests for m2m_set helper."""
-
-    async def _load_tags(self, session: AsyncSession, post: Post) -> list[Tag]:
-        result = await session.execute(
-            select(Post).where(Post.id == post.id).options(selectinload(Post.tags))
-        )
-        return result.scalar_one().tags
-
-    @pytest.mark.anyio
-    async def test_replaces_existing_set(self, db_session: AsyncSession):
-        """Replaces the full association set atomically."""
-        user = User(username="set_author1", email="set1@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post Set A", author_id=user.id)
-        tag1 = Tag(name="tag_set_a")
-        tag2 = Tag(name="tag_set_b")
-        tag3 = Tag(name="tag_set_c")
-        db_session.add_all([post, tag1, tag2, tag3])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag1, tag2)
-
-        async with get_transaction(db_session):
-            await m2m_set(db_session, post, Post.tags, tag3)
-
-        remaining = await self._load_tags(db_session, post)
-        assert len(remaining) == 1
-        assert remaining[0].id == tag3.id
-
-    @pytest.mark.anyio
-    async def test_clears_all_when_no_related(self, db_session: AsyncSession):
-        """Passing no related instances clears all associations."""
-        user = User(username="set_author2", email="set2@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post Set B", author_id=user.id)
-        tag = Tag(name="tag_set_d")
-        db_session.add_all([post, tag])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_add(db_session, post, Post.tags, tag)
-
-        async with get_transaction(db_session):
-            await m2m_set(db_session, post, Post.tags)
-
-        remaining = await self._load_tags(db_session, post)
-        assert remaining == []
-
-    @pytest.mark.anyio
-    async def test_set_on_empty_then_populate(self, db_session: AsyncSession):
-        """m2m_set works on a post with no existing associations."""
-        user = User(username="set_author3", email="set3@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        post = Post(title="Post Set C", author_id=user.id)
-        tag1 = Tag(name="tag_set_e")
-        tag2 = Tag(name="tag_set_f")
-        db_session.add_all([post, tag1, tag2])
-        await db_session.flush()
-
-        async with get_transaction(db_session):
-            await m2m_set(db_session, post, Post.tags, tag1, tag2)
-
-        remaining = await self._load_tags(db_session, post)
-        assert {t.id for t in remaining} == {tag1.id, tag2.id}
-
-    @pytest.mark.anyio
-    async def test_non_m2m_raises_type_error(self, db_session: AsyncSession):
-        """Passing a non-M2M relationship attribute raises TypeError."""
-        user = User(username="set_author4", email="set4@test.com")
-        db_session.add(user)
-        await db_session.flush()
-
-        role = Role(name="set_type_err_role")
-        db_session.add(role)
-        await db_session.flush()
-
-        with pytest.raises(TypeError, match="Many-to-Many"):
-            await m2m_set(db_session, user, User.role, role)
@@ -1,277 +0,0 @@
-"""Tests for fastapi_toolsets.dependencies module."""
-
-import inspect
-import uuid
-from collections.abc import AsyncGenerator
-from typing import Annotated, Any, cast
-
-import pytest
-from fastapi.params import Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from fastapi_toolsets.dependencies import (
-    BodyDependency,
-    PathDependency,
-    _unwrap_session_dep,
-)
-
-from .conftest import Role, RoleCreate, RoleCrud, User
-
-
-async def mock_get_db() -> AsyncGenerator[AsyncSession, None]:
-    """Mock session dependency for testing."""
-    yield None  # type: ignore[misc]  # ty:ignore[invalid-yield]
-
-
-MockSessionDep = Annotated[AsyncSession, Depends(mock_get_db)]
-
-
-class TestUnwrapSessionDep:
-    def test_plain_callable_returned_as_is(self):
-        """Plain callable is returned unchanged."""
-        assert _unwrap_session_dep(mock_get_db) is mock_get_db
-
-    def test_annotated_with_depends_unwrapped(self):
-        """Annotated form with Depends is unwrapped to the plain callable."""
-        assert _unwrap_session_dep(MockSessionDep) is mock_get_db
-
-    def test_annotated_without_depends_returned_as_is(self):
-        """Annotated form with no Depends falls back to returning session_dep as-is."""
-        annotated_no_dep = Annotated[AsyncSession, "not_a_depends"]
-        assert _unwrap_session_dep(annotated_no_dep) is annotated_no_dep
-
-
-class TestPathDependency:
-    """Tests for PathDependency factory."""
-
-    def test_returns_depends_instance(self):
-        """PathDependency returns a Depends instance."""
-        dep = PathDependency(Role, Role.id, session_dep=mock_get_db)
-        assert isinstance(dep, Depends)
-
-    def test_signature_has_default_param_name(self):
-        """PathDependency uses model_field as default param name."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=mock_get_db))
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-        params = list(sig.parameters.keys())
-
-        assert "role_id" in params
-        assert "session" in params
-
-    def test_signature_has_correct_type_annotation(self):
-        """PathDependency uses field's python type for annotation."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=mock_get_db))
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-
-        assert sig.parameters["role_id"].annotation == uuid.UUID
-        assert sig.parameters["session"].annotation == AsyncSession
-
-    def test_signature_session_has_depends_default(self):
-        """PathDependency session param has Depends as default."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=mock_get_db))
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-
-        assert isinstance(sig.parameters["session"].default, Depends)
-
-    def test_custom_param_name_in_signature(self):
-        """PathDependency uses custom param_name in signature."""
-        dep = cast(
-            Any,
-            PathDependency(
-                Role, Role.id, session_dep=mock_get_db, param_name="role_uuid"
-            ),
-        )
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-        params = list(sig.parameters.keys())
-
-        assert "role_uuid" in params
-        assert "id" not in params
-
-    def test_string_field_type(self):
-        """PathDependency handles string field types."""
-        dep = cast(Any, PathDependency(User, User.username, session_dep=mock_get_db))
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-
-        assert sig.parameters["user_username"].annotation is str
-
-    @pytest.mark.anyio
-    async def test_dependency_fetches_object(self, db_session):
-        """PathDependency inner function fetches object from database."""
-        role = await RoleCrud.create(db_session, RoleCreate(name="test_role"))
-
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=mock_get_db))
-        func = dep.dependency
-
-        result = await func(session=db_session, role_id=role.id)
-
-        assert result.id == role.id
-        assert result.name == "test_role"
-
-    def test_annotated_session_dep_returns_depends_instance(self):
-        """PathDependency accepts Annotated[AsyncSession, Depends(...)] form."""
-        dep = PathDependency(Role, Role.id, session_dep=MockSessionDep)
-        assert isinstance(dep, Depends)
-
-    def test_annotated_session_dep_signature(self):
-        """PathDependency with Annotated session_dep produces a valid signature."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=MockSessionDep))
-        sig = inspect.signature(dep.dependency)
-
-        assert "role_id" in sig.parameters
-        assert "session" in sig.parameters
-        assert isinstance(sig.parameters["session"].default, Depends)
-
-    def test_annotated_session_dep_unwraps_callable(self):
-        """PathDependency with Annotated form uses the underlying callable, not the Annotated type."""
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=MockSessionDep))
-        sig = inspect.signature(dep.dependency)
-
-        inner_dep = sig.parameters["session"].default
-        assert inner_dep.dependency is mock_get_db
-
-    @pytest.mark.anyio
-    async def test_annotated_session_dep_fetches_object(self, db_session):
-        """PathDependency with Annotated session_dep correctly fetches object from database."""
-        role = await RoleCrud.create(db_session, RoleCreate(name="annotated_role"))
-
-        dep = cast(Any, PathDependency(Role, Role.id, session_dep=MockSessionDep))
-        result = await dep.dependency(session=db_session, role_id=role.id)
-
-        assert result.id == role.id
-        assert result.name == "annotated_role"
-
-
-class TestBodyDependency:
-    """Tests for BodyDependency factory."""
-
-    def test_returns_depends_instance(self):
-        """BodyDependency returns a Depends instance."""
-        dep = BodyDependency(
-            Role, Role.id, session_dep=mock_get_db, body_field="role_id"
-        )
-        assert isinstance(dep, Depends)
-
-    def test_signature_has_body_field_as_param(self):
-        """BodyDependency uses body_field as param name."""
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=mock_get_db, body_field="role_id"
-            ),
-        )
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-        params = list(sig.parameters.keys())
-
-        assert "role_id" in params
-        assert "session" in params
-
-    def test_signature_has_correct_type_annotation(self):
-        """BodyDependency uses field's python type for annotation."""
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=mock_get_db, body_field="role_id"
-            ),
-        )
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-
-        assert sig.parameters["role_id"].annotation == uuid.UUID
-        assert sig.parameters["session"].annotation == AsyncSession
-
-    def test_signature_session_has_depends_default(self):
-        """BodyDependency session param has Depends as default."""
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=mock_get_db, body_field="role_id"
-            ),
-        )
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-
-        assert isinstance(sig.parameters["session"].default, Depends)
-
-    def test_different_body_field_name(self):
-        """BodyDependency can use any body_field name."""
-        dep = cast(
-            Any,
-            BodyDependency(
-                User, User.id, session_dep=mock_get_db, body_field="user_uuid"
-            ),
-        )
-        func = dep.dependency
-
-        sig = inspect.signature(func)
-        params = list(sig.parameters.keys())
-
-        assert "user_uuid" in params
-        assert "id" not in params
-
-    @pytest.mark.anyio
-    async def test_dependency_fetches_object(self, db_session):
-        """BodyDependency inner function fetches object from database."""
-        role = await RoleCrud.create(db_session, RoleCreate(name="body_test_role"))
-
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=mock_get_db, body_field="role_id"
-            ),
-        )
-        func = dep.dependency
-
-        result = await func(session=db_session, role_id=role.id)
-
-        assert result.id == role.id
-        assert result.name == "body_test_role"
-
-    def test_annotated_session_dep_returns_depends_instance(self):
-        """BodyDependency accepts Annotated[AsyncSession, Depends(...)] form."""
-        dep = BodyDependency(
-            Role, Role.id, session_dep=MockSessionDep, body_field="role_id"
-        )
-        assert isinstance(dep, Depends)
-
-    def test_annotated_session_dep_unwraps_callable(self):
-        """BodyDependency with Annotated form uses the underlying callable, not the Annotated type."""
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=MockSessionDep, body_field="role_id"
-            ),
-        )
-        sig = inspect.signature(dep.dependency)
-
-        inner_dep = sig.parameters["session"].default
-        assert inner_dep.dependency is mock_get_db
-
-    @pytest.mark.anyio
-    async def test_annotated_session_dep_fetches_object(self, db_session):
-        """BodyDependency with Annotated session_dep correctly fetches object from database."""
-        role = await RoleCrud.create(db_session, RoleCreate(name="body_annotated_role"))
-
-        dep = cast(
-            Any,
-            BodyDependency(
-                Role, Role.id, session_dep=MockSessionDep, body_field="role_id"
-            ),
-        )
-        result = await dep.dependency(session=db_session, role_id=role.id)
-
-        assert result.id == role.id
-        assert result.name == "body_annotated_role"
@@ -1,485 +0,0 @@
-"""Live test for the docs/examples/pagination-search.md example.
-
-Spins up the exact FastAPI app described in the example (sourced from
-docs_src/examples/pagination_search/) and exercises it through a real HTTP
-client against a real PostgreSQL database.
-"""
-
-import datetime
-
-import pytest
-from fastapi import FastAPI
-from httpx import ASGITransport, AsyncClient
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from docs_src.examples.pagination_search.db import get_db
-from docs_src.examples.pagination_search.models import Article, Base, Category
-from docs_src.examples.pagination_search.routes import router
-from fastapi_toolsets.exceptions import init_exceptions_handlers
-from fastapi_toolsets.pytest import create_db_session
-
-from .conftest import DATABASE_URL
-
-
-def build_app(session: AsyncSession) -> FastAPI:
-    app = FastAPI()
-    init_exceptions_handlers(app)
-
-    async def override_get_db():
-        yield session
-
-    app.dependency_overrides[get_db] = override_get_db
-    app.include_router(router)
-    return app
-
-
-@pytest.fixture(scope="function")
-async def ex_db_session():
-    """Isolated session for the example models (separate tables from conftest)."""
-    async with create_db_session(DATABASE_URL, Base) as session:
-        yield session
-
-
-@pytest.fixture
-async def client(ex_db_session: AsyncSession):
-    app = build_app(ex_db_session)
-    async with AsyncClient(
-        transport=ASGITransport(app=app), base_url="http://test"
-    ) as ac:
-        yield ac
-
-
-async def seed(session: AsyncSession):
-    """Insert representative fixture data."""
-    python = Category(name="python")
-    backend = Category(name="backend")
-    session.add_all([python, backend])
-    await session.flush()
-
-    now = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
-    session.add_all(
-        [
-            Article(
-                title="FastAPI tips",
-                body="Ten useful tips for FastAPI.",
-                status="published",
-                published=True,
-                category_id=python.id,
-                created_at=now,
-            ),
-            Article(
-                title="SQLAlchemy async",
-                body="How to use async SQLAlchemy.",
-                status="published",
-                published=True,
-                category_id=backend.id,
-                created_at=now + datetime.timedelta(seconds=1),
-            ),
-            Article(
-                title="Draft notes",
-                body="Work in progress.",
-                status="draft",
-                published=False,
-                category_id=None,
-                created_at=now + datetime.timedelta(seconds=2),
-            ),
-        ]
-    )
-    await session.commit()
-
-
-class TestAppSessionDep:
-    @pytest.mark.anyio
-    async def test_get_db_yields_async_session(self):
-        """get_db yields a real AsyncSession when called directly."""
-        from docs_src.examples.pagination_search.db import get_db
-
-        gen = get_db()
-        session = await gen.__anext__()
-        assert isinstance(session, AsyncSession)
-        await gen.aclose()
-
-
-class TestOffsetPagination:
-    @pytest.mark.anyio
-    async def test_returns_all_articles(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination"]["total_count"] == 3
-        assert len(body["data"]) == 3
-
-    @pytest.mark.anyio
-    async def test_pagination_page_size(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?items_per_page=2&page=1")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert len(body["data"]) == 2
-        assert body["pagination"]["total_count"] == 3
-        assert body["pagination"]["has_more"] is True
-
-    @pytest.mark.anyio
-    async def test_full_text_search(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?search=fastapi")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination"]["total_count"] == 1
-        assert body["data"][0]["title"] == "FastAPI tips"
-
-    @pytest.mark.anyio
-    async def test_search_traverses_relationship(
-        self, client: AsyncClient, ex_db_session
-    ):
-        await seed(ex_db_session)
-
-        # "python" matches Category.name, not Article.title or body
-        resp = await client.get("/articles/offset?search=python")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination"]["total_count"] == 1
-        assert body["data"][0]["title"] == "FastAPI tips"
-
-    @pytest.mark.anyio
-    async def test_facet_filter_scalar(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?status=published")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination"]["total_count"] == 2
-        assert all(a["status"] == "published" for a in body["data"])
-
-    @pytest.mark.anyio
-    async def test_facet_filter_multi_value(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?status=published&status=draft")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination"]["total_count"] == 3
-
-    @pytest.mark.anyio
-    async def test_filter_attributes_in_response(
-        self, client: AsyncClient, ex_db_session
-    ):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        fa = body["filter_attributes"]
-        assert set(fa["status"]) == {"draft", "published"}
-        assert set(fa["category__name"]) == {"backend", "python"}
-
-    @pytest.mark.anyio
-    async def test_filter_attributes_scoped_to_filter(
-        self, client: AsyncClient, ex_db_session
-    ):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?status=published")
-
-        body = resp.json()
-        # draft is filtered out → should not appear in filter_attributes
-        assert "draft" not in body["filter_attributes"]["status"]
-
-    @pytest.mark.anyio
-    async def test_search_and_filter_combined(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?search=async&status=published")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination"]["total_count"] == 1
-        assert body["data"][0]["title"] == "SQLAlchemy async"
-
-
-class TestCursorPagination:
-    @pytest.mark.anyio
-    async def test_first_page(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/cursor?items_per_page=2")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert len(body["data"]) == 2
-        assert body["pagination"]["has_more"] is True
-        assert body["pagination"]["next_cursor"] is not None
-        assert body["pagination"]["prev_cursor"] is None
-
-    @pytest.mark.anyio
-    async def test_second_page(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        first = await client.get("/articles/cursor?items_per_page=2")
-        next_cursor = first.json()["pagination"]["next_cursor"]
-
-        resp = await client.get(
-            f"/articles/cursor?items_per_page=2&cursor={next_cursor}"
-        )
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert len(body["data"]) == 1
-        assert body["pagination"]["has_more"] is False
-
-    @pytest.mark.anyio
-    async def test_facet_filter(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/cursor?status=draft")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert len(body["data"]) == 1
-        assert body["data"][0]["status"] == "draft"
-
-    @pytest.mark.anyio
-    async def test_full_text_search(self, client: AsyncClient, ex_db_session):
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/cursor?search=sqlalchemy")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert len(body["data"]) == 1
-        assert body["data"][0]["title"] == "SQLAlchemy async"
-
-
-class TestOffsetSorting:
-    """Tests for order_by / order query parameters on the offset endpoint."""
-
-    @pytest.mark.anyio
-    async def test_default_order_uses_created_at_asc(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """No order_by → default field (created_at) ASC."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset")
-
-        assert resp.status_code == 200
-        titles = [a["title"] for a in resp.json()["data"]]
-        assert titles == ["FastAPI tips", "SQLAlchemy async", "Draft notes"]
-
-    @pytest.mark.anyio
-    async def test_order_by_title_asc(self, client: AsyncClient, ex_db_session):
-        """order_by=title&order=asc returns alphabetical order."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?order_by=title&order=asc")
-
-        assert resp.status_code == 200
-        titles = [a["title"] for a in resp.json()["data"]]
-        assert titles == ["Draft notes", "FastAPI tips", "SQLAlchemy async"]
-
-    @pytest.mark.anyio
-    async def test_order_by_title_desc(self, client: AsyncClient, ex_db_session):
-        """order_by=title&order=desc returns reverse alphabetical order."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?order_by=title&order=desc")
-
-        assert resp.status_code == 200
-        titles = [a["title"] for a in resp.json()["data"]]
-        assert titles == ["SQLAlchemy async", "FastAPI tips", "Draft notes"]
-
-    @pytest.mark.anyio
-    async def test_order_by_created_at_desc(self, client: AsyncClient, ex_db_session):
-        """order_by=created_at&order=desc returns newest-first."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/offset?order_by=created_at&order=desc")
-
-        assert resp.status_code == 200
-        titles = [a["title"] for a in resp.json()["data"]]
-        assert titles == ["Draft notes", "SQLAlchemy async", "FastAPI tips"]
-
-    @pytest.mark.anyio
-    async def test_invalid_order_by_returns_422(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """Unknown order_by field returns 422 with SORT-422 error code."""
-        resp = await client.get("/articles/offset?order_by=nonexistent_field")
-
-        assert resp.status_code == 422
-        body = resp.json()
-        assert body["error_code"] == "SORT-422"
-        assert body["status"] == "FAIL"
-
-
-class TestCursorSorting:
-    """Tests for order_by / order query parameters on the cursor endpoint.
-
-    In cursor_paginate the cursor_column is always the primary sort; order_by
-    acts as a secondary tiebreaker. With the seeded articles (all having unique
-    created_at values) the overall ordering is always created_at ASC regardless
-    of the order_by value — only the valid/invalid field check and the response
-    shape are meaningful here.
-    """
-
-    @pytest.mark.anyio
-    async def test_default_order_uses_created_at_asc(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """No order_by → default field (created_at) ASC."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/cursor")
-
-        assert resp.status_code == 200
-        titles = [a["title"] for a in resp.json()["data"]]
-        assert titles == ["FastAPI tips", "SQLAlchemy async", "Draft notes"]
-
-    @pytest.mark.anyio
-    async def test_order_by_title_asc_accepted(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """order_by=title is a valid field — request succeeds and returns all articles."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/cursor?order_by=title&order=asc")
-
-        assert resp.status_code == 200
-        assert len(resp.json()["data"]) == 3
-
-    @pytest.mark.anyio
-    async def test_order_by_title_desc_accepted(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """order_by=title&order=desc is valid — request succeeds and returns all articles."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/cursor?order_by=title&order=desc")
-
-        assert resp.status_code == 200
-        assert len(resp.json()["data"]) == 3
-
-    @pytest.mark.anyio
-    async def test_invalid_order_by_returns_422(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """Unknown order_by field returns 422 with SORT-422 error code."""
-        resp = await client.get("/articles/cursor?order_by=nonexistent_field")
-
-        assert resp.status_code == 422
-        body = resp.json()
-        assert body["error_code"] == "SORT-422"
-        assert body["status"] == "FAIL"
-
-
-class TestPaginateUnified:
-    """Tests for the unified GET /articles/ endpoint using paginate()."""
-
-    @pytest.mark.anyio
-    async def test_defaults_to_offset_pagination(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """Without pagination_type, defaults to offset pagination."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "offset"
-        assert "total_count" in body["pagination"]
-        assert body["pagination"]["total_count"] == 3
-
-    @pytest.mark.anyio
-    async def test_explicit_offset_pagination(self, client: AsyncClient, ex_db_session):
-        """pagination_type=offset returns OffsetPagination metadata."""
-        await seed(ex_db_session)
-
-        resp = await client.get(
-            "/articles/?pagination_type=offset&page=1&items_per_page=2"
-        )
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "offset"
-        assert body["pagination"]["total_count"] == 3
-        assert body["pagination"]["page"] == 1
-        assert body["pagination"]["has_more"] is True
-        assert len(body["data"]) == 2
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination_type(self, client: AsyncClient, ex_db_session):
-        """pagination_type=cursor returns CursorPagination metadata."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/?pagination_type=cursor&items_per_page=2")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "cursor"
-        assert "next_cursor" in body["pagination"]
-        assert "total_count" not in body["pagination"]
-        assert body["pagination"]["has_more"] is True
-        assert len(body["data"]) == 2
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination_navigate_pages(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """Cursor from first page can be used to fetch the next page."""
-        await seed(ex_db_session)
-
-        first = await client.get("/articles/?pagination_type=cursor&items_per_page=2")
-        assert first.status_code == 200
-        first_body = first.json()
-        next_cursor = first_body["pagination"]["next_cursor"]
-        assert next_cursor is not None
-
-        second = await client.get(
-            f"/articles/?pagination_type=cursor&items_per_page=2&cursor={next_cursor}"
-        )
-        assert second.status_code == 200
-        second_body = second.json()
-        assert second_body["pagination_type"] == "cursor"
-        assert second_body["pagination"]["has_more"] is False
-        assert len(second_body["data"]) == 1
-
-    @pytest.mark.anyio
-    async def test_cursor_pagination_with_search(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """paginate() with cursor type respects search parameter."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/?pagination_type=cursor&search=fastapi")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "cursor"
-        assert len(body["data"]) == 1
-        assert body["data"][0]["title"] == "FastAPI tips"
-
-    @pytest.mark.anyio
-    async def test_offset_pagination_with_filter(
-        self, client: AsyncClient, ex_db_session
-    ):
-        """paginate() with offset type respects filter_by parameter."""
-        await seed(ex_db_session)
-
-        resp = await client.get("/articles/?pagination_type=offset&status=published")
-
-        assert resp.status_code == 200
-        body = resp.json()
-        assert body["pagination_type"] == "offset"
-        assert body["pagination"]["total_count"] == 2
@@ -1,766 +0,0 @@
-"""Tests for fastapi_toolsets.exceptions module."""
-
-import pytest
-from fastapi import FastAPI
-from fastapi.exceptions import HTTPException
-from fastapi.testclient import TestClient
-
-from fastapi_toolsets.exceptions import (
-    ApiException,
-    ConflictError,
-    ForbiddenError,
-    InvalidOrderFieldError,
-    NotFoundError,
-    UnauthorizedError,
-    generate_error_responses,
-    init_exceptions_handlers,
-)
-from fastapi_toolsets.schemas import ApiError
-
-
-class TestApiException:
-    """Tests for ApiException base class."""
-
-    def test_subclass_with_api_error(self):
-        """Subclasses can define api_error."""
-
-        class CustomError(ApiException):
-            api_error = ApiError(
-                code=418,
-                msg="I'm a teapot",
-                desc="The server is a teapot.",
-                err_code="TEA-418",
-            )
-
-        error = CustomError()
-        assert error.api_error.code == 418
-        assert error.api_error.msg == "I'm a teapot"
-        assert str(error) == "I'm a teapot"
-
-    def test_detail_overrides_msg_and_str(self):
-        """detail sets both str(exc) and api_error.msg; class-level msg is unchanged."""
-
-        class CustomError(ApiException):
-            api_error = ApiError(
-                code=400,
-                msg="Bad Request",
-                desc="Request was bad.",
-                err_code="BAD-400",
-            )
-
-        error = CustomError("Widget not found")
-        assert str(error) == "Widget not found"
-        assert error.api_error.msg == "Widget not found"
-        assert CustomError.api_error.msg == "Bad Request"  # class unchanged
-
-    def test_desc_override(self):
-        """desc kwarg overrides api_error.desc on the instance only."""
-
-        class MyError(ApiException):
-            api_error = ApiError(
-                code=400, msg="Error", desc="Default.", err_code="ERR-400"
-            )
-
-        err = MyError(desc="Custom desc.")
-        assert err.api_error.desc == "Custom desc."
-        assert MyError.api_error.desc == "Default."  # class unchanged
-
-    def test_data_override(self):
-        """data kwarg sets api_error.data on the instance only."""
-
-        class MyError(ApiException):
-            api_error = ApiError(
-                code=400, msg="Error", desc="Default.", err_code="ERR-400"
-            )
-
-        err = MyError(data={"key": "value"})
-        assert err.api_error.data == {"key": "value"}
-        assert MyError.api_error.data is None  # class unchanged
-
-    def test_desc_and_data_override(self):
-        """detail, desc and data can all be overridden together."""
-
-        class MyError(ApiException):
-            api_error = ApiError(
-                code=400, msg="Error", desc="Default.", err_code="ERR-400"
-            )
-
-        err = MyError("custom msg", desc="New desc.", data={"x": 1})
-        assert str(err) == "custom msg"
-        assert err.api_error.msg == "custom msg"  # detail also updates msg
-        assert err.api_error.desc == "New desc."
-        assert err.api_error.data == {"x": 1}
-        assert err.api_error.code == 400  # other fields unchanged
-
-    def test_class_api_error_not_mutated_after_instance_override(self):
-        """Raising with desc/data does not mutate the class-level api_error."""
-
-        class MyError(ApiException):
-            api_error = ApiError(
-                code=400, msg="Error", desc="Default.", err_code="ERR-400"
-            )
-
-        MyError(desc="Changed", data={"x": 1})
-        assert MyError.api_error.desc == "Default."
-        assert MyError.api_error.data is None
-
-    def test_subclass_uses_super_with_desc_and_data(self):
-        """Subclasses can delegate detail/desc/data to super().__init__()."""
-
-        class BuildValidationError(ApiException):
-            api_error = ApiError(
-                code=422,
-                msg="Build Validation Error",
-                desc="The build configuration is invalid.",
-                err_code="BUILD-422",
-            )
-
-            def __init__(self, *errors: str) -> None:
-                super().__init__(
-                    f"{len(errors)} validation error(s)",
-                    desc=", ".join(errors),
-                    data={"errors": [{"message": e} for e in errors]},
-                )
-
-        err = BuildValidationError("Field A is required", "Field B is invalid")
-        assert str(err) == "2 validation error(s)"
-        assert err.api_error.msg == "2 validation error(s)"  # detail set msg
-        assert err.api_error.desc == "Field A is required, Field B is invalid"
-        assert err.api_error.data == {
-            "errors": [
-                {"message": "Field A is required"},
-                {"message": "Field B is invalid"},
-            ]
-        }
-        assert err.api_error.code == 422  # other fields unchanged
-
-    def test_detail_desc_data_in_http_response(self):
-        """detail/desc/data overrides all appear correctly in the FastAPI HTTP response."""
-
-        class DynamicError(ApiException):
-            api_error = ApiError(
-                code=400, msg="Error", desc="Default.", err_code="ERR-400"
-            )
-
-            def __init__(self, message: str) -> None:
-                super().__init__(
-                    message,
-                    desc=f"Detail: {message}",
-                    data={"reason": message},
-                )
-
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/error")
-        async def raise_error():
-            raise DynamicError("something went wrong")
-
-        client = TestClient(app)
-        response = client.get("/error")
-
-        assert response.status_code == 400
-        body = response.json()
-        assert body["message"] == "something went wrong"
-        assert body["description"] == "Detail: something went wrong"
-        assert body["data"] == {"reason": "something went wrong"}
-
-
-class TestApiExceptionGuard:
-    """Tests for the __init_subclass__ api_error guard."""
-
-    def test_missing_api_error_raises_type_error(self):
-        """Defining a subclass without api_error raises TypeError at class creation time."""
-        with pytest.raises(
-            TypeError, match="must define an 'api_error' class attribute"
-        ):
-
-            class BrokenError(ApiException):
-                pass
-
-    def test_abstract_subclass_skips_guard(self):
-        """abstract=True allows intermediate base classes without api_error."""
-
-        class BaseGroupError(ApiException, abstract=True):
-            pass
-
-        # Concrete child must still define it
-        class ConcreteError(BaseGroupError):
-            api_error = ApiError(
-                code=400, msg="Error", desc="Desc.", err_code="ERR-400"
-            )
-
-        err = ConcreteError()
-        assert err.api_error.code == 400
-
-    def test_abstract_child_still_requires_api_error_on_concrete(self):
-        """Concrete subclass of an abstract class must define api_error."""
-
-        class Base(ApiException, abstract=True):
-            pass
-
-        with pytest.raises(
-            TypeError, match="must define an 'api_error' class attribute"
-        ):
-
-            class Concrete(Base):
-                pass
-
-    def test_inherited_api_error_satisfies_guard(self):
-        """Subclass that inherits api_error from a parent does not need its own."""
-
-        class ConcreteError(NotFoundError):
-            pass
-
-        err = ConcreteError()
-        assert err.api_error.code == 404
-
-
-class TestBuiltInExceptions:
-    """Tests for built-in exception classes."""
-
-    def test_unauthorized_error(self):
-        """UnauthorizedError has correct attributes."""
-        error = UnauthorizedError()
-        assert error.api_error.code == 401
-        assert error.api_error.err_code == "AUTH-401"
-
-    def test_forbidden_error(self):
-        """ForbiddenError has correct attributes."""
-        error = ForbiddenError()
-        assert error.api_error.code == 403
-        assert error.api_error.err_code == "AUTH-403"
-
-    def test_not_found_error(self):
-        """NotFoundError has correct attributes."""
-        error = NotFoundError()
-        assert error.api_error.code == 404
-        assert error.api_error.err_code == "RES-404"
-
-    def test_conflict_error(self):
-        """ConflictError has correct attributes."""
-        error = ConflictError()
-        assert error.api_error.code == 409
-        assert error.api_error.err_code == "RES-409"
-
-
-class TestGenerateErrorResponses:
-    """Tests for generate_error_responses function."""
-
-    def test_generates_single_response(self):
-        """Generates response for single exception."""
-        responses = generate_error_responses(NotFoundError)
-
-        assert 404 in responses
-        assert responses[404]["description"] == "Not Found"
-
-    def test_generates_multiple_responses(self):
-        """Generates responses for multiple exceptions with distinct status codes."""
-        responses = generate_error_responses(
-            UnauthorizedError,
-            ForbiddenError,
-            NotFoundError,
-        )
-
-        assert 401 in responses
-        assert 403 in responses
-        assert 404 in responses
-
-    def test_response_has_named_example(self):
-        """Generated response uses named examples keyed by err_code."""
-        responses = generate_error_responses(NotFoundError)
-        examples = responses[404]["content"]["application/json"]["examples"]
-
-        assert "RES-404" in examples
-        value = examples["RES-404"]["value"]
-        assert value["status"] == "FAIL"
-        assert value["error_code"] == "RES-404"
-        assert value["message"] == "Not Found"
-        assert value["data"] is None
-
-    def test_response_example_has_summary(self):
-        """Each named example carries a summary equal to api_error.msg."""
-        responses = generate_error_responses(NotFoundError)
-        example = responses[404]["content"]["application/json"]["examples"]["RES-404"]
-
-        assert example["summary"] == "Not Found"
-
-    def test_response_example_with_data(self):
-        """Generated response includes data when set on ApiError."""
-
-        class ErrorWithData(ApiException):
-            api_error = ApiError(
-                code=400,
-                msg="Bad Request",
-                desc="Invalid input.",
-                err_code="BAD-400",
-                data={"details": "some context"},
-            )
-
-        responses = generate_error_responses(ErrorWithData)
-        value = responses[400]["content"]["application/json"]["examples"]["BAD-400"][
-            "value"
-        ]
-
-        assert value["data"] == {"details": "some context"}
-
-    def test_two_errors_same_code_both_present(self):
-        """Two exceptions with the same HTTP code produce two named examples."""
-
-        class BadRequestA(ApiException):
-            api_error = ApiError(
-                code=400, msg="Bad A", desc="Reason A.", err_code="ERR-A"
-            )
-
-        class BadRequestB(ApiException):
-            api_error = ApiError(
-                code=400, msg="Bad B", desc="Reason B.", err_code="ERR-B"
-            )
-
-        responses = generate_error_responses(BadRequestA, BadRequestB)
-
-        assert 400 in responses
-        examples = responses[400]["content"]["application/json"]["examples"]
-        assert "ERR-A" in examples
-        assert "ERR-B" in examples
-        assert examples["ERR-A"]["value"]["message"] == "Bad A"
-        assert examples["ERR-B"]["value"]["message"] == "Bad B"
-
-    def test_two_errors_same_code_single_top_level_entry(self):
-        """Two exceptions with the same HTTP code produce exactly one top-level entry."""
-
-        class BadRequestA(ApiException):
-            api_error = ApiError(
-                code=400, msg="Bad A", desc="Reason A.", err_code="ERR-A"
-            )
-
-        class BadRequestB(ApiException):
-            api_error = ApiError(
-                code=400, msg="Bad B", desc="Reason B.", err_code="ERR-B"
-            )
-
-        responses = generate_error_responses(BadRequestA, BadRequestB)
-        assert len([k for k in responses if k == 400]) == 1
-
-
-class TestInitExceptionsHandlers:
-    """Tests for init_exceptions_handlers function."""
-
-    def test_returns_app(self):
-        """Returns the FastAPI app."""
-        app = FastAPI()
-        result = init_exceptions_handlers(app)
-        assert result is app
-
-    def test_handles_api_exception(self):
-        """Handles ApiException with structured response."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/error")
-        async def raise_error():
-            raise NotFoundError()
-
-        client = TestClient(app)
-        response = client.get("/error")
-
-        assert response.status_code == 404
-        data = response.json()
-        assert data["status"] == "FAIL"
-        assert data["error_code"] == "RES-404"
-        assert data["message"] == "Not Found"
-
-    def test_handles_api_exception_without_data(self):
-        """ApiException without data returns null data field."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/error")
-        async def raise_error():
-            raise NotFoundError()
-
-        client = TestClient(app)
-        response = client.get("/error")
-
-        assert response.status_code == 404
-        assert response.json()["data"] is None
-
-    def test_handles_api_exception_with_data(self):
-        """ApiException with data returns the data payload."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        class CustomValidationError(ApiException):
-            api_error = ApiError(
-                code=422,
-                msg="Validation Error",
-                desc="1 validation error(s) detected",
-                err_code="CUSTOM-422",
-                data={
-                    "errors": [
-                        {
-                            "field": "email",
-                            "message": "invalid format",
-                            "type": "value_error",
-                        }
-                    ]
-                },
-            )
-
-        @app.get("/error")
-        async def raise_error():
-            raise CustomValidationError()
-
-        client = TestClient(app)
-        response = client.get("/error")
-
-        assert response.status_code == 422
-        data = response.json()
-        assert data["data"] == {
-            "errors": [
-                {"field": "email", "message": "invalid format", "type": "value_error"}
-            ]
-        }
-        assert data["error_code"] == "CUSTOM-422"
-
-    def test_handles_validation_error(self):
-        """Handles validation errors with structured response."""
-        from pydantic import BaseModel
-
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        class Item(BaseModel):
-            name: str
-            price: float
-
-        @app.post("/items")
-        async def create_item(item: Item):
-            return item
-
-        client = TestClient(app)
-        response = client.post("/items", json={"name": 123})
-
-        assert response.status_code == 422
-        data = response.json()
-        assert data["status"] == "FAIL"
-        assert data["error_code"] == "VAL-422"
-        assert "errors" in data["data"]
-
-    def test_handles_generic_exception(self):
-        """Handles unhandled exceptions with 500 response."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/crash")
-        async def crash():
-            raise RuntimeError("Something went wrong")
-
-        client = TestClient(app, raise_server_exceptions=False)
-        response = client.get("/crash")
-
-        assert response.status_code == 500
-        data = response.json()
-        assert data["status"] == "FAIL"
-        assert data["error_code"] == "SERVER-500"
-
-    def test_handles_http_exception(self):
-        """Handles starlette HTTPException with consistent ErrorResponse envelope."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/protected")
-        async def protected():
-            raise HTTPException(status_code=403, detail="Forbidden")
-
-        client = TestClient(app)
-        response = client.get("/protected")
-
-        assert response.status_code == 403
-        data = response.json()
-        assert data["status"] == "FAIL"
-        assert data["error_code"] == "HTTP-403"
-        assert data["message"] == "Forbidden"
-
-    def test_handles_http_exception_404_from_route(self):
-        """HTTPException(404) raised inside a route uses the consistent ErrorResponse envelope."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/items/{item_id}")
-        async def get_item(item_id: int):
-            raise HTTPException(status_code=404, detail="Item not found")
-
-        client = TestClient(app)
-        response = client.get("/items/99")
-
-        assert response.status_code == 404
-        data = response.json()
-        assert data["status"] == "FAIL"
-        assert data["error_code"] == "HTTP-404"
-        assert data["message"] == "Item not found"
-
-    def test_handles_http_exception_forwards_headers(self):
-        """HTTPException with WWW-Authenticate header forwards it in the response."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/secure")
-        async def secure():
-            raise HTTPException(
-                status_code=401,
-                detail="Not authenticated",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-
-        client = TestClient(app)
-        response = client.get("/secure")
-
-        assert response.status_code == 401
-        assert response.headers.get("www-authenticate") == "Bearer"
-
-    def test_custom_openapi_schema(self):
-        """Customises OpenAPI schema for 422 responses using named examples."""
-        from pydantic import BaseModel
-
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        class Item(BaseModel):
-            name: str
-
-        @app.post("/items")
-        async def create_item(item: Item):
-            return item
-
-        openapi = app.openapi()
-
-        post_op = openapi["paths"]["/items"]["post"]
-        assert "422" in post_op["responses"]
-        resp_422 = post_op["responses"]["422"]
-        examples = resp_422["content"]["application/json"]["examples"]
-        assert "VAL-422" in examples
-        assert examples["VAL-422"]["value"]["error_code"] == "VAL-422"
-
-    def test_custom_openapi_preserves_app_metadata(self):
-        """_patched_openapi preserves custom FastAPI app-level metadata."""
-        app = FastAPI(
-            title="My API",
-            version="2.0.0",
-            description="Custom description",
-        )
-        init_exceptions_handlers(app)
-
-        schema = app.openapi()
-        assert schema["info"]["title"] == "My API"
-        assert schema["info"]["version"] == "2.0.0"
-
-    def test_handles_response_validation_error(self):
-        """Handles ResponseValidationError with a structured 422 response."""
-        from pydantic import BaseModel
-
-        class CountResponse(BaseModel):
-            count: int
-
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/broken", response_model=CountResponse)
-        async def broken():
-            return {"count": "not-a-number"}  # triggers ResponseValidationError
-
-        client = TestClient(app, raise_server_exceptions=False)
-        response = client.get("/broken")
-
-        assert response.status_code == 422
-        data = response.json()
-        assert data["status"] == "FAIL"
-        assert data["error_code"] == "VAL-422"
-        assert "errors" in data["data"]
-
-    def test_handles_validation_error_with_non_standard_loc(self):
-        """Validation error with empty loc tuple maps the field to 'root'."""
-        from fastapi.exceptions import RequestValidationError
-
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/root-error")
-        async def root_error():
-            raise RequestValidationError(
-                [
-                    {
-                        "type": "custom",
-                        "loc": (),
-                        "msg": "root level error",
-                        "input": None,
-                        "url": "",
-                    }
-                ]
-            )
-
-        client = TestClient(app)
-        response = client.get("/root-error")
-
-        assert response.status_code == 422
-        data = response.json()
-        assert data["data"]["errors"][0]["field"] == "root"
-
-    def test_openapi_schema_cached_after_first_call(self):
-        """app.openapi() returns the cached schema on subsequent calls."""
-        from pydantic import BaseModel
-
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        class Item(BaseModel):
-            name: str
-
-        @app.post("/items")
-        async def create_item(item: Item):
-            return item
-
-        schema_first = app.openapi()
-        schema_second = app.openapi()
-        assert schema_first is schema_second
-
-    def test_openapi_skips_operations_without_422(self):
-        """_patched_openapi leaves operations that have no 422 response unchanged."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/ping")
-        async def ping():
-            return {"ok": True}
-
-        schema = app.openapi()
-        get_op = schema["paths"]["/ping"]["get"]
-        assert "422" not in get_op["responses"]
-        assert "200" in get_op["responses"]
-
-    def test_openapi_skips_non_dict_path_item_values(self):
-        """_patched_openapi ignores non-dict values in path items (e.g. path-level parameters)."""
-        from fastapi_toolsets.exceptions.handler import _patched_openapi
-
-        app = FastAPI()
-
-        def fake_openapi() -> dict:
-            return {
-                "paths": {
-                    "/items": {
-                        "parameters": [
-                            {"name": "q", "in": "query"}
-                        ],  # list, not a dict
-                        "get": {"responses": {"200": {"description": "OK"}}},
-                    }
-                }
-            }
-
-        schema = _patched_openapi(app, fake_openapi)
-        # The list value was skipped without error; the GET operation is intact
-        assert schema["paths"]["/items"]["parameters"] == [{"name": "q", "in": "query"}]
-        assert "422" not in schema["paths"]["/items"]["get"]["responses"]
-
-
-class TestExceptionIntegration:
-    """Integration tests for exception handling."""
-
-    @pytest.fixture
-    def app_with_routes(self):
-        """Create app with test routes."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/users/{user_id}")
-        async def get_user(user_id: int):
-            if user_id == 404:
-                raise NotFoundError()
-            if user_id == 401:
-                raise UnauthorizedError()
-            if user_id == 403:
-                raise ForbiddenError()
-            if user_id == 409:
-                raise ConflictError()
-            return {"id": user_id}
-
-        return app
-
-    def test_not_found_response(self, app_with_routes):
-        """NotFoundError returns 404."""
-        client = TestClient(app_with_routes)
-        response = client.get("/users/404")
-
-        assert response.status_code == 404
-        assert response.json()["error_code"] == "RES-404"
-
-    def test_unauthorized_response(self, app_with_routes):
-        """UnauthorizedError returns 401."""
-        client = TestClient(app_with_routes)
-        response = client.get("/users/401")
-
-        assert response.status_code == 401
-        assert response.json()["error_code"] == "AUTH-401"
-
-    def test_forbidden_response(self, app_with_routes):
-        """ForbiddenError returns 403."""
-        client = TestClient(app_with_routes)
-        response = client.get("/users/403")
-
-        assert response.status_code == 403
-        assert response.json()["error_code"] == "AUTH-403"
-
-    def test_conflict_response(self, app_with_routes):
-        """ConflictError returns 409."""
-        client = TestClient(app_with_routes)
-        response = client.get("/users/409")
-
-        assert response.status_code == 409
-        assert response.json()["error_code"] == "RES-409"
-
-    def test_success_response(self, app_with_routes):
-        """Successful requests return normally."""
-        client = TestClient(app_with_routes)
-        response = client.get("/users/1")
-
-        assert response.status_code == 200
-        assert response.json() == {"id": 1}
-
-
-class TestInvalidOrderFieldError:
-    """Tests for InvalidOrderFieldError exception."""
-
-    def test_api_error_attributes(self):
-        """InvalidOrderFieldError has correct api_error metadata."""
-        assert InvalidOrderFieldError.api_error.code == 422
-        assert InvalidOrderFieldError.api_error.err_code == "SORT-422"
-        assert InvalidOrderFieldError.api_error.msg == "Invalid Order Field"
-
-    def test_stores_field_and_valid_fields(self):
-        """InvalidOrderFieldError stores field and valid_fields on the instance."""
-        error = InvalidOrderFieldError("unknown", ["name", "created_at"])
-        assert error.field == "unknown"
-        assert error.valid_fields == ["name", "created_at"]
-
-    def test_description_contains_field_and_valid_fields(self):
-        """api_error.desc mentions the bad field and valid options."""
-        error = InvalidOrderFieldError("bad_field", ["name", "email"])
-        assert "bad_field" in error.api_error.desc
-        assert "name" in error.api_error.desc
-        assert "email" in error.api_error.desc
-
-    def test_handled_as_422_by_exception_handler(self):
-        """init_exceptions_handlers turns InvalidOrderFieldError into a 422 response."""
-        app = FastAPI()
-        init_exceptions_handlers(app)
-
-        @app.get("/items")
-        async def list_items():
-            raise InvalidOrderFieldError("bad", ["name"])
-
-        client = TestClient(app)
-        response = client.get("/items")
-
-        assert response.status_code == 422
-        data = response.json()
-        assert data["error_code"] == "SORT-422"
-        assert data["status"] == "FAIL"
@@ -1,210 +0,0 @@
-"""Tests for optional dependency import guards."""
-
-import importlib
-import sys
-from unittest.mock import patch
-
-import pytest
-
-from fastapi_toolsets._imports import require_extra
-
-
-class TestRequireExtra:
-    """Tests for the require_extra helper."""
-
-    def test_raises_import_error(self):
-        """require_extra raises ImportError."""
-        with pytest.raises(ImportError):
-            require_extra(package="some_pkg", extra="some_extra")
-
-    def test_error_message_contains_package_name(self):
-        """Error message mentions the missing package."""
-        with pytest.raises(ImportError, match="'prometheus_client'"):
-            require_extra(package="prometheus_client", extra="metrics")
-
-    def test_error_message_contains_install_instruction(self):
-        """Error message contains the pip install command."""
-        with pytest.raises(
-            ImportError, match=r"pip install fastapi-toolsets\[metrics\]"
-        ):
-            require_extra(package="prometheus_client", extra="metrics")
-
-
-def _reload_without_package(module_path: str, blocked_packages: list[str]):
-    """Reload a module while blocking specific package imports.
-
-    Removes the target module and its parents from sys.modules so they
-    get re-imported, and patches builtins.__import__ to raise ImportError
-    for *blocked_packages*.
-    """
-    # Remove cached modules so they get re-imported
-    to_remove = [
-        key
-        for key in sys.modules
-        if key == module_path or key.startswith(module_path + ".")
-    ]
-    saved = {}
-    for key in to_remove:
-        saved[key] = sys.modules.pop(key)
-
-    # Also remove parent package to force re-execution of __init__.py
-    parts = module_path.rsplit(".", 1)
-    if len(parts) == 2:
-        parent = parts[0]
-        parent_keys = [
-            key for key in sys.modules if key == parent or key.startswith(parent + ".")
-        ]
-        for key in parent_keys:
-            if key not in saved:
-                saved[key] = sys.modules.pop(key)
-
-    original_import = (
-        __builtins__.__import__ if hasattr(__builtins__, "__import__") else __import__
-    )
-
-    def blocking_import(name, *args, **kwargs):
-        for blocked in blocked_packages:
-            if name == blocked or name.startswith(blocked + "."):
-                raise ImportError(f"Mocked: No module named '{name}'")
-        return original_import(name, *args, **kwargs)
-
-    return saved, blocking_import
-
-
-class TestMetricsImportGuard:
-    """Tests for metrics module import guard when prometheus_client is missing."""
-
-    def test_registry_imports_without_prometheus(self):
-        """Metric and MetricsRegistry are importable without prometheus_client."""
-        saved, blocking_import = _reload_without_package(
-            "fastapi_toolsets.metrics", ["prometheus_client"]
-        )
-        try:
-            with patch("builtins.__import__", side_effect=blocking_import):
-                mod = importlib.import_module("fastapi_toolsets.metrics")
-                # Registry types should be available (they're stdlib-only)
-                assert hasattr(mod, "Metric")
-                assert hasattr(mod, "MetricsRegistry")
-        finally:
-            # Restore original modules
-            for key in list(sys.modules):
-                if key.startswith("fastapi_toolsets.metrics"):
-                    sys.modules.pop(key, None)
-            sys.modules.update(saved)
-
-    def test_init_metrics_stub_raises_without_prometheus(self):
-        """init_metrics raises ImportError when prometheus_client is missing."""
-        saved, blocking_import = _reload_without_package(
-            "fastapi_toolsets.metrics", ["prometheus_client"]
-        )
-        try:
-            with patch("builtins.__import__", side_effect=blocking_import):
-                mod = importlib.import_module("fastapi_toolsets.metrics")
-                with pytest.raises(ImportError, match="prometheus_client"):
-                    mod.init_metrics(None, None)  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
-        finally:
-            for key in list(sys.modules):
-                if key.startswith("fastapi_toolsets.metrics"):
-                    sys.modules.pop(key, None)
-            sys.modules.update(saved)
-
-    def test_init_metrics_works_with_prometheus(self):
-        """init_metrics is the real function when prometheus_client is available."""
-        from fastapi_toolsets.metrics import init_metrics
-
-        # Should be the real function, not a stub
-        assert init_metrics.__module__ == "fastapi_toolsets.metrics.handler"
-
-
-class TestPytestImportGuard:
-    """Tests for pytest module import guard when dependencies are missing."""
-
-    def test_import_raises_without_pytest_package(self):
-        """Importing fastapi_toolsets.pytest raises when pytest is missing."""
-        saved, blocking_import = _reload_without_package(
-            "fastapi_toolsets.pytest", ["pytest"]
-        )
-        try:
-            with patch("builtins.__import__", side_effect=blocking_import):
-                with pytest.raises(ImportError, match="pytest"):
-                    importlib.import_module("fastapi_toolsets.pytest")
-        finally:
-            for key in list(sys.modules):
-                if key.startswith("fastapi_toolsets.pytest"):
-                    sys.modules.pop(key, None)
-            sys.modules.update(saved)
-
-    def test_import_raises_without_httpx(self):
-        """Importing fastapi_toolsets.pytest raises when httpx is missing."""
-        saved, blocking_import = _reload_without_package(
-            "fastapi_toolsets.pytest", ["httpx"]
-        )
-        try:
-            with patch("builtins.__import__", side_effect=blocking_import):
-                with pytest.raises(ImportError, match="httpx"):
-                    importlib.import_module("fastapi_toolsets.pytest")
-        finally:
-            for key in list(sys.modules):
-                if key.startswith("fastapi_toolsets.pytest"):
-                    sys.modules.pop(key, None)
-            sys.modules.update(saved)
-
-    def test_all_exports_available_with_deps(self):
-        """All expected exports are available when deps are installed."""
-        from fastapi_toolsets.pytest import (
-            cleanup_tables,
-            create_async_client,
-            create_db_session,
-            create_worker_database,
-            register_fixtures,
-            worker_database_url,
-        )
-
-        assert callable(register_fixtures)
-        assert callable(create_async_client)
-        assert callable(create_db_session)
-        assert callable(create_worker_database)
-        assert callable(worker_database_url)
-        assert callable(cleanup_tables)
-
-
-class TestCliImportGuard:
-    """Tests for CLI module import guard when typer is missing."""
-
-    @pytest.mark.parametrize(
-        "expected_match",
-        [
-            "typer",
-            r"pip install fastapi-toolsets\[cli\]",
-        ],
-    )
-    def test_import_raises_without_typer(self, expected_match):
-        """Importing cli.app raises when typer is missing, with an informative error message."""
-        saved, blocking_import = _reload_without_package(
-            "fastapi_toolsets.cli.app", ["typer"]
-        )
-        # Also remove cli.config since it imports typer too
-        config_keys = [
-            k for k in sys.modules if k.startswith("fastapi_toolsets.cli.config")
-        ]
-        for key in config_keys:
-            if key not in saved:
-                saved[key] = sys.modules.pop(key)
-
-        try:
-            with patch("builtins.__import__", side_effect=blocking_import):
-                with pytest.raises(ImportError, match=expected_match):
-                    importlib.import_module("fastapi_toolsets.cli.app")
-        finally:
-            for key in list(sys.modules):
-                if key.startswith("fastapi_toolsets.cli.app") or key.startswith(
-                    "fastapi_toolsets.cli.config"
-                ):
-                    sys.modules.pop(key, None)
-            sys.modules.update(saved)
-
-    def test_async_command_imports_without_typer(self):
-        """async_command is importable without typer (stdlib only)."""
-        from fastapi_toolsets.cli import async_command
-
-        assert callable(async_command)
@@ -1,118 +0,0 @@
-import logging
-import sys
-
-import pytest
-
-from fastapi_toolsets.logger import (
-    DEFAULT_FORMAT,
-    UVICORN_LOGGERS,
-    configure_logging,
-    get_logger,
-)
-
-
-@pytest.fixture(autouse=True)
-def _reset_loggers():
-    """Reset the root and uvicorn loggers after each test."""
-    yield
-    root = logging.getLogger()
-    root.handlers.clear()
-    root.setLevel(logging.WARNING)
-    for name in UVICORN_LOGGERS:
-        uv = logging.getLogger(name)
-        uv.handlers.clear()
-        uv.setLevel(logging.NOTSET)
-
-
-class TestConfigureLogging:
-    def test_sets_up_handler_and_format(self):
-        logger = configure_logging()
-
-        assert len(logger.handlers) == 1
-        handler = logger.handlers[0]
-        assert isinstance(handler, logging.StreamHandler)
-        assert handler.stream is sys.stdout
-        assert handler.formatter is not None
-        assert handler.formatter._fmt == DEFAULT_FORMAT
-
-    def test_default_level_is_info(self):
-        logger = configure_logging()
-
-        assert logger.level == logging.INFO
-
-    def test_custom_level_string(self):
-        logger = configure_logging(level="DEBUG")
-
-        assert logger.level == logging.DEBUG
-
-    def test_custom_level_int(self):
-        logger = configure_logging(level=logging.WARNING)
-
-        assert logger.level == logging.WARNING
-
-    def test_custom_format(self):
-        custom_fmt = "%(levelname)s: %(message)s"
-        logger = configure_logging(fmt=custom_fmt)
-
-        handler = logger.handlers[0]
-        assert handler.formatter is not None
-        assert handler.formatter._fmt == custom_fmt
-
-    def test_named_logger(self):
-        logger = configure_logging(logger_name="myapp")
-
-        assert logger.name == "myapp"
-        assert len(logger.handlers) == 1
-
-    def test_default_configures_root_logger(self):
-        logger = configure_logging()
-
-        assert logger is logging.getLogger()
-
-    def test_idempotent_no_duplicate_handlers(self):
-        configure_logging()
-        configure_logging()
-        logger = configure_logging()
-
-        assert len(logger.handlers) == 1
-
-    def test_configures_uvicorn_loggers(self):
-        configure_logging(level="DEBUG")
-
-        for name in UVICORN_LOGGERS:
-            uv_logger = logging.getLogger(name)
-            assert len(uv_logger.handlers) == 1
-            assert uv_logger.level == logging.DEBUG
-            handler = uv_logger.handlers[0]
-            assert handler.formatter is not None
-            assert handler.formatter._fmt == DEFAULT_FORMAT
-
-    def test_returns_configured_logger(self):
-        logger = configure_logging(logger_name="test.return")
-
-        assert isinstance(logger, logging.Logger)
-        assert logger.name == "test.return"
-
-
-class TestGetLogger:
-    def test_returns_named_logger(self):
-        logger = get_logger("myapp.services")
-
-        assert isinstance(logger, logging.Logger)
-        assert logger.name == "myapp.services"
-
-    def test_returns_root_logger_when_none(self):
-        logger = get_logger(None)
-
-        assert logger is logging.getLogger()
-
-    def test_defaults_to_caller_module_name(self):
-        logger = get_logger()
-
-        assert logger.name == __name__
-
-    def test_same_name_returns_same_logger(self):
-        a = get_logger("myapp")
-        b = get_logger("myapp")
-
-        assert a is b
@@ -1,549 +0,0 @@
-"""Tests for fastapi_toolsets.metrics module."""
-
-import tempfile
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-from prometheus_client import REGISTRY, CollectorRegistry, Counter, Gauge
-
-from fastapi_toolsets.metrics import Metric, MetricsRegistry, init_metrics
-
-
-@pytest.fixture(autouse=True)
-def _clean_prometheus_registry():
-    """Unregister test collectors from the global registry after each test."""
-    yield
-    collectors = list(REGISTRY._names_to_collectors.values())
-    for collector in collectors:
-        try:
-            REGISTRY.unregister(collector)
-        except Exception:
-            pass
-
-
-class TestMetric:
-    """Tests for Metric dataclass."""
-
-    def test_default_collect_is_false(self):
-        """Default collect is False (provider mode)."""
-        definition = Metric(name="test", func=lambda: None)
-        assert definition.collect is False
-
-    def test_collect_true(self):
-        """Collect can be set to True (collector mode)."""
-        definition = Metric(name="test", func=lambda: None, collect=True)
-        assert definition.collect is True
-
-
-class TestMetricsRegistry:
-    """Tests for MetricsRegistry class."""
-
-    def test_register_with_decorator(self):
-        """Register metric with bare decorator."""
-        registry = MetricsRegistry()
-
-        @registry.register
-        def my_counter():
-            return Counter("test_counter", "A test counter")
-
-        names = [m.name for m in registry.get_all()]
-        assert "my_counter" in names
-
-    def test_register_with_custom_name(self):
-        """Register metric with custom name."""
-        registry = MetricsRegistry()
-
-        @registry.register(name="custom_name")
-        def my_counter():
-            return Counter("test_counter_2", "A test counter")
-
-        definition = registry.get_all()[0]
-        assert definition.name == "custom_name"
-
-    def test_register_as_collector(self):
-        """Register metric with collect=True."""
-        registry = MetricsRegistry()
-
-        @registry.register(collect=True)
-        def collect_something():
-            pass
-
-        definition = registry.get_all()[0]
-        assert definition.collect is True
-
-    def test_register_preserves_function(self):
-        """Decorator returns the original function unchanged."""
-        registry = MetricsRegistry()
-
-        def my_func():
-            return "original"
-
-        result = registry.register(my_func)
-        assert result is my_func
-        assert result() == "original"
-
-    def test_register_parameterized_preserves_function(self):
-        """Parameterized decorator returns the original function unchanged."""
-        registry = MetricsRegistry()
-
-        def my_func():
-            return "original"
-
-        result = registry.register(name="custom")(my_func)
-        assert result is my_func
-        assert result() == "original"
-
-    def test_get_all(self):
-        """Get all registered metrics."""
-        registry = MetricsRegistry()
-
-        @registry.register
-        def metric_a():
-            pass
-
-        @registry.register
-        def metric_b():
-            pass
-
-        names = {m.name for m in registry.get_all()}
-        assert names == {"metric_a", "metric_b"}
-
-    def test_get_providers(self):
-        """Get only provider metrics (collect=False)."""
-        registry = MetricsRegistry()
-
-        @registry.register
-        def provider():
-            pass
-
-        @registry.register(collect=True)
-        def collector():
-            pass
-
-        providers = registry.get_providers()
-        assert len(providers) == 1
-        assert providers[0].name == "provider"
-
-    def test_get_collectors(self):
-        """Get only collector metrics (collect=True)."""
-        registry = MetricsRegistry()
-
-        @registry.register
-        def provider():
-            pass
-
-        @registry.register(collect=True)
-        def collector():
-            pass
-
-        collectors = registry.get_collectors()
-        assert len(collectors) == 1
-        assert collectors[0].name == "collector"
-
-    def test_register_overwrites_same_name(self):
-        """Registering with the same name overwrites the previous entry."""
-        registry = MetricsRegistry()
-
-        @registry.register(name="metric")
-        def first():
-            pass
-
-        @registry.register(name="metric")
-        def second():
-            pass
-
-        assert len(registry.get_all()) == 1
-        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."""
-
-    def test_include_empty_registry(self):
-        """Include an empty registry does nothing."""
-        main = MetricsRegistry()
-        other = MetricsRegistry()
-
-        @main.register
-        def metric_a():
-            pass
-
-        main.include_registry(other)
-        assert len(main.get_all()) == 1
-
-    def test_include_registry_adds_metrics(self):
-        """Include registry adds all metrics from the other registry."""
-        main = MetricsRegistry()
-        other = MetricsRegistry()
-
-        @main.register
-        def metric_a():
-            pass
-
-        @other.register
-        def metric_b():
-            pass
-
-        @other.register
-        def metric_c():
-            pass
-
-        main.include_registry(other)
-        names = {m.name for m in main.get_all()}
-        assert names == {"metric_a", "metric_b", "metric_c"}
-
-    def test_include_registry_preserves_collect_flag(self):
-        """Include registry preserves the collect flag."""
-        main = MetricsRegistry()
-        other = MetricsRegistry()
-
-        @other.register(collect=True)
-        def collector():
-            pass
-
-        main.include_registry(other)
-        assert main.get_all()[0].collect is True
-
-    def test_include_registry_raises_on_duplicate(self):
-        """Include registry raises ValueError on duplicate metric names."""
-        main = MetricsRegistry()
-        other = MetricsRegistry()
-
-        @main.register(name="metric")
-        def metric_main():
-            pass
-
-        @other.register(name="metric")
-        def metric_other():
-            pass
-
-        with pytest.raises(ValueError, match="already exists"):
-            main.include_registry(other)
-
-    def test_include_multiple_registries(self):
-        """Include multiple registries sequentially."""
-        main = MetricsRegistry()
-        sub1 = MetricsRegistry()
-        sub2 = MetricsRegistry()
-
-        @main.register
-        def base():
-            pass
-
-        @sub1.register
-        def sub1_metric():
-            pass
-
-        @sub2.register
-        def sub2_metric():
-            pass
-
-        main.include_registry(sub1)
-        main.include_registry(sub2)
-
-        names = {m.name for m in main.get_all()}
-        assert names == {"base", "sub1_metric", "sub2_metric"}
-
-
-class TestInitMetrics:
-    """Tests for init_metrics function."""
-
-    @pytest.fixture
-    def metrics_client(self):
-        """Create a FastAPI app with MetricsRegistry and return a TestClient."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        init_metrics(app, registry)
-        client = TestClient(app)
-        yield client
-        client.close()
-
-    def test_returns_app(self):
-        """Returns the FastAPI app."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        result = init_metrics(app, registry)
-        assert result is app
-
-    def test_metrics_endpoint_responds(self, metrics_client):
-        """The /metrics endpoint returns 200."""
-        response = metrics_client.get("/metrics")
-        assert response.status_code == 200
-
-    def test_metrics_endpoint_content_type(self, metrics_client):
-        """The /metrics endpoint returns prometheus content type."""
-        response = metrics_client.get("/metrics")
-        assert "text/plain" in response.headers["content-type"]
-
-    def test_custom_path(self):
-        """Custom path is used for the metrics endpoint."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        init_metrics(app, registry, path="/custom-metrics")
-
-        client = TestClient(app)
-        assert client.get("/custom-metrics").status_code == 200
-        assert client.get("/metrics").status_code == 404
-
-    def test_providers_called_at_init(self):
-        """Provider functions are called once at init time."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        mock = MagicMock()
-
-        @registry.register
-        def my_provider():
-            mock()
-
-        init_metrics(app, registry)
-
-        mock.assert_called_once()
-
-    def test_collectors_called_on_scrape(self):
-        """Collector functions are called on each scrape."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        mock = MagicMock()
-
-        @registry.register(collect=True)
-        def my_collector():
-            mock()
-
-        init_metrics(app, registry)
-
-        client = TestClient(app)
-        client.get("/metrics")
-        client.get("/metrics")
-
-        assert mock.call_count == 2
-
-    def test_collectors_not_called_at_init(self):
-        """Collector functions are not called at init time."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        mock = MagicMock()
-
-        @registry.register(collect=True)
-        def my_collector():
-            mock()
-
-        init_metrics(app, registry)
-
-        mock.assert_not_called()
-
-    def test_async_collectors_called_on_scrape(self):
-        """Async collector functions are awaited on each scrape."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        mock = AsyncMock()
-
-        @registry.register(collect=True)
-        async def my_async_collector():
-            await mock()
-
-        init_metrics(app, registry)
-
-        client = TestClient(app)
-        client.get("/metrics")
-        client.get("/metrics")
-
-        assert mock.call_count == 2
-
-    def test_mixed_sync_and_async_collectors(self):
-        """Both sync and async collectors are called on scrape."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        sync_mock = MagicMock()
-        async_mock = AsyncMock()
-
-        @registry.register(collect=True)
-        def sync_collector():
-            sync_mock()
-
-        @registry.register(collect=True)
-        async def async_collector():
-            await async_mock()
-
-        init_metrics(app, registry)
-
-        client = TestClient(app)
-        client.get("/metrics")
-
-        sync_mock.assert_called_once()
-        async_mock.assert_called_once()
-
-    def test_registered_metrics_appear_in_output(self):
-        """Metrics created by providers appear in /metrics output."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-
-        @registry.register
-        def my_gauge():
-            g = Gauge("test_gauge_value", "A test gauge")
-            g.set(42)
-            return g
-
-        init_metrics(app, registry)
-
-        client = TestClient(app)
-        response = client.get("/metrics")
-
-        assert b"test_gauge_value" in response.content
-        assert b"42.0" in response.content
-
-    def test_endpoint_not_in_openapi_schema(self):
-        """The /metrics endpoint is not included in the OpenAPI schema."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        init_metrics(app, registry)
-
-        schema = app.openapi()
-        assert "/metrics" not in schema.get("paths", {})
-
-
-class TestMultiProcessMode:
-    """Tests for multi-process Prometheus mode."""
-
-    def test_multiprocess_with_env_var(self, monkeypatch):
-        """Multi-process mode works when PROMETHEUS_MULTIPROC_DIR is set."""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            monkeypatch.setenv("PROMETHEUS_MULTIPROC_DIR", tmpdir)
-            # Use a separate registry to avoid conflicts with default
-            prom_registry = CollectorRegistry()
-            app = FastAPI()
-            registry = MetricsRegistry()
-
-            @registry.register
-            def mp_counter():
-                return Counter(
-                    "mp_test_counter",
-                    "A multiprocess counter",
-                    registry=prom_registry,
-                )
-
-            init_metrics(app, registry)
-
-            client = TestClient(app)
-            response = client.get("/metrics")
-
-            assert response.status_code == 200
-
-    def test_single_process_without_env_var(self, monkeypatch):
-        """Single-process mode when PROMETHEUS_MULTIPROC_DIR is not set."""
-        monkeypatch.delenv("PROMETHEUS_MULTIPROC_DIR", raising=False)
-
-        app = FastAPI()
-        registry = MetricsRegistry()
-
-        @registry.register
-        def sp_gauge():
-            g = Gauge("sp_test_gauge", "A single-process gauge")
-            g.set(99)
-            return g
-
-        init_metrics(app, registry)
-
-        client = TestClient(app)
-        response = client.get("/metrics")
-
-        assert response.status_code == 200
-        assert b"sp_test_gauge" in response.content
-
-
-class TestMetricsIntegration:
-    """Integration tests for the metrics module."""
-
-    def test_full_workflow(self):
-        """Full workflow: registry, providers, collectors, endpoint."""
-        app = FastAPI()
-        registry = MetricsRegistry()
-        call_count = {"value": 0}
-
-        @registry.register
-        def request_counter():
-            return Counter(
-                "integration_requests_total",
-                "Total requests",
-                ["method"],
-            )
-
-        @registry.register(collect=True)
-        def collect_uptime():
-            call_count["value"] += 1
-
-        init_metrics(app, registry)
-
-        client = TestClient(app)
-
-        response = client.get("/metrics")
-        assert response.status_code == 200
-        assert b"integration_requests_total" in response.content
-        assert call_count["value"] == 1
-
-        response = client.get("/metrics")
-        assert call_count["value"] == 2
-
-    def test_multiple_registries_merged(self):
-        """Multiple registries can be merged and used together."""
-        app = FastAPI()
-        main = MetricsRegistry()
-        sub = MetricsRegistry()
-
-        @main.register
-        def main_gauge():
-            g = Gauge("main_gauge_val", "Main gauge")
-            g.set(1)
-            return g
-
-        @sub.register
-        def sub_gauge():
-            g = Gauge("sub_gauge_val", "Sub gauge")
-            g.set(2)
-            return g
-
-        main.include_registry(sub)
-        init_metrics(app, main)
-
-        client = TestClient(app)
-        response = client.get("/metrics")
-
-        assert b"main_gauge_val" in response.content
-        assert b"sub_gauge_val" in response.content
@@ -1,725 +0,0 @@
-"""Tests for fastapi_toolsets.pytest module."""
-
-import uuid
-from typing import cast
-
-import pytest
-from fastapi import Depends, FastAPI
-from httpx import AsyncClient
-from sqlalchemy import ForeignKey, String, select, text
-from sqlalchemy.engine import make_url
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
-
-from fastapi_toolsets.db import get_transaction
-from fastapi_toolsets.fixtures import Context, FixtureRegistry, LoadStrategy
-from fastapi_toolsets.pytest import (
-    create_async_client,
-    create_db_session,
-    create_worker_database,
-    register_fixtures,
-    worker_database_url,
-)
-from fastapi_toolsets.pytest.plugin import (
-    _get_primary_key,
-    _relationship_load_options,
-    _reload_with_relationships,
-)
-from fastapi_toolsets.pytest.utils import _get_xdist_worker
-
-from .conftest import (
-    DATABASE_URL,
-    Base,
-    IntRole,
-    Permission,
-    Role,
-    RoleCrud,
-    User,
-    UserCrud,
-)
-
-test_registry = FixtureRegistry()
-
-# Fixed UUIDs for test fixtures to allow consistent assertions
-ROLE_ADMIN_ID = uuid.UUID("00000000-0000-0000-0000-000000001000")
-ROLE_USER_ID = uuid.UUID("00000000-0000-0000-0000-000000001001")
-USER_ADMIN_ID = uuid.UUID("00000000-0000-0000-0000-000000002000")
-USER_USER_ID = uuid.UUID("00000000-0000-0000-0000-000000002001")
-USER_EXTRA_ID = uuid.UUID("00000000-0000-0000-0000-000000002002")
-
-
-@test_registry.register(contexts=[Context.BASE])
-def roles() -> list[Role]:
-    return [
-        Role(id=ROLE_ADMIN_ID, name="plugin_admin"),
-        Role(id=ROLE_USER_ID, name="plugin_user"),
-    ]
-
-
-@test_registry.register(depends_on=["roles"], contexts=[Context.BASE])
-def users() -> list[User]:
-    return [
-        User(
-            id=USER_ADMIN_ID,
-            username="plugin_admin",
-            email="padmin@test.com",
-            role_id=ROLE_ADMIN_ID,
-        ),
-        User(
-            id=USER_USER_ID,
-            username="plugin_user",
-            email="puser@test.com",
-            role_id=ROLE_USER_ID,
-        ),
-    ]
-
-
-@test_registry.register(depends_on=["users"], contexts=[Context.TESTING])
-def extra_users() -> list[User]:
-    return [
-        User(
-            id=USER_EXTRA_ID,
-            username="plugin_extra",
-            email="pextra@test.com",
-            role_id=ROLE_USER_ID,
-        ),
-    ]
-
-
-register_fixtures(test_registry, globals())
-
-
-class TestRegisterFixtures:
-    """Tests for register_fixtures function."""
-
-    def test_creates_fixtures_in_namespace(self):
-        """Fixtures are created in the namespace."""
-        assert "fixture_roles" in globals()
-        assert "fixture_users" in globals()
-        assert "fixture_extra_users" in globals()
-
-    def test_fixtures_are_callable(self):
-        """Created fixtures are callable."""
-        assert callable(globals()["fixture_roles"])
-        assert callable(globals()["fixture_users"])
-
-
-class TestGeneratedFixtures:
-    """Tests for the generated pytest fixtures."""
-
-    @pytest.mark.anyio
-    async def test_fixture_loads_data(
-        self, db_session: AsyncSession, fixture_roles: list[Role]
-    ):
-        """Fixture loads data into database and returns it."""
-        assert len(fixture_roles) == 2
-        assert fixture_roles[0].name == "plugin_admin"
-        assert fixture_roles[1].name == "plugin_user"
-
-        # Verify data is in database
-        count = await RoleCrud.count(db_session)
-        assert count == 2
-
-    @pytest.mark.anyio
-    async def test_fixture_with_dependency(
-        self, db_session: AsyncSession, fixture_users: list[User]
-    ):
-        """Fixture with dependency loads parent fixture first."""
-        # fixture_users depends on fixture_roles
-        # Both should be loaded
-        assert len(fixture_users) == 2
-
-        # Roles should also be in database
-        roles_count = await RoleCrud.count(db_session)
-        assert roles_count == 2
-
-        # Users should be in database
-        users_count = await UserCrud.count(db_session)
-        assert users_count == 2
-
-    @pytest.mark.anyio
-    async def test_fixture_returns_models(
-        self, db_session: AsyncSession, fixture_users: list[User]
-    ):
-        """Fixture returns actual model instances."""
-        user = fixture_users[0]
-        assert isinstance(user, User)
-        assert user.id == USER_ADMIN_ID
-        assert user.username == "plugin_admin"
-
-    @pytest.mark.anyio
-    async def test_fixture_relationships_work(
-        self, db_session: AsyncSession, fixture_users: list[User]
-    ):
-        """Loaded fixtures have working relationships directly accessible."""
-        user = next(u for u in fixture_users if u.id == USER_ADMIN_ID)
-        assert user.role is not None
-        assert user.role.name == "plugin_admin"
-
-    @pytest.mark.anyio
-    async def test_chained_dependencies(
-        self, db_session: AsyncSession, fixture_extra_users: list[User]
-    ):
-        """Chained dependencies are resolved correctly."""
-        # fixture_extra_users -> fixture_users -> fixture_roles
-        assert len(fixture_extra_users) == 1
-
-        # All fixtures should be loaded
-        roles_count = await RoleCrud.count(db_session)
-        users_count = await UserCrud.count(db_session)
-
-        assert roles_count == 2
-        assert users_count == 3  # 2 from users + 1 from extra_users
-
-    @pytest.mark.anyio
-    async def test_can_query_loaded_data(
-        self, db_session: AsyncSession, fixture_users: list[User]
-    ):
-        """Can query the loaded fixture data."""
-        # Get all users loaded by fixture
-        users = await UserCrud.get_multi(
-            db_session,
-            order_by=User.username,
-        )
-
-        assert len(users) == 2
-        assert users[0].username == "plugin_admin"
-        assert users[1].username == "plugin_user"
-
-    @pytest.mark.anyio
-    async def test_fixture_auto_loads_relationships(
-        self, db_session: AsyncSession, fixture_users: list[User]
-    ):
-        """Fixtures automatically eager-load all direct relationships."""
-        user = next(u for u in fixture_users if u.username == "plugin_admin")
-        assert user.role is not None
-        assert user.role.name == "plugin_admin"
-
-    @pytest.mark.anyio
-    async def test_multiple_fixtures_in_same_test(
-        self,
-        db_session: AsyncSession,
-        fixture_roles: list[Role],
-        fixture_users: list[User],
-    ):
-        """Multiple fixtures can be used in the same test."""
-        assert len(fixture_roles) == 2
-        assert len(fixture_users) == 2
-
-        # Both should be in database
-        roles = await RoleCrud.get_multi(db_session)
-        users = await UserCrud.get_multi(db_session)
-
-        assert len(roles) == 2
-        assert len(users) == 2
-
-
-class TestCreateAsyncClient:
-    """Tests for create_async_client helper."""
-
-    @pytest.mark.anyio
-    async def test_creates_working_client(self):
-        """Client can make requests to the app."""
-        app = FastAPI()
-
-        @app.get("/health")
-        async def health():
-            return {"status": "ok"}
-
-        async with create_async_client(app) as client:
-            assert isinstance(client, AsyncClient)
-            response = await client.get("/health")
-            assert response.status_code == 200
-            assert response.json() == {"status": "ok"}
-
-    @pytest.mark.anyio
-    async def test_custom_base_url(self):
-        """Client uses custom base URL."""
-        app = FastAPI()
-
-        @app.get("/test")
-        async def test_endpoint():
-            return {"url": "test"}
-
-        async with create_async_client(app, base_url="http://custom") as client:
-            assert str(client.base_url) == "http://custom"
-
-    @pytest.mark.anyio
-    async def test_client_closes_properly(self):
-        """Client is properly closed after context exit."""
-        app = FastAPI()
-
-        async with create_async_client(app) as client:
-            client_ref = client
-
-        assert client_ref.is_closed
-
-    @pytest.mark.anyio
-    async def test_dependency_overrides_applied_and_cleaned(self):
-        """Dependency overrides are applied during the context and removed after."""
-        app = FastAPI()
-
-        async def original_dep() -> str:
-            return "original"
-
-        async def override_dep() -> str:
-            return "overridden"
-
-        @app.get("/dep")
-        async def dep_endpoint(value: str = Depends(original_dep)):
-            return {"value": value}
-
-        async with create_async_client(
-            app, dependency_overrides={original_dep: override_dep}
-        ) as client:
-            response = await client.get("/dep")
-            assert response.json() == {"value": "overridden"}
-
-        # Overrides should be cleaned up
-        assert original_dep not in app.dependency_overrides
-
-
-class TestCreateDbSession:
-    """Tests for create_db_session helper."""
-
-    @pytest.mark.anyio
-    async def test_creates_working_session(self):
-        """Session can perform database operations."""
-        role_id = uuid.uuid4()
-        async with create_db_session(DATABASE_URL, Base) as session:
-            assert isinstance(session, AsyncSession)
-
-            role = Role(id=role_id, name="test_helper_role")
-            session.add(role)
-            await session.commit()
-
-            result = await session.execute(select(Role).where(Role.id == role_id))
-            fetched = result.scalar_one()
-            assert fetched.name == "test_helper_role"
-
-    @pytest.mark.anyio
-    async def test_tables_created_before_session(self):
-        """Tables exist when session is yielded."""
-        async with create_db_session(DATABASE_URL, Base) as session:
-            # Should not raise - tables exist
-            result = await session.execute(select(Role))
-            assert result.all() == []
-
-    @pytest.mark.anyio
-    async def test_tables_dropped_after_session(self):
-        """Tables are dropped after session closes when drop_tables=True."""
-        role_id = uuid.uuid4()
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
-            role = Role(id=role_id, name="will_be_dropped")
-            session.add(role)
-            await session.commit()
-
-        # Verify tables were dropped by creating new session
-        async with create_db_session(DATABASE_URL, Base) as session:
-            result = await session.execute(select(Role))
-            assert result.all() == []
-
-    @pytest.mark.anyio
-    async def test_tables_preserved_when_drop_disabled(self):
-        """Tables are preserved when drop_tables=False."""
-        role_id = uuid.uuid4()
-        async with create_db_session(DATABASE_URL, Base, drop_tables=False) as session:
-            role = Role(id=role_id, name="preserved_role")
-            session.add(role)
-            await session.commit()
-
-        # Create another session without dropping
-        async with create_db_session(DATABASE_URL, Base, drop_tables=False) as session:
-            result = await session.execute(select(Role).where(Role.id == role_id))
-            fetched = result.scalar_one_or_none()
-            assert fetched is not None
-            assert fetched.name == "preserved_role"
-
-        # Cleanup: drop tables manually
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as _:
-            pass
-
-    @pytest.mark.anyio
-    async def test_cleanup_truncates_tables(self):
-        """Tables are truncated after session closes when cleanup=True."""
-        role_id = uuid.uuid4()
-        async with create_db_session(
-            DATABASE_URL, Base, cleanup=True, drop_tables=False
-        ) as session:
-            role = Role(id=role_id, name="will_be_cleaned")
-            session.add(role)
-            await session.commit()
-
-        # Data should have been truncated, but tables still exist
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as session:
-            result = await session.execute(select(Role))
-            assert result.all() == []
-
-    @pytest.mark.anyio
-    async def test_get_transaction_commits_visible_to_separate_session(self):
-        """Data written via get_transaction() is committed and visible to other sessions."""
-        role_id = uuid.uuid4()
-
-        async with create_db_session(DATABASE_URL, Base, drop_tables=False) as session:
-            # Simulate what _create_fixture_function does: insert via get_transaction
-            # with no explicit commit afterward.
-            async with get_transaction(session):
-                role = Role(id=role_id, name="visible_to_other_session")
-                session.add(role)
-
-            # The data must have been committed (begin/commit, not a savepoint),
-            # so a separate engine/session can read it.
-            other_engine = create_async_engine(DATABASE_URL, echo=False)
-            try:
-                other_session_maker = async_sessionmaker(
-                    other_engine, expire_on_commit=False
-                )
-                async with other_session_maker() as other:
-                    result = await other.execute(select(Role).where(Role.id == role_id))
-                    fetched = result.scalar_one_or_none()
-                    assert fetched is not None, (
-                        "Fixture data inserted via get_transaction() must be committed "
-                        "and visible to a separate session. If create_db_session uses "
-                        "create_db_context, auto-begin forces get_transaction() into "
-                        "savepoints instead of real commits."
-                    )
-                    assert fetched.name == "visible_to_other_session"
-            finally:
-                await other_engine.dispose()
-
-        # Cleanup
-        async with create_db_session(DATABASE_URL, Base, drop_tables=True) as _:
-            pass
-
-
-class TestGetXdistWorker:
-    """Tests for _get_xdist_worker helper."""
-
-    def test_returns_default_test_db_without_env_var(
-        self, monkeypatch: pytest.MonkeyPatch
-    ):
-        """Returns default_test_db when PYTEST_XDIST_WORKER is not set."""
-        monkeypatch.delenv("PYTEST_XDIST_WORKER", raising=False)
-        assert _get_xdist_worker("my_default") == "my_default"
-
-    def test_returns_worker_name(self, monkeypatch: pytest.MonkeyPatch):
-        """Returns the worker name from the environment variable."""
-        monkeypatch.setenv("PYTEST_XDIST_WORKER", "gw0")
-        assert _get_xdist_worker("ignored") == "gw0"
-
-
-class TestWorkerDatabaseUrl:
-    """Tests for worker_database_url helper."""
-
-    def test_appends_default_test_db_without_xdist(
-        self, monkeypatch: pytest.MonkeyPatch
-    ):
-        """default_test_db is appended when not running under xdist."""
-        monkeypatch.delenv("PYTEST_XDIST_WORKER", raising=False)
-        url = "postgresql+asyncpg://user:pass@localhost:5432/mydb"
-        result = worker_database_url(url, default_test_db="fallback")
-        assert make_url(result).database == "mydb_fallback"
-
-    def test_appends_worker_id_to_database_name(self, monkeypatch: pytest.MonkeyPatch):
-        """Worker name is appended to the database name."""
-        monkeypatch.setenv("PYTEST_XDIST_WORKER", "gw0")
-        url = "postgresql+asyncpg://user:pass@localhost:5432/db"
-        result = worker_database_url(url, default_test_db="unused")
-        assert make_url(result).database == "db_gw0"
-
-    def test_preserves_url_components(self, monkeypatch: pytest.MonkeyPatch):
-        """Host, port, username, password, and driver are preserved."""
-        monkeypatch.setenv("PYTEST_XDIST_WORKER", "gw2")
-        url = "postgresql+asyncpg://myuser:secret@dbhost:6543/testdb"
-        result = make_url(worker_database_url(url, default_test_db="unused"))
-
-        assert result.drivername == "postgresql+asyncpg"
-        assert result.username == "myuser"
-        assert result.password == "secret"
-        assert result.host == "dbhost"
-        assert result.port == 6543
-        assert result.database == "testdb_gw2"
-
-
-class TestCreateWorkerDatabase:
-    """Tests for create_worker_database context manager."""
-
-    @pytest.mark.anyio
-    async def test_creates_default_db_without_xdist(
-        self, monkeypatch: pytest.MonkeyPatch
-    ):
-        """Without xdist, creates a database suffixed with default_test_db."""
-        monkeypatch.delenv("PYTEST_XDIST_WORKER", raising=False)
-        default_test_db = "no_xdist_default"
-        expected_db = make_url(
-            worker_database_url(DATABASE_URL, default_test_db=default_test_db)
-        ).database
-
-        async with create_worker_database(
-            DATABASE_URL, default_test_db=default_test_db
-        ) as url:
-            assert make_url(url).database == expected_db
-
-            engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
-            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
-            await engine.dispose()
-
-        engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
-        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() is None
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_creates_and_drops_worker_database(
-        self, monkeypatch: pytest.MonkeyPatch
-    ):
-        """Worker database exists inside the context and is dropped after."""
-        monkeypatch.setenv("PYTEST_XDIST_WORKER", "gw_test_create")
-        expected_db = make_url(
-            worker_database_url(DATABASE_URL, default_test_db="unused")
-        ).database
-
-        async with create_worker_database(DATABASE_URL) as url:
-            assert make_url(url).database == expected_db
-
-            engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
-            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
-            await engine.dispose()
-
-        engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
-        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() is None
-        await engine.dispose()
-
-    @pytest.mark.anyio
-    async def test_cleans_up_stale_database(self, monkeypatch: pytest.MonkeyPatch):
-        """A pre-existing worker database is dropped and recreated."""
-        monkeypatch.setenv("PYTEST_XDIST_WORKER", "gw_test_stale")
-        expected_db = make_url(
-            worker_database_url(DATABASE_URL, default_test_db="unused")
-        ).database
-
-        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()
-
-        async with create_worker_database(DATABASE_URL) as url:
-            assert make_url(url).database == expected_db
-
-        engine = create_async_engine(DATABASE_URL, isolation_level="AUTOCOMMIT")
-        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() is None
-        await engine.dispose()
-
-
-class _LocalBase(DeclarativeBase):
-    pass
-
-
-class _Group(_LocalBase):
-    __tablename__ = "_test_groups"
-    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(50))
-
-
-class _CompositeItem(_LocalBase):
-    """Model with composite PK and a relationship — exercises the fallback path."""
-
-    __tablename__ = "_test_composite_items"
-    group_id: Mapped[uuid.UUID] = mapped_column(
-        ForeignKey("_test_groups.id"), primary_key=True
-    )
-    item_code: Mapped[str] = mapped_column(String(50), primary_key=True)
-    group: Mapped["_Group"] = relationship()
-
-
-class TestGetPrimaryKey:
-    """Unit tests for _get_primary_key — no DB needed."""
-
-    def test_single_pk_returns_value(self):
-        rid = uuid.UUID("00000000-0000-0000-0000-000000000001")
-        role = Role(id=rid, name="x")
-        assert _get_primary_key(role) == rid
-
-    def test_composite_pk_all_set_returns_tuple(self):
-        perm = Permission(subject="posts", action="read")
-        assert _get_primary_key(perm) == ("posts", "read")
-
-    def test_composite_pk_partial_none_returns_none(self):
-        perm = Permission(subject=None, action="read")
-        assert _get_primary_key(perm) is None
-
-    def test_composite_pk_all_none_returns_none(self):
-        perm = Permission(subject=None, action=None)
-        assert _get_primary_key(perm) is None
-
-
-class TestRelationshipLoadOptions:
-    """Unit tests for _relationship_load_options — no DB needed."""
-
-    def test_empty_for_model_with_no_relationships(self):
-        assert _relationship_load_options(IntRole) == []
-
-    def test_returns_options_for_model_with_relationships(self):
-        opts = _relationship_load_options(User)
-        assert len(opts) >= 1
-
-
-class TestFixtureStrategies:
-    """Integration tests covering INSERT, SKIP_EXISTING, empty fixture, no-rels model."""
-
-    @pytest.mark.anyio
-    async def test_empty_fixture_returns_empty_list(self, db_session: AsyncSession):
-        """Fixture function returning [] produces an empty list."""
-        registry = FixtureRegistry()
-
-        @registry.register()
-        def empty() -> list[Role]:
-            return []
-
-        local_ns: dict = {}
-        register_fixtures(registry, local_ns, session_fixture="db_session")
-        inner = local_ns["fixture_empty"].__wrapped__  # type: ignore[attr-defined]
-        result = await inner(db_session=db_session)
-        assert result == []
-
-    @pytest.mark.anyio
-    async def test_insert_strategy_no_relationships(self, db_session: AsyncSession):
-        """INSERT strategy adds instances; model with no rels skips reload (line 135)."""
-        registry = FixtureRegistry()
-
-        @registry.register()
-        def int_roles() -> list[IntRole]:
-            return [IntRole(name="insert_role")]
-
-        local_ns: dict = {}
-        register_fixtures(
-            registry,
-            local_ns,
-            session_fixture="db_session",
-            strategy=LoadStrategy.INSERT,
-        )
-        inner = local_ns["fixture_int_roles"].__wrapped__  # type: ignore[attr-defined]
-        result = await inner(db_session=db_session)
-        assert len(result) == 1
-        assert result[0].name == "insert_role"
-
-    @pytest.mark.anyio
-    async def test_skip_existing_inserts_new_record(self, db_session: AsyncSession):
-        """SKIP_EXISTING inserts when the record does not yet exist."""
-        registry = FixtureRegistry()
-        role_id = uuid.uuid4()
-
-        @registry.register()
-        def new_roles() -> list[Role]:
-            return [Role(id=role_id, name="skip_new")]
-
-        local_ns: dict = {}
-        register_fixtures(
-            registry,
-            local_ns,
-            session_fixture="db_session",
-            strategy=LoadStrategy.SKIP_EXISTING,
-        )
-        inner = local_ns["fixture_new_roles"].__wrapped__  # type: ignore[attr-defined]
-        result = await inner(db_session=db_session)
-        assert len(result) == 1
-        assert result[0].id == role_id
-
-    @pytest.mark.anyio
-    async def test_skip_existing_returns_existing_record(
-        self, db_session: AsyncSession
-    ):
-        """SKIP_EXISTING returns the existing DB record when PK already present."""
-        role_id = uuid.uuid4()
-        existing = Role(id=role_id, name="already_there")
-        db_session.add(existing)
-        await db_session.flush()
-
-        registry = FixtureRegistry()
-
-        @registry.register()
-        def dup_roles() -> list[Role]:
-            return [Role(id=role_id, name="should_not_overwrite")]
-
-        local_ns: dict = {}
-        register_fixtures(
-            registry,
-            local_ns,
-            session_fixture="db_session",
-            strategy=LoadStrategy.SKIP_EXISTING,
-        )
-        inner = local_ns["fixture_dup_roles"].__wrapped__  # type: ignore[attr-defined]
-        result = await inner(db_session=db_session)
-        assert len(result) == 1
-        assert result[0].name == "already_there"
-
-    @pytest.mark.anyio
-    async def test_skip_existing_null_pk_inserts(self, db_session: AsyncSession):
-        """SKIP_EXISTING with null PK (auto-increment) falls through to session.add()."""
-        registry = FixtureRegistry()
-
-        @registry.register()
-        def auto_roles() -> list[IntRole]:
-            return [IntRole(name="auto_int")]
-
-        local_ns: dict = {}
-        register_fixtures(
-            registry,
-            local_ns,
-            session_fixture="db_session",
-            strategy=LoadStrategy.SKIP_EXISTING,
-        )
-        inner = local_ns["fixture_auto_roles"].__wrapped__  # type: ignore[attr-defined]
-        result = await inner(db_session=db_session)
-        assert len(result) == 1
-        assert result[0].name == "auto_int"
-
-
-class TestReloadWithRelationshipsCompositePK:
-    """Integration test for _reload_with_relationships composite-PK fallback."""
-
-    @pytest.mark.anyio
-    async def test_composite_pk_fallback_loads_relationships(self):
-        """Models with composite PKs are reloaded per-instance via session.get()."""
-        async with create_db_session(DATABASE_URL, _LocalBase) as session:
-            group = _Group(id=uuid.uuid4(), name="g1")
-            session.add(group)
-            await session.flush()
-
-            item = _CompositeItem(group_id=group.id, item_code="A")
-            session.add(item)
-            await session.flush()
-
-            load_opts = _relationship_load_options(_CompositeItem)
-            assert load_opts  # _CompositeItem has 'group' relationship
-
-            reloaded = await _reload_with_relationships(session, [item], load_opts)
-            assert len(reloaded) == 1
-            reloaded_item = cast(_CompositeItem, reloaded[0])
-            assert reloaded_item.group is not None
-            assert reloaded_item.group.name == "g1"
@@ -1,678 +0,0 @@
-"""Tests for fastapi_toolsets.schemas module."""
-
-import pytest
-from pydantic import ValidationError
-
-from fastapi_toolsets.schemas import (
-    ApiError,
-    CursorPagination,
-    CursorPaginatedResponse,
-    ErrorResponse,
-    OffsetPagination,
-    OffsetPaginatedResponse,
-    PaginatedResponse,
-    PaginationType,
-    Response,
-    ResponseStatus,
-)
-
-
-class TestResponseStatus:
-    """Tests for ResponseStatus enum."""
-
-    def test_success_value(self):
-        """SUCCESS has correct value."""
-        assert ResponseStatus.SUCCESS.value == "SUCCESS"
-
-    def test_fail_value(self):
-        """FAIL has correct value."""
-        assert ResponseStatus.FAIL.value == "FAIL"
-
-    def test_is_string_enum(self):
-        """ResponseStatus is a string enum."""
-        assert isinstance(ResponseStatus.SUCCESS, str)
-
-
-class TestApiError:
-    """Tests for ApiError schema."""
-
-    def test_create_api_error(self):
-        """Create ApiError with all fields."""
-        error = ApiError(
-            code=404,
-            msg="Not Found",
-            desc="The resource was not found.",
-            err_code="RES-404",
-        )
-
-        assert error.code == 404
-        assert error.msg == "Not Found"
-        assert error.desc == "The resource was not found."
-        assert error.err_code == "RES-404"
-
-    def test_data_defaults_to_none(self):
-        """ApiError data field defaults to None."""
-        error = ApiError(
-            code=404,
-            msg="Not Found",
-            desc="The resource was not found.",
-            err_code="RES-404",
-        )
-        assert error.data is None
-
-    def test_create_with_data(self):
-        """ApiError can be created with a data payload."""
-        error = ApiError(
-            code=422,
-            msg="Validation Error",
-            desc="2 validation error(s) detected",
-            err_code="VAL-422",
-            data={
-                "errors": [{"field": "name", "message": "required", "type": "missing"}]
-            },
-        )
-        assert error.data == {
-            "errors": [{"field": "name", "message": "required", "type": "missing"}]
-        }
-
-    def test_requires_all_fields(self):
-        """ApiError requires all fields."""
-        with pytest.raises(ValidationError):
-            ApiError(code=404, msg="Not Found")  # type: ignore
-
-
-class TestResponse:
-    """Tests for Response schema."""
-
-    def test_create_with_data(self):
-        """Create Response with data."""
-        response = Response(data={"id": 1, "name": "test"})
-
-        assert response.data == {"id": 1, "name": "test"}
-        assert response.status == ResponseStatus.SUCCESS
-        assert response.message == "Success"
-        assert response.error_code is None
-
-    def test_create_with_custom_message(self):
-        """Create Response with custom message."""
-        response = Response(data="result", message="Operation completed")
-
-        assert response.message == "Operation completed"
-
-    def test_create_with_none_data(self):
-        """Create Response with None data."""
-        response = Response[dict](data=None)
-
-        assert response.data is None
-        assert response.status == ResponseStatus.SUCCESS
-
-    def test_generic_type_hint(self):
-        """Response supports generic type hints."""
-        response: Response[list[str]] = Response(data=["a", "b", "c"])
-
-        assert response.data == ["a", "b", "c"]
-
-    def test_serialization(self):
-        """Response serializes correctly."""
-        response = Response(data={"key": "value"}, message="Test")
-        data = response.model_dump()
-
-        assert data["status"] == "SUCCESS"
-        assert data["message"] == "Test"
-        assert data["data"] == {"key": "value"}
-        assert data["error_code"] is None
-
-
-class TestErrorResponse:
-    """Tests for ErrorResponse schema."""
-
-    def test_default_values(self):
-        """ErrorResponse has correct defaults."""
-        response = ErrorResponse()
-
-        assert response.status == ResponseStatus.FAIL
-        assert response.data is None
-
-    def test_with_description(self):
-        """ErrorResponse with description."""
-        response = ErrorResponse(
-            message="Bad Request",
-            description="The request was invalid.",
-            error_code="BAD-400",
-        )
-
-        assert response.message == "Bad Request"
-        assert response.description == "The request was invalid."
-        assert response.error_code == "BAD-400"
-
-    def test_serialization(self):
-        """ErrorResponse serializes correctly."""
-        response = ErrorResponse(
-            message="Error",
-            description="Details",
-            error_code="ERR-500",
-        )
-        data = response.model_dump()
-
-        assert data["status"] == "FAIL"
-        assert data["description"] == "Details"
-
-
-class TestOffsetPagination:
-    """Tests for OffsetPagination schema (canonical name for offset-based pagination)."""
-
-    def test_create_pagination(self):
-        """Create OffsetPagination with all fields."""
-        pagination = OffsetPagination(
-            total_count=100,
-            items_per_page=10,
-            page=1,
-            has_more=True,
-        )
-
-        assert pagination.total_count == 100
-        assert pagination.items_per_page == 10
-        assert pagination.page == 1
-        assert pagination.has_more is True
-
-    def test_last_page_has_more_false(self):
-        """Last page has has_more=False."""
-        pagination = OffsetPagination(
-            total_count=25,
-            items_per_page=10,
-            page=3,
-            has_more=False,
-        )
-
-        assert pagination.has_more is False
-
-    def test_serialization(self):
-        """OffsetPagination serializes correctly."""
-        pagination = OffsetPagination(
-            total_count=50,
-            items_per_page=20,
-            page=2,
-            has_more=True,
-        )
-        data = pagination.model_dump()
-
-        assert data["total_count"] == 50
-        assert data["items_per_page"] == 20
-        assert data["page"] == 2
-        assert data["has_more"] is True
-
-    def test_total_count_can_be_none(self):
-        """total_count accepts None (include_total=False mode)."""
-        pagination = OffsetPagination(
-            total_count=None,
-            items_per_page=20,
-            page=1,
-            has_more=True,
-        )
-        assert pagination.total_count is None
-
-    def test_serialization_with_none_total_count(self):
-        """OffsetPagination serializes total_count=None correctly."""
-        pagination = OffsetPagination(
-            total_count=None,
-            items_per_page=20,
-            page=1,
-            has_more=False,
-        )
-        data = pagination.model_dump()
-        assert data["total_count"] is None
-
-    def test_pages_computed(self):
-        """pages is ceil(total_count / items_per_page)."""
-        pagination = OffsetPagination(
-            total_count=42,
-            items_per_page=10,
-            page=1,
-            has_more=True,
-        )
-        assert pagination.pages == 5
-
-    def test_pages_exact_division(self):
-        """pages is exact when total_count is evenly divisible."""
-        pagination = OffsetPagination(
-            total_count=40,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        assert pagination.pages == 4
-
-    def test_pages_zero_total(self):
-        """pages is 0 when total_count is 0."""
-        pagination = OffsetPagination(
-            total_count=0,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        assert pagination.pages == 0
-
-    def test_pages_zero_items_per_page(self):
-        """pages is 0 when items_per_page is 0."""
-        pagination = OffsetPagination(
-            total_count=100,
-            items_per_page=0,
-            page=1,
-            has_more=False,
-        )
-        assert pagination.pages == 0
-
-    def test_pages_none_when_total_count_none(self):
-        """pages is None when total_count is None (include_total=False)."""
-        pagination = OffsetPagination(
-            total_count=None,
-            items_per_page=20,
-            page=1,
-            has_more=True,
-        )
-        assert pagination.pages is None
-
-    def test_pages_in_serialization(self):
-        """pages appears in model_dump output."""
-        pagination = OffsetPagination(
-            total_count=25,
-            items_per_page=10,
-            page=1,
-            has_more=True,
-        )
-        data = pagination.model_dump()
-        assert data["pages"] == 3
-
-
-class TestCursorPagination:
-    """Tests for CursorPagination schema."""
-
-    def test_create_with_next_cursor(self):
-        """CursorPagination with a next cursor indicates more pages."""
-        pagination = CursorPagination(
-            next_cursor="eyJ2YWx1ZSI6ICIxMjMifQ==",
-            items_per_page=20,
-            has_more=True,
-        )
-        assert pagination.next_cursor == "eyJ2YWx1ZSI6ICIxMjMifQ=="
-        assert pagination.prev_cursor is None
-        assert pagination.items_per_page == 20
-        assert pagination.has_more is True
-
-    def test_create_last_page(self):
-        """CursorPagination for the last page has next_cursor=None and has_more=False."""
-        pagination = CursorPagination(
-            next_cursor=None,
-            items_per_page=20,
-            has_more=False,
-        )
-        assert pagination.next_cursor is None
-        assert pagination.has_more is False
-
-    def test_prev_cursor_defaults_to_none(self):
-        """prev_cursor defaults to None."""
-        pagination = CursorPagination(
-            next_cursor=None, items_per_page=10, has_more=False
-        )
-        assert pagination.prev_cursor is None
-
-    def test_prev_cursor_can_be_set(self):
-        """prev_cursor can be explicitly set."""
-        pagination = CursorPagination(
-            next_cursor="next123",
-            prev_cursor="prev456",
-            items_per_page=10,
-            has_more=True,
-        )
-        assert pagination.prev_cursor == "prev456"
-
-    def test_serialization(self):
-        """CursorPagination serializes correctly."""
-        pagination = CursorPagination(
-            next_cursor="abc123",
-            prev_cursor="xyz789",
-            items_per_page=20,
-            has_more=True,
-        )
-        data = pagination.model_dump()
-        assert data["next_cursor"] == "abc123"
-        assert data["prev_cursor"] == "xyz789"
-        assert data["items_per_page"] == 20
-        assert data["has_more"] is True
-
-
-class TestPaginatedResponse:
-    """Tests for PaginatedResponse schema."""
-
-    def test_create_paginated_response(self):
-        """Create PaginatedResponse with data and pagination."""
-        pagination = OffsetPagination(
-            total_count=30,
-            items_per_page=10,
-            page=1,
-            has_more=True,
-        )
-        response = PaginatedResponse(
-            data=[{"id": 1}, {"id": 2}],
-            pagination=pagination,
-        )
-
-        assert isinstance(response.pagination, OffsetPagination)
-        assert len(response.data) == 2
-        assert response.pagination.total_count == 30
-        assert response.status == ResponseStatus.SUCCESS
-
-    def test_with_custom_message(self):
-        """PaginatedResponse with custom message."""
-        pagination = OffsetPagination(
-            total_count=5,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        response = PaginatedResponse(
-            data=[1, 2, 3, 4, 5],
-            pagination=pagination,
-            message="Found 5 items",
-        )
-
-        assert response.message == "Found 5 items"
-
-    def test_empty_data(self):
-        """PaginatedResponse with empty data."""
-        pagination = OffsetPagination(
-            total_count=0,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        response = PaginatedResponse(
-            data=[],
-            pagination=pagination,
-        )
-
-        assert isinstance(response.pagination, OffsetPagination)
-        assert response.data == []
-        assert response.pagination.total_count == 0
-
-    def test_class_getitem_with_concrete_type_returns_discriminated_union(self):
-        """PaginatedResponse[T] with a concrete type returns a discriminated Annotated union."""
-        import typing
-
-        alias = PaginatedResponse[dict]
-        args = typing.get_args(alias)
-        # args[0] is the Union, args[1] is the FieldInfo discriminator
-        union_args = typing.get_args(args[0])
-        assert CursorPaginatedResponse[dict] in union_args
-        assert OffsetPaginatedResponse[dict] in union_args
-
-    def test_class_getitem_is_cached(self):
-        """Repeated subscripting with the same type returns the identical cached object."""
-        assert PaginatedResponse[dict] is PaginatedResponse[dict]
-
-    def test_class_getitem_with_typevar_returns_generic(self):
-        """PaginatedResponse[TypeVar] falls through to Pydantic generic parametrisation."""
-        from typing import TypeVar
-
-        T = TypeVar("T")
-        alias = PaginatedResponse[T]
-        # Should be a generic alias, not an Annotated union
-        assert not hasattr(alias, "__metadata__")
-
-    def test_generic_type_hint(self):
-        """PaginatedResponse supports generic type hints."""
-        pagination = OffsetPagination(
-            total_count=1,
-            items_per_page=10,
-            page=1,
-            has_more=False,
-        )
-        response: PaginatedResponse[dict] = PaginatedResponse(
-            data=[{"id": 1, "name": "test"}],
-            pagination=pagination,
-        )
-
-        assert response.data[0]["id"] == 1
-
-    def test_serialization(self):
-        """PaginatedResponse serializes correctly."""
-        pagination = OffsetPagination(
-            total_count=100,
-            items_per_page=10,
-            page=5,
-            has_more=True,
-        )
-        response = PaginatedResponse(
-            data=["item1", "item2"],
-            pagination=pagination,
-            message="Page 5",
-        )
-        data = response.model_dump()
-
-        assert data["status"] == "SUCCESS"
-        assert data["message"] == "Page 5"
-        assert data["data"] == ["item1", "item2"]
-        assert data["pagination"]["page"] == 5
-
-    def test_pagination_field_accepts_offset_pagination(self):
-        """PaginatedResponse.pagination accepts OffsetPagination."""
-        response = PaginatedResponse(
-            data=[1, 2],
-            pagination=OffsetPagination(
-                total_count=2, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert isinstance(response.pagination, OffsetPagination)
-
-    def test_pagination_field_accepts_cursor_pagination(self):
-        """PaginatedResponse.pagination accepts CursorPagination."""
-        response = PaginatedResponse(
-            data=[1, 2],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert isinstance(response.pagination, CursorPagination)
-
-
-class TestPaginationType:
-    """Tests for PaginationType enum."""
-
-    def test_offset_value(self):
-        """OFFSET has string value 'offset'."""
-        assert PaginationType.OFFSET == "offset"
-        assert PaginationType.OFFSET.value == "offset"
-
-    def test_cursor_value(self):
-        """CURSOR has string value 'cursor'."""
-        assert PaginationType.CURSOR == "cursor"
-        assert PaginationType.CURSOR.value == "cursor"
-
-    def test_is_string_enum(self):
-        """PaginationType is a string enum."""
-        assert isinstance(PaginationType.OFFSET, str)
-        assert isinstance(PaginationType.CURSOR, str)
-
-    def test_members(self):
-        """PaginationType has exactly two members."""
-        assert set(PaginationType) == {PaginationType.OFFSET, PaginationType.CURSOR}
-
-
-class TestOffsetPaginatedResponse:
-    """Tests for OffsetPaginatedResponse schema."""
-
-    def test_pagination_type_is_offset(self):
-        """pagination_type is always PaginationType.OFFSET."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert response.pagination_type is PaginationType.OFFSET
-
-    def test_pagination_type_serializes_to_string(self):
-        """pagination_type serializes to 'offset' in JSON mode."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert response.model_dump(mode="json")["pagination_type"] == "offset"
-
-    def test_pagination_field_is_typed(self):
-        """pagination field is OffsetPagination, not the union."""
-        response = OffsetPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=OffsetPagination(
-                total_count=10, items_per_page=5, page=2, has_more=True
-            ),
-        )
-        assert isinstance(response.pagination, OffsetPagination)
-        assert response.pagination.total_count == 10
-        assert response.pagination.page == 2
-
-    def test_is_subclass_of_paginated_response(self):
-        """OffsetPaginatedResponse IS a PaginatedResponse."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert isinstance(response, PaginatedResponse)
-
-    def test_pagination_type_default_cannot_be_overridden_to_cursor(self):
-        """pagination_type rejects values other than OFFSET."""
-        with pytest.raises(ValidationError):
-            OffsetPaginatedResponse(
-                data=[],
-                pagination=OffsetPagination(
-                    total_count=0, items_per_page=10, page=1, has_more=False
-                ),
-                pagination_type=PaginationType.CURSOR,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
-            )
-
-    def test_filter_attributes_defaults_to_none(self):
-        """filter_attributes defaults to None."""
-        response = OffsetPaginatedResponse(
-            data=[],
-            pagination=OffsetPagination(
-                total_count=0, items_per_page=10, page=1, has_more=False
-            ),
-        )
-        assert response.filter_attributes is None
-
-    def test_full_serialization(self):
-        """Full JSON serialization includes all expected fields."""
-        response = OffsetPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=OffsetPagination(
-                total_count=1, items_per_page=10, page=1, has_more=False
-            ),
-            filter_attributes={"status": ["active"]},
-        )
-        data = response.model_dump(mode="json")
-
-        assert data["pagination_type"] == "offset"
-        assert data["status"] == "SUCCESS"
-        assert data["data"] == [{"id": 1}]
-        assert data["pagination"]["total_count"] == 1
-        assert data["filter_attributes"] == {"status": ["active"]}
-
-
-class TestCursorPaginatedResponse:
-    """Tests for CursorPaginatedResponse schema."""
-
-    def test_pagination_type_is_cursor(self):
-        """pagination_type is always PaginationType.CURSOR."""
-        response = CursorPaginatedResponse(
-            data=[],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert response.pagination_type is PaginationType.CURSOR
-
-    def test_pagination_type_serializes_to_string(self):
-        """pagination_type serializes to 'cursor' in JSON mode."""
-        response = CursorPaginatedResponse(
-            data=[],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert response.model_dump(mode="json")["pagination_type"] == "cursor"
-
-    def test_pagination_field_is_typed(self):
-        """pagination field is CursorPagination, not the union."""
-        response = CursorPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=CursorPagination(
-                next_cursor="abc123",
-                prev_cursor=None,
-                items_per_page=20,
-                has_more=True,
-            ),
-        )
-        assert isinstance(response.pagination, CursorPagination)
-        assert response.pagination.next_cursor == "abc123"
-        assert response.pagination.has_more is True
-
-    def test_is_subclass_of_paginated_response(self):
-        """CursorPaginatedResponse IS a PaginatedResponse."""
-        response = CursorPaginatedResponse(
-            data=[],
-            pagination=CursorPagination(
-                next_cursor=None, items_per_page=10, has_more=False
-            ),
-        )
-        assert isinstance(response, PaginatedResponse)
-
-    def test_pagination_type_default_cannot_be_overridden_to_offset(self):
-        """pagination_type rejects values other than CURSOR."""
-        with pytest.raises(ValidationError):
-            CursorPaginatedResponse(
-                data=[],
-                pagination=CursorPagination(
-                    next_cursor=None, items_per_page=10, has_more=False
-                ),
-                pagination_type=PaginationType.OFFSET,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
-            )
-
-    def test_full_serialization(self):
-        """Full JSON serialization includes all expected fields."""
-        response = CursorPaginatedResponse(
-            data=[{"id": 1}],
-            pagination=CursorPagination(
-                next_cursor="tok_next",
-                prev_cursor="tok_prev",
-                items_per_page=10,
-                has_more=True,
-            ),
-        )
-        data = response.model_dump(mode="json")
-
-        assert data["pagination_type"] == "cursor"
-        assert data["status"] == "SUCCESS"
-        assert data["pagination"]["next_cursor"] == "tok_next"
-        assert data["pagination"]["prev_cursor"] == "tok_prev"
-
-
-class TestFromAttributes:
-    """Tests for from_attributes config (ORM mode)."""
-
-    def test_response_from_orm_object(self):
-        """Response can accept ORM-like objects."""
-
-        class FakeOrmObject:
-            def __init__(self):
-                self.id = 1
-                self.name = "test"
-
-        obj = FakeOrmObject()
-        response = Response(data=obj)
-
-        assert response.data.id == 1  # type: ignore
-        assert response.data.name == "test"  # type: ignore
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
github-actions[bot]	eca29a5bdb	Deployed `88ecfa8` to v5.1 with Zensical 0.0.51 and mike 2.2.0+zensical-0.1.0	2026-07-28 12:24:25 +00:00
github-actions[bot]	c6d31cdac9	Deployed `c15aee2` to v5.0 with Zensical 0.0.50 and mike 2.2.0+zensical-0.1.0	2026-07-11 13:17:37 +00:00
github-actions[bot]	c9285b0fb8	Deployed `06d49d5` to v5.0 with Zensical 0.0.43 and mike 2.2.0+zensical-0.1.0	2026-07-04 09:08:25 +00:00
github-actions[bot]	8c60711c56	Deployed `025f190` to v5.0 with Zensical 0.0.43 and mike 2.2.0+zensical-0.1.0	2026-06-25 19:18:13 +00:00
github-actions[bot]	ad920321e8	Removed v4.0 with mike 2.2.0+zensical-0.1.0	2026-06-25 19:18:10 +00:00
github-actions[bot]	95c5fb7828	Deployed `2641881` to v4.1 with Zensical 0.0.43 and mike 2.2.0+zensical-0.1.0	2026-06-09 16:51:07 +00:00
github-actions[bot]	e449df76c2	Deployed `43445e9` to v4.1 with Zensical 0.0.43 and mike 2.2.0+zensical-0.1.0	2026-06-08 16:44:06 +00:00
github-actions[bot]	0c48b83fdd	Deployed `b0c35bf` to v4.1 with Zensical 0.0.43 and mike 2.2.0+zensical-0.1.0	2026-06-03 20:06:25 +00:00
github-actions[bot]	9a13ebdd22	Deployed `f80dae2` to v4.1 with Zensical 0.0.41 and mike 2.2.0+zensical-0.1.0	2026-05-21 16:33:08 +00:00
github-actions[bot]	1042121c1b	Deployed `189e9e1` to v4.0 with Zensical 0.0.40 and mike 2.2.0+zensical-0.1.0	2026-05-08 11:18:22 +00:00
github-actions[bot]	c541fb4f85	Removed v3.0 with mike 2.2.0+zensical-0.1.0	2026-05-08 11:18:19 +00:00
github-actions[bot]	84602c0fcf	Deployed `2115036` to v3.1 with Zensical 0.0.33 and mike 2.2.0+zensical-0.1.0	2026-04-16 19:40:33 +00:00
github-actions[bot]	8f42f8da40	Deployed `94e7d79` to v3.1 with Zensical 0.0.32 and mike 2.2.0+zensical-0.1.0	2026-04-12 16:54:43 +00:00
github-actions[bot]	b8da326810	Deployed `6b127d9` to v3.0 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-04 23:15:54 +00:00
d3vyce	07289c015a	Deployed `9b74f16` to v2.4 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-03 04:53:26 -05:00
d3vyce	c09eb4a4ac	Deployed `9b74f16` to v1.3 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-03 04:53:16 -05:00
d3vyce	01ca5496e0	Removed v2.4 with mike 2.2.0+zensical-0.1.0	2026-04-03 04:53:00 -05:00
d3vyce	c59a43dea6	Removed v1.3 with mike 2.2.0+zensical-0.1.0	2026-04-03 04:52:59 -05:00
d3vyce	012d89dc09	Deployed `a647da4` to v3.0 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-03 04:37:39 -05:00
d3vyce	fc9a1279ac	Deployed `a647da4` to v2.4 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-03 04:37:32 -05:00
d3vyce	e4edd7c612	Deployed `a647da4` to v1.3 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-03 04:37:25 -05:00
d3vyce	3b783e55bb	Removed v3.0 with mike 2.2.0+zensical-0.1.0	2026-04-03 04:37:16 -05:00
d3vyce	62f7d5fd39	Removed v2 with mike 2.2.0+zensical-0.1.0	2026-04-03 04:37:16 -05:00
d3vyce	5837eecb8e	Removed v1 with mike 2.2.0+zensical-0.1.0	2026-04-03 04:37:15 -05:00
github-actions[bot]	5f52925eaf	Deployed `bbe63ed` to v3.0 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-02 09:39:23 +00:00
github-actions[bot]	ec2593d738	Removed v2.1 with mike 2.2.0+zensical-0.1.0	2026-04-02 09:39:20 +00:00
github-actions[bot]	9466862ea3	Removed v2.2 with mike 2.2.0+zensical-0.1.0	2026-04-02 09:39:19 +00:00
github-actions[bot]	f1ac88e21f	Removed v2.3 with mike 2.2.0+zensical-0.1.0	2026-04-02 09:39:19 +00:00
github-actions[bot]	41a3b63554	Removed v2.4 with mike 2.2.0+zensical-0.1.0	2026-04-02 09:39:18 +00:00
github-actions[bot]	91659b8237	Deployed `bbe63ed` to v2 with Zensical 0.0.31 and mike 2.2.0+zensical-0.1.0	2026-04-02 09:39:18 +00:00
d3vyceandGitHub	1d8415de08	Create CNAME	2026-03-29 13:59:20 +02:00
github-actions[bot]	de46f8bd2d	Removed 2.2 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:17 -05:00
github-actions[bot]	23109102ca	Removed 2.1 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:16 -05:00
github-actions[bot]	b9b7c0d5cc	Removed 2.0 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:13 -05:00
github-actions[bot]	beb35d4d3c	Removed 1.3 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:10 -05:00
github-actions[bot]	99c132508d	Removed 1.2 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:07 -05:00
github-actions[bot]	b1056369b1	Removed 1.1 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:06 -05:00
github-actions[bot]	9051aade4b	Removed 1.0 with mike 2.2.0+zensical-0.1.0	2026-03-29 06:48:03 -05:00
github-actions[bot]	659918bf5e	Set default version to stable with mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:34 -05:00
github-actions[bot]	1d22c64697	Deployed `f5afbbe` to v2.4 with Zensical 0.0.30 and mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:33 -05:00
github-actions[bot]	793ba6f45f	Deployed `f5afbbe` to v2.3 with Zensical 0.0.30 and mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:31 -05:00
github-actions[bot]	f61659e39b	Deployed `f5afbbe` to v2.2 with Zensical 0.0.30 and mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:28 -05:00
github-actions[bot]	a1043448ed	Deployed `f5afbbe` to v2.1 with Zensical 0.0.30 and mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:25 -05:00
github-actions[bot]	57ccbe6523	Deployed `f5afbbe` to v2 with Zensical 0.0.30 and mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:23 -05:00
github-actions[bot]	baf58c6b3a	Deployed `f5afbbe` to v1 with Zensical 0.0.30 and mike 2.2.0+zensical-0.1.0	2026-03-29 06:47:20 -05:00
d3vyce	9462d4406e	Set default version to latest with mike 2.1.4	2026-03-11 13:58:30 -05:00
d3vyce	aa1734e054	Deployed `0cc21d2` to 2.2 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:58:28 -05:00
d3vyce	e386f5d0c9	Deployed `0cc21d2` to 2.1 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:58:24 -05:00
d3vyce	2223d42d15	Deployed `dde5183` to 2.2 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:56:55 -05:00
d3vyce	9279947778	Deployed `c4c7604` to 2.0 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:56:50 -05:00
d3vyce	d863ddbbe2	Deployed `56d365d` to 1.3 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:56:46 -05:00
d3vyce	e473812460	Deployed `117675d` to 1.2 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:56:41 -05:00
d3vyce	b87be8aeea	Deployed `7ec4078` to 1.1 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:56:37 -05:00
d3vyce	d4e83fdc79	Deployed `3167893` to 1.0 with MkDocs 1.0.0 and mike 2.1.4	2026-03-11 13:56:32 -05:00