simple-module-db 0.0.1__tar.gz

simple_module_db-0.0.1/.gitignore

@@ -0,0 +1,59 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+*.egg
+
+# UV
+uv.lock
+
+# Node
+node_modules/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+.env
+
+# Database
+*.db
+*.sqlite3
+
+# Module-managed runtime state (e.g. uploaded dataset files,
+# default storage_dir for SM_DATASETS_STORAGE_DIR).
+var/
+
+# file_storage filesystem backend default root (override via SM_FILE_STORAGE_FS_ROOT_PATH).
+uploads/
+
+# Vite
+host/static/dist/
+
+# Auto-generated frontend module manifest (regenerated by the host at boot
+# or via `make gen-pages`).
+host/client_app/modules.manifest.json
+host/client_app/modules.generated.ts
+host/client_app/modules.generated.css
+
+# Worktrees
+.worktrees/
+
+# Performance profiles
+.memray/
+.benchmarks/
+
+# OS
+.DS_Store
+Thumbs.db
+
+.playwright-cli/*
+.playwright-mcp/*
+host/client_app/.playwright-cli/*
+.superpowers/

simple_module_db-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anto Subash
+
+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.

simple_module_db-0.0.1/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: simple_module_db
+Version: 0.0.1
+Summary: Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module
+Project-URL: Homepage, https://github.com/antosubash/simple_module_python
+Project-URL: Repository, https://github.com/antosubash/simple_module_python
+Project-URL: Issues, https://github.com/antosubash/simple_module_python/issues
+Project-URL: Changelog, https://github.com/antosubash/simple_module_python/blob/main/CHANGELOG.md
+Author-email: Anto Subash <antosubash@live.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: alembic,async,multi-tenant,simple-module,sqlalchemy,sqlmodel
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: alembic>=1.14
+Requires-Dist: asyncpg>=0.30
+Requires-Dist: simple-module-core==0.0.1
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: sqlmodel>=0.0.22
+Description-Content-Type: text/markdown
+
+# simple_module_db
+
+Database layer for the [simple_module](https://github.com/antosubash/simple_module_python) framework. Provides a per-module `Base`, an async SQLAlchemy/SQLModel session, standard mixins, and an auto-commit-on-flush listener that removes manual `session.commit()` calls from service code.
+
+## Install
+
+```bash
+pip install simple_module_db
+```
+
+## What it provides
+
+- `create_module_base("<module_name>")` — a module-scoped declarative `Base`. PostgreSQL maps it to its own schema; SQLite namespaces via table-name prefix.
+- Per-request async session (`get_db`) with an auto-commit-on-flush hook — `after_flush` commits if there are pending writes, rolls back otherwise.
+- Mixins in `simple_module_db.mixins`: `AuditMixin` (created_at/updated_at), `SoftDeleteMixin` (auto-filtered unless `stmt.execution_options(include_deleted=True)`), `MultiTenantMixin`, `VersionedMixin`.
+- `DatabaseState` container used by the framework to avoid global mutable state.
+
+## Usage
+
+```python
+# modules/orders/orders/models.py
+from simple_module_db import AuditMixin, SoftDeleteMixin, create_module_base
+from sqlmodel import Field
+
+Base = create_module_base("orders")
+
+
+class Order(Base, AuditMixin, SoftDeleteMixin, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    customer_id: int = Field(index=True, foreign_key="users_user.id")
+    total_cents: int
+```
+
+In a service:
+
+```python
+from simple_module_db import get_db
+
+async def create_order(session = Depends(get_db), ...):
+    order = Order(customer_id=..., total_cents=...)
+    session.add(order)
+    await session.flush()   # assigns order.id; auto-commit happens after the request
+    return order
+```
+
+Never call `session.commit()` — the framework handles it.
+
+## Depends on
+
+- `simple_module_core`, `sqlalchemy[asyncio]`, `sqlmodel`, `alembic`, `asyncpg`, `aiosqlite`
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_db-0.0.1/README.md

@@ -0,0 +1,54 @@
+# simple_module_db
+
+Database layer for the [simple_module](https://github.com/antosubash/simple_module_python) framework. Provides a per-module `Base`, an async SQLAlchemy/SQLModel session, standard mixins, and an auto-commit-on-flush listener that removes manual `session.commit()` calls from service code.
+
+## Install
+
+```bash
+pip install simple_module_db
+```
+
+## What it provides
+
+- `create_module_base("<module_name>")` — a module-scoped declarative `Base`. PostgreSQL maps it to its own schema; SQLite namespaces via table-name prefix.
+- Per-request async session (`get_db`) with an auto-commit-on-flush hook — `after_flush` commits if there are pending writes, rolls back otherwise.
+- Mixins in `simple_module_db.mixins`: `AuditMixin` (created_at/updated_at), `SoftDeleteMixin` (auto-filtered unless `stmt.execution_options(include_deleted=True)`), `MultiTenantMixin`, `VersionedMixin`.
+- `DatabaseState` container used by the framework to avoid global mutable state.
+
+## Usage
+
+```python
+# modules/orders/orders/models.py
+from simple_module_db import AuditMixin, SoftDeleteMixin, create_module_base
+from sqlmodel import Field
+
+Base = create_module_base("orders")
+
+
+class Order(Base, AuditMixin, SoftDeleteMixin, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    customer_id: int = Field(index=True, foreign_key="users_user.id")
+    total_cents: int
+```
+
+In a service:
+
+```python
+from simple_module_db import get_db
+
+async def create_order(session = Depends(get_db), ...):
+    order = Order(customer_id=..., total_cents=...)
+    session.add(order)
+    await session.flush()   # assigns order.id; auto-commit happens after the request
+    return order
+```
+
+Never call `session.commit()` — the framework handles it.
+
+## Depends on
+
+- `simple_module_core`, `sqlalchemy[asyncio]`, `sqlmodel`, `alembic`, `asyncpg`, `aiosqlite`
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_db-0.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "simple_module_db"
+version = "0.0.1"
+description = "Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "Anto Subash", email = "antosubash@live.com" }]
+keywords = ["simple-module", "sqlmodel", "sqlalchemy", "async", "alembic", "multi-tenant"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiosqlite>=0.20",
+    "alembic>=1.14",
+    "asyncpg>=0.30",
+    "simple_module_core==0.0.1",
+    "sqlalchemy[asyncio]>=2.0",
+    "sqlmodel>=0.0.22",
+]
+
+[project.urls]
+Homepage = "https://github.com/antosubash/simple_module_python"
+Repository = "https://github.com/antosubash/simple_module_python"
+Issues = "https://github.com/antosubash/simple_module_python/issues"
+Changelog = "https://github.com/antosubash/simple_module_python/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv.sources]
+simple_module_core = { workspace = true }

simple_module_db-0.0.1/simple_module_db/__init__.py

@@ -0,0 +1,27 @@
+"""SimpleModule DB - SQLAlchemy async support with per-module schema isolation."""
+
+from simple_module_db.base import create_module_base
+from simple_module_db.deps import get_db
+from simple_module_db.listeners import TenantIsolationError, current_tenant_id
+from simple_module_db.migrations import build_module_metadata, make_include_object, render_item
+from simple_module_db.mixins import AuditMixin, MultiTenantMixin, SoftDeleteMixin, VersionedMixin
+from simple_module_db.provider import DatabaseProvider, detect_provider
+from simple_module_db.session import DatabaseState, init_db
+
+__all__ = [
+    "AuditMixin",
+    "DatabaseProvider",
+    "DatabaseState",
+    "MultiTenantMixin",
+    "SoftDeleteMixin",
+    "TenantIsolationError",
+    "VersionedMixin",
+    "build_module_metadata",
+    "create_module_base",
+    "current_tenant_id",
+    "detect_provider",
+    "get_db",
+    "init_db",
+    "make_include_object",
+    "render_item",
+]

simple_module_db-0.0.1/simple_module_db/base.py

@@ -0,0 +1,98 @@
+"""Per-module SQLModel base with schema isolation."""
+
+from __future__ import annotations
+
+import os
+
+from sqlalchemy import MetaData
+from sqlmodel import SQLModel
+
+from simple_module_db.provider import DatabaseProvider, detect_provider
+
+# Convention-based naming for constraints (helps Alembic)
+_naming_convention = {
+    "ix": "ix_%(column_0_label)s",
+    "uq": "uq_%(table_name)s_%(column_0_name)s",
+    "ck": "ck_%(table_name)s_%(constraint_name)s",
+    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+    "pk": "pk_%(table_name)s",
+}
+
+# Cache created bases to avoid recreating for the same module
+_base_cache: dict[str, type[SQLModel]] = {}
+
+# Track all module bases for Alembic discovery. Module-level *mutable* list
+# so callers that imported it before every module registered (e.g. conftest,
+# migrations/env.py) still observe new entries. Deduped at append time —
+# see ``_register_base`` below.
+all_module_bases: list[type[SQLModel]] = []
+
+
+def _register_base(base: type[SQLModel]) -> None:
+    """Append ``base`` to ``all_module_bases`` iff not already present.
+
+    Guards against the list growing under repeated imports (test suites,
+    reloaders, plugin discovery) without changing the public type.
+    """
+    if base not in all_module_bases:
+        all_module_bases.append(base)
+
+
+def _default_provider() -> DatabaseProvider:
+    """Resolve the active provider from ``SM_DATABASE_URL`` at import time.
+
+    Falls back to SQLite when the variable is unset, keeping the common
+    dev-loop happy without requiring callers to plumb the provider through.
+    """
+    url = os.environ.get("SM_DATABASE_URL", "")
+    return detect_provider(url) if url else DatabaseProvider.SQLITE
+
+
+def create_module_base(
+    module_name: str,
+    provider: DatabaseProvider | None = None,
+) -> type[SQLModel]:
+    """Create a SQLModel abstract base with schema isolation for a module.
+
+    - PostgreSQL: uses a dedicated schema (e.g., ``products``)
+    - SQLite: single schema; modules are expected to prefix ``__tablename__``
+      with the module name to avoid collisions (e.g., ``products_product``)
+
+    The provider defaults to whatever ``SM_DATABASE_URL`` indicates, so
+    module models work in both dev (SQLite) and prod (PostgreSQL) without
+    code changes. Pass ``provider=`` explicitly in tests that need to pin it.
+
+    Returns a cached base if already created for this module+provider. The
+    returned class is a ``SQLModel`` subclass with a per-module ``MetaData``;
+    concrete table classes declare ``table=True`` and inherit from it.
+    """
+    if provider is None:
+        provider = _default_provider()
+
+    cache_key = f"{module_name}:{provider}"
+    if cache_key in _base_cache:
+        return _base_cache[cache_key]
+
+    schema_name = module_name.lower()
+
+    if provider == DatabaseProvider.POSTGRESQL:
+        mod_metadata = MetaData(schema=schema_name, naming_convention=_naming_convention)
+    else:
+        mod_metadata = MetaData(naming_convention=_naming_convention)
+
+    # Use type() to create the class, avoiding class body scoping issues
+    ModuleBase = type(  # noqa: N806
+        f"{module_name.title()}Base",
+        (SQLModel,),
+        {
+            "__abstract__": True,
+            "metadata": mod_metadata,
+        },
+    )
+
+    # Store module name for reference
+    ModuleBase.__module_name__ = schema_name  # type: ignore[attr-defined]
+
+    _base_cache[cache_key] = ModuleBase
+    _register_base(ModuleBase)
+    return ModuleBase

simple_module_db-0.0.1/simple_module_db/deps.py

@@ -0,0 +1,62 @@
+"""FastAPI dependencies for database access."""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import AsyncGenerator
+
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from simple_module_db.listeners import SESSION_HAS_WRITES_KEY
+
+_db_logger = logging.getLogger("simple_module.db")
+
+
+async def get_db(request: Request) -> AsyncGenerator[AsyncSession, None]:
+    """Yield an async database session, auto-closing on exit.
+
+    Commits only when the session has pending writes (``new``, ``dirty``,
+    or ``deleted`` objects). Read-only handlers still open an implicit
+    transaction but exit via ``rollback`` — that's one round-trip
+    cheaper than ``commit`` and keeps read-only queries from showing up
+    as writes in query logs / ``pg_stat_statements``.
+
+    Usage in FastAPI endpoints::
+
+        @router.get("/items")
+        async def list_items(db: AsyncSession = Depends(get_db)):
+            ...
+    """
+    factory = request.app.state.sm.db.session_factory
+    start = time.perf_counter()
+    async with factory() as session:
+        try:
+            yield session
+            # ``has_writes`` is set by the after_flush listener and
+            # survives the flush emptying session.new/.dirty/.deleted.
+            has_pending = bool(
+                session.info.get(SESSION_HAS_WRITES_KEY)
+                or session.new
+                or session.dirty
+                or session.deleted
+            )
+            if has_pending:
+                await session.commit()
+                op, log_message = "commit", "db.session.commit"
+                log = _db_logger.info
+            else:
+                await session.rollback()
+                op, log_message = "read_only_rollback", "db.session.read_only"
+                log = _db_logger.debug
+            duration_ms = round((time.perf_counter() - start) * 1000, 2)
+            log(log_message, extra={"operation": op, "db_duration_ms": duration_ms})
+        except Exception:
+            await session.rollback()
+            duration_ms = round((time.perf_counter() - start) * 1000, 2)
+            _db_logger.warning(
+                "db.session.rollback",
+                extra={"operation": "rollback", "db_duration_ms": duration_ms},
+            )
+            raise

simple_module_db-0.0.1/simple_module_db/listeners.py

@@ -0,0 +1,230 @@
+"""SQLAlchemy event listeners for auto-populating entity fields."""
+
+from __future__ import annotations
+
+import logging
+from contextvars import ContextVar
+from datetime import UTC, datetime
+
+from sqlalchemy import event
+from sqlalchemy import inspect as sa_inspect
+from sqlalchemy.orm import ORMExecuteState, Session, with_loader_criteria
+
+from simple_module_db.mixins import AuditMixin, MultiTenantMixin, SoftDeleteMixin, VersionedMixin
+from simple_module_db.session import DatabaseState
+
+logger = logging.getLogger(__name__)
+_db_logger = logging.getLogger("simple_module.db")
+
+# Set by auth middleware on each request
+current_user_id: ContextVar[str | None] = ContextVar("current_user_id", default=None)
+
+# Set by tenant middleware on each request
+current_tenant_id: ContextVar[str | None] = ContextVar("current_tenant_id", default=None)
+
+
+class TenantIsolationError(Exception):
+    """Raised when a multi-tenancy isolation constraint is violated."""
+
+
+# Key on ``Session.info`` stamped by the after_flush listener so
+# ``get_db`` can distinguish read-only requests from write requests after
+# flush has cleared ``session.new/.dirty/.deleted``.
+SESSION_HAS_WRITES_KEY = "has_writes"
+
+# DB audit event names
+_EVENT_ENTITY_CREATED = "db.entity.created"
+_EVENT_ENTITY_UPDATED = "db.entity.updated"
+_EVENT_ENTITY_SOFT_DELETED = "db.entity.soft_deleted"
+_EVENT_ENTITY_DELETED = "db.entity.deleted"
+
+# DB operation strings used in log extra dicts
+_OP_CREATE = "create"
+_OP_UPDATE = "update"
+_OP_SOFT_DELETE = "soft_delete"
+_OP_DELETE = "delete"
+
+
+def _entity_label(obj: object) -> str:
+    """Return 'ClassName' for a mapped entity instance."""
+    return type(obj).__name__
+
+
+def _entity_pk(obj: object) -> object:
+    """Return the primary key value(s) if available, else None."""
+    try:
+        inspector = sa_inspect(obj)
+        if inspector is None:
+            return None
+        identity = inspector.identity
+        if identity and len(identity) == 1:
+            return identity[0]
+        return identity
+    except Exception:
+        return None
+
+
+def _mark_session_written(session: Session, flush_context: object) -> None:
+    """Flag the session as having performed write work.
+
+    ``get_db`` reads this flag to decide between commit and rollback at
+    request end. Checking ``session.new/.dirty/.deleted`` directly after
+    a flush is useless — flush empties those sets — so we stash a tag on
+    ``session.info`` that survives the rest of the request.
+    """
+    session.info[SESSION_HAS_WRITES_KEY] = True
+
+
+def register_listeners(db_state: DatabaseState) -> None:
+    """Register SQLAlchemy event listeners for audit, soft delete, versioning, and tenancy.
+
+    Registers on the engine-scoped session events. Safe to call multiple times
+    — subsequent calls are no-ops.
+    """
+    if db_state._listeners_registered:
+        logger.debug("Listeners already registered, skipping")
+        return
+
+    event.listen(db_state.sync_session_class, "before_flush", _before_flush_listener)
+    event.listen(db_state.sync_session_class, "after_flush", _mark_session_written)
+    event.listen(db_state.sync_session_class, "do_orm_execute", _filter_select_statements)
+    db_state._listeners_registered = True
+    logger.info("Registered SQLAlchemy entity listeners")
+
+
+def _before_flush_listener(
+    session: Session,
+    flush_context: object,
+    instances: object,
+) -> None:
+    user_id = current_user_id.get()
+    tenant_id = current_tenant_id.get()
+    now = datetime.now(UTC)
+
+    for obj in session.new:
+        if isinstance(obj, AuditMixin):
+            if obj.created_by is None:
+                obj.created_by = user_id
+            if obj.updated_by is None:
+                obj.updated_by = user_id
+
+        # Auto-populate tenant_id; reject cross-tenant creation
+        if isinstance(obj, MultiTenantMixin):
+            if obj.tenant_id is None and tenant_id is not None:
+                obj.tenant_id = tenant_id
+            elif tenant_id is not None and obj.tenant_id != tenant_id:
+                raise TenantIsolationError(
+                    f"Cannot create object for tenant '{obj.tenant_id}' "
+                    f"in context of tenant '{tenant_id}'"
+                )
+
+        _db_logger.info(
+            _EVENT_ENTITY_CREATED,
+            extra={
+                "operation": _OP_CREATE,
+                "entity": _entity_label(obj),
+                "user_id": user_id,
+            },
+        )
+
+    for obj in session.dirty:
+        if not session.is_modified(obj):
+            continue
+
+        if isinstance(obj, AuditMixin):
+            obj.updated_at = now
+            obj.updated_by = user_id
+
+        if isinstance(obj, VersionedMixin):
+            obj.version += 1
+
+        # Prevent tenant_id from being changed on existing objects
+        if isinstance(obj, MultiTenantMixin) and tenant_id is not None:
+            hist = sa_inspect(obj).attrs.tenant_id.history
+            if hist.has_changes():
+                raise TenantIsolationError("Cannot change tenant_id of an existing object")
+
+        _db_logger.info(
+            _EVENT_ENTITY_UPDATED,
+            extra={
+                "operation": _OP_UPDATE,
+                "entity": _entity_label(obj),
+                "entity_id": _entity_pk(obj),
+                "user_id": user_id,
+            },
+        )
+
+    # Deleted objects — convert to soft delete if applicable
+    for obj in list(session.deleted):
+        if isinstance(obj, SoftDeleteMixin):
+            # Cancel the hard delete
+            session.expunge(obj)
+            # Merge back as modified with soft-delete fields set
+            obj.is_deleted = True
+            obj.deleted_at = now
+            obj.deleted_by = user_id
+            session.add(obj)
+
+            _db_logger.info(
+                _EVENT_ENTITY_SOFT_DELETED,
+                extra={
+                    "operation": _OP_SOFT_DELETE,
+                    "entity": _entity_label(obj),
+                    "entity_id": _entity_pk(obj),
+                    "user_id": user_id,
+                },
+            )
+        else:
+            _db_logger.info(
+                _EVENT_ENTITY_DELETED,
+                extra={
+                    "operation": _OP_DELETE,
+                    "entity": _entity_label(obj),
+                    "entity_id": _entity_pk(obj),
+                    "user_id": user_id,
+                },
+            )
+
+
+# Cache ``(is_soft_delete, is_multi_tenant)`` flags per mapper class so the
+# ``do_orm_execute`` hot path skips redundant ``issubclass`` work on every query.
+_mixin_flags_cache: dict[type, tuple[bool, bool]] = {}
+
+
+def _filter_select_statements(execute_state: ORMExecuteState) -> None:
+    """Attach per-mapper ``with_loader_criteria`` for soft-delete and tenant isolation.
+
+    The criteria are attached per concrete mapper because SQLModel mixins
+    expose Pydantic ``FieldInfo`` (not SQLAlchemy ``InstrumentedAttribute``)
+    at the mixin-class level, which breaks the lambda form of
+    ``with_loader_criteria`` that was used before the SQLModel migration.
+
+    Soft-delete bypass: ``stmt.execution_options(include_deleted=True)``.
+    """
+    if not execute_state.is_select:
+        return
+
+    skip_soft_delete = execute_state.execution_options.get("include_deleted", False)
+    tenant_id = current_tenant_id.get()
+    if skip_soft_delete and tenant_id is None:
+        return
+
+    options = []
+    for mapper in execute_state.all_mappers:
+        cls = mapper.class_
+        flags = _mixin_flags_cache.get(cls)
+        if flags is None:
+            flags = (issubclass(cls, SoftDeleteMixin), issubclass(cls, MultiTenantMixin))
+            _mixin_flags_cache[cls] = flags
+        is_soft_delete, is_multi_tenant = flags
+        if is_soft_delete and not skip_soft_delete:
+            options.append(
+                with_loader_criteria(cls, cls.is_deleted.is_(False), include_aliases=True)
+            )
+        if is_multi_tenant and tenant_id is not None:
+            options.append(
+                with_loader_criteria(cls, cls.tenant_id == tenant_id, include_aliases=True)
+            )
+
+    if options:
+        execute_state.statement = execute_state.statement.options(*options)