simple-module-db 0.0.1__py3-none-any.whl

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/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/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/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)

simple_module_db/migrations.py

@@ -0,0 +1,112 @@
+"""Helpers for Alembic integration with module-based schemas.
+
+A host's ``migrations/env.py`` should call :func:`build_module_metadata` to
+obtain the combined ``target_metadata`` for autogenerate, and
+:func:`make_include_object` to obtain an ``include_object`` filter that
+protects non-module tables from being touched by autogenerate.
+
+This abstraction decouples the host from the import mechanics and is the
+single place where a pip-installed module's ``<pkg>.models`` submodule gets
+loaded — so every host scaffolded by ``sm create-host`` behaves identically
+whether the module was installed via workspace path, PyPI wheel, or
+``pip install -e``.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from collections.abc import Callable, Sequence
+from typing import Literal
+
+from simple_module_core import ModuleBase
+from simple_module_core.discovery import discover_modules, get_module_package_name
+from sqlalchemy import MetaData
+from sqlalchemy.schema import SchemaItem
+
+from simple_module_db.base import all_module_bases
+
+logger = logging.getLogger(__name__)
+
+# Matches alembic.context.configure's include_object signature exactly so
+# type-checkers accept the returned filter without casts or ignores.
+_SchemaItemType = Literal[
+    "schema", "table", "column", "index", "unique_constraint", "foreign_key_constraint"
+]
+IncludeObjectFn = Callable[[SchemaItem, str | None, _SchemaItemType, bool, SchemaItem | None], bool]
+
+
+def build_module_metadata(modules: Sequence[ModuleBase] | None = None) -> MetaData:
+    """Import every installed module's ``models`` submodule and return combined MetaData.
+
+    Returns a single :class:`MetaData` containing every ``Table`` declared by
+    every installed module's SQLAlchemy models. Modules without a ``models``
+    submodule are skipped without error.
+
+    :param modules: Optional list of already-discovered modules. When ``None``,
+        :func:`discover_modules` is called to find them. Callers that already
+        have the list (e.g. an env.py that shares state with the app) should
+        pass it in to avoid re-parsing entry_points and re-running the
+        framework version check.
+    """
+    if modules is None:
+        modules = discover_modules()
+    for mod in modules:
+        pkg = get_module_package_name(mod)
+        try:
+            importlib.import_module(f"{pkg}.models")
+        except ModuleNotFoundError:
+            logger.debug("No models submodule for module '%s' (pkg=%s)", mod.meta.name, pkg)
+
+    combined = MetaData()
+    for base in all_module_bases:
+        for table in base.metadata.tables.values():
+            table.to_metadata(combined)
+    return combined
+
+
+def make_include_object(metadata: MetaData) -> IncludeObjectFn:
+    """Return an Alembic ``include_object`` filter scoped to the module tables.
+
+    Call as ``context.configure(..., include_object=make_include_object(meta))``.
+    The filter accepts only table names present in ``metadata``, preventing
+    autogenerate from diffing — and potentially dropping — tables that exist
+    in the database but aren't owned by any installed module (e.g. a user
+    table added by the host developer outside the module system).
+    """
+    allowlist = {t.name for t in metadata.tables.values()}
+
+    def include_object(
+        object: SchemaItem,
+        name: str | None,
+        type_: _SchemaItemType,
+        reflected: bool,
+        compare_to: SchemaItem | None,
+    ) -> bool:
+        if type_ == "table":
+            return name in allowlist
+        parent_table = getattr(object, "table", None)
+        if parent_table is not None:
+            return parent_table.name in allowlist
+        return True
+
+    return include_object
+
+
+def render_item(type_, obj, autogen_context):
+    """Alembic ``render_item`` callback that collapses SQLModel's ``AutoString``.
+
+    Without this, autogenerate emits ``sqlmodel.sql.sqltypes.AutoString(...)``
+    in generated migrations but does not add the corresponding
+    ``import sqlmodel``, so the migration fails with ``NameError`` on apply.
+    ``AutoString`` is a thin wrapper over ``String``, so collapsing it here
+    keeps migrations self-contained without losing semantics.
+
+    Pass to :func:`alembic.context.configure` as ``render_item=render_item``.
+    """
+    if type_ == "type" and type(obj).__name__ == "AutoString":
+        length = getattr(obj, "length", None)
+        if length is not None:
+            return f"sa.String(length={length})"
+        return "sa.String()"
+    return False  # let alembic use its default rendering

simple_module_db/mixins.py

@@ -0,0 +1,62 @@
+"""Entity mixins for cross-cutting concerns (audit, soft delete, tenancy, versioning).
+
+We use ``sa_type`` + ``sa_column_kwargs`` (not ``sa_column=Column(...)``) so
+SQLModel constructs a fresh ``Column`` per concrete subclass; sharing a single
+``Column`` across mixin subclasses raises
+``ArgumentError: Column already assigned to Table``.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, func
+from sqlmodel import Field, SQLModel
+
+
+class AuditMixin(SQLModel):
+    """Adds created_at, updated_at, created_by, updated_by fields.
+
+    ``created_at`` gets a server-side default; ``updated_at`` is populated by
+    the audit listener in :mod:`simple_module_db.listeners`.
+    """
+
+    created_at: datetime = Field(
+        sa_type=DateTime(timezone=True),
+        sa_column_kwargs={"server_default": func.now()},
+    )
+    updated_at: datetime | None = Field(
+        default=None,
+        sa_type=DateTime(timezone=True),
+        sa_column_kwargs={"onupdate": func.now()},
+    )
+    created_by: str | None = Field(default=None, max_length=255)
+    updated_by: str | None = Field(default=None, max_length=255)
+
+
+class SoftDeleteMixin(SQLModel):
+    """Marks records as deleted instead of removing them.
+
+    Query filters installed by :func:`register_listeners` exclude
+    ``is_deleted=True`` rows by default. Use
+    ``stmt.execution_options(include_deleted=True)`` to bypass.
+    """
+
+    is_deleted: bool = Field(default=False)
+    deleted_at: datetime | None = Field(
+        default=None,
+        sa_type=DateTime(timezone=True),
+    )
+    deleted_by: str | None = Field(default=None, max_length=255)
+
+
+class MultiTenantMixin(SQLModel):
+    """Adds a tenant_id column for data isolation in multi-tenant apps."""
+
+    tenant_id: str = Field(max_length=50, index=True)
+
+
+class VersionedMixin(SQLModel):
+    """Optimistic concurrency via an auto-incrementing version field."""
+
+    version: int = Field(default=1)

simple_module_db/provider.py

@@ -0,0 +1,16 @@
+"""Database provider detection."""
+
+from enum import StrEnum
+
+
+class DatabaseProvider(StrEnum):
+    SQLITE = "sqlite"
+    POSTGRESQL = "postgresql"
+
+
+def detect_provider(database_url: str) -> DatabaseProvider:
+    """Detect the database provider from a connection URL."""
+    url_lower = database_url.lower()
+    if url_lower.startswith(("postgresql", "postgres")):
+        return DatabaseProvider.POSTGRESQL
+    return DatabaseProvider.SQLITE

simple_module_db/session.py

@@ -0,0 +1,70 @@
+"""Async engine and session factory management."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.orm import Session
+
+from simple_module_db.provider import DatabaseProvider, detect_provider
+
+
+@dataclass
+class DatabaseState:
+    """Holds all database state for a single application instance."""
+
+    engine: AsyncEngine
+    session_factory: async_sessionmaker[AsyncSession]
+    sync_session_class: type[Session] = field(repr=False, default=Session)
+    _listeners_registered: bool = field(default=False, repr=False)
+
+
+def init_db(
+    database_url: str,
+    *,
+    echo: bool = False,
+    pool_size: int = 10,
+    max_overflow: int = 20,
+    pool_pre_ping: bool = True,
+    pool_recycle: int = 1800,
+) -> DatabaseState:
+    """Create an async engine and session factory.
+
+    The pool options only take effect for server-side providers (Postgres).
+    SQLite uses SQLAlchemy's default pool (single-file, no network), so
+    passing ``pool_size``/etc. would raise ``TypeError`` — skipped below.
+
+    Returns a ``DatabaseState`` that should be stored on ``app.state.db``.
+    """
+    provider = detect_provider(database_url)
+
+    connect_args: dict = {}
+    engine_kwargs: dict = {"echo": echo, "connect_args": connect_args}
+    if provider == DatabaseProvider.SQLITE:
+        connect_args["check_same_thread"] = False
+    else:
+        engine_kwargs.update(
+            pool_size=pool_size,
+            max_overflow=max_overflow,
+            pool_pre_ping=pool_pre_ping,
+            pool_recycle=pool_recycle,
+        )
+
+    engine = create_async_engine(database_url, **engine_kwargs)
+    # Scoped Session subclass so event listeners only fire for this engine's sessions
+    scoped_session_class = type("ScopedSession", (Session,), {})
+    session_factory = async_sessionmaker(
+        engine, expire_on_commit=False, sync_session_class=scoped_session_class
+    )
+
+    return DatabaseState(
+        engine=engine,
+        session_factory=session_factory,
+        sync_session_class=scoped_session_class,
+    )

simple_module_db-0.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+simple_module_db/__init__.py,sha256=4Hhxiqh8apRK2S1afYRjftIw13R3ZQxcL0DScsgKP84,936
+simple_module_db/base.py,sha256=oLCG4x_v83Kw_uv6_qsfwBzprM7__dVMRd8fUEMmKTk,3497
+simple_module_db/deps.py,sha256=C-nVm2mLOjAuqkNL7MnjnjpDG4x-vPfhTdZbaFbKWts,2306
+simple_module_db/listeners.py,sha256=ENuxdc59GO-x0S8pNMS77psNOkagjQD18xSlLjt7OuM,8176
+simple_module_db/migrations.py,sha256=KZzz3Cr-486P2reGjUczhmIXO1cNEzJg1M4_YrJ326Y,4555
+simple_module_db/mixins.py,sha256=I5Ih2GQOWNe7jERt4wQdxP4itR2SNadfbXEw_yCZcDM,1968
+simple_module_db/provider.py,sha256=jvO42xGh15bj52xd9E4dZc1yur_soSSkBAHKMWhAGi4,444
+simple_module_db/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simple_module_db/session.py,sha256=Q3ked5HQIMUJO9jBaPJ37lQha8UXYJyLJ4hm69fdmcw,2181
+simple_module_db-0.0.1.dist-info/METADATA,sha256=uzGqb3gRecAjEPDS_oerg397caPWXdMG17zMUXx2Q88,3371
+simple_module_db-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+simple_module_db-0.0.1.dist-info/licenses/LICENSE,sha256=Yn66lhLklsF5p7pa85_ksQrJ79Q-FgOaUAHevLBjer4,1068
+simple_module_db-0.0.1.dist-info/RECORD,,

simple_module_db-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

simple_module_db-0.0.1.dist-info/licenses/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.