simple-module-db 0.0.36__tar.gz → 0.0.37__tar.gz

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/.gitignore

@@ -64,3 +64,4 @@ host/client_app/.playwright-cli/*
 .superpowers/
 .qa/
 .verify/
+/openapi.json

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_db
-Version: 0.0.36
+Version: 0.0.37
 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
@@ -25,7 +25,7 @@ Requires-Dist: aiosqlite>=0.20
 Requires-Dist: alembic>=1.14
 Requires-Dist: asyncpg>=0.30
 Requires-Dist: psycopg2-binary>=2.9
-Requires-Dist: simple-module-core==0.0.36
+Requires-Dist: simple-module-core==0.0.37
 Requires-Dist: sqlalchemy[asyncio]>=2.0
 Requires-Dist: sqlmodel>=0.0.22
 Description-Content-Type: text/markdown

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_db"
-version = "0.0.36"
+version = "0.0.37"
 description = "Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module"
 readme = "README.md"
 license = "MIT"
@@ -28,7 +28,7 @@ dependencies = [
     # The async app code goes through asyncpg; migration env.py rewrites the
     # URL to +psycopg2 because Alembic's online migrations are sync-only.
     "psycopg2-binary>=2.9",
-    "simple_module_core==0.0.36",
+    "simple_module_core==0.0.37",
     "sqlalchemy[asyncio]>=2.0",
     "sqlmodel>=0.0.22",
 ]

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/simple_module_db/__init__.py

@@ -4,6 +4,7 @@ from simple_module_db.audit import AuditRecord
 from simple_module_db.base import create_module_base
 from simple_module_db.callbacks import OnCommitCallback
 from simple_module_db.deps import get_db
+from simple_module_db.extensions import UnsupportedDatabaseError, ensure_db_extensions
 from simple_module_db.migration_portability import drop_enums_if_postgres
 from simple_module_db.migrations import (
     build_module_metadata,
@@ -26,9 +27,11 @@ from simple_module_db.tenancy import (
     bind_current_tenant,
     current_tenant_id,
     is_valid_tenant_id,
+    no_tenant,
     tenant_context,
 )
 from simple_module_db.transaction import CommitBeforeResponseMiddleware, finalize_session
+from simple_module_db.types import AwareDateTime, LTree, TSVector
 from simple_module_db.writes import hard_delete, mark_written
 
 __all__ = [
@@ -39,15 +42,19 @@ __all__ = [
     "TENANT_ID_PATTERN",
     "AuditMixin",
     "AuditRecord",
+    "AwareDateTime",
     "CommitBeforeResponseMiddleware",
     "DatabaseProvider",
     "DatabaseState",
+    "LTree",
     "MissingTenantError",
     "MultiTenantMixin",
     "OnCommitCallback",
     "RequestSession",
     "SoftDeleteMixin",
+    "TSVector",
     "TenantIsolationError",
+    "UnsupportedDatabaseError",
     "VersionedMixin",
     "all_tenants",
     "bind_current_tenant",
@@ -56,6 +63,7 @@ __all__ = [
     "current_tenant_id",
     "detect_provider",
     "drop_enums_if_postgres",
+    "ensure_db_extensions",
     "finalize_session",
     "get_db",
     "hard_delete",
@@ -66,6 +74,7 @@ __all__ = [
     "make_include_object",
     "make_process_revision_directives",
     "mark_written",
+    "no_tenant",
     "render_item",
     "tenant_context",
 ]

simple_module_db-0.0.37/simple_module_db/extensions.py

@@ -0,0 +1,103 @@
+"""Postgres extensions a module needs (``ModuleBase.db_extensions``).
+
+``ensure_db_extensions`` runs from the host ``env.py`` before the migrations
+do, so a revision that creates an ``ltree`` column finds the extension already
+installed. It is idempotent (``CREATE EXTENSION IF NOT EXISTS``), so it costs
+nothing on an up-to-date database.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from collections.abc import Iterable
+from typing import Any
+
+from simple_module_core import ModuleBase
+from sqlalchemy import text
+
+from simple_module_db.types import LTree, TSVector
+
+logger = logging.getLogger(__name__)
+
+EXTENSION_NAME_PATTERN = re.compile(r"^[a-z][a-z0-9_-]*$")
+
+
+class UnsupportedDatabaseError(RuntimeError):
+    """A module needs a database feature the configured database lacks."""
+
+
+def declared_extensions(modules: Iterable[ModuleBase]) -> dict[str, list[str]]:
+    """``{extension: [module names that declare it]}``, validated, in module order."""
+    wanted: dict[str, list[str]] = {}
+    for mod in modules:
+        for name in mod.db_extensions():
+            if not EXTENSION_NAME_PATTERN.fullmatch(name):
+                raise ValueError(
+                    f"Module {mod.meta.name!r} declares invalid database extension "
+                    f"{name!r} (must match {EXTENSION_NAME_PATTERN.pattern})"
+                )
+            owners = wanted.setdefault(name, [])
+            if mod.meta.name not in owners:
+                owners.append(mod.meta.name)
+    return wanted
+
+
+def ensure_db_extensions(connection: Any, modules: Iterable[ModuleBase]) -> list[str]:
+    """Install every extension the modules declare; return the extension names.
+
+    * Postgres: ``CREATE EXTENSION IF NOT EXISTS "<name>"``.
+    * SQLite: raises :class:`UnsupportedDatabaseError` naming the module(s) and
+      extension(s) — SQLite has none, and carrying on would fail later with a
+      less helpful message.
+    * ``connection=None`` is Alembic offline mode: the statements are emitted
+      into the generated SQL script through ``context.execute``.
+    """
+    wanted = declared_extensions(modules)
+    if not wanted:
+        return []
+
+    offline = connection is None
+    if offline:
+        from alembic import context
+
+        dialect = context.get_context().dialect.name
+    else:
+        dialect = connection.dialect.name
+
+    if dialect != "postgresql":
+        detail = "; ".join(f"{', '.join(owners)} needs {name!r}" for name, owners in wanted.items())
+        raise UnsupportedDatabaseError(
+            f"Database extensions require PostgreSQL, but the database is {dialect}: {detail}. "
+            "Point SM_DATABASE_URL at Postgres or uninstall the module."
+        )
+
+    for name in wanted:
+        statement = f'CREATE EXTENSION IF NOT EXISTS "{name}"'
+        if offline:
+            context.execute(statement)
+        else:
+            logger.info("Ensuring Postgres extension %r", name)
+            connection.execute(text(statement))
+    return list(wanted)
+
+
+def render_extension_type(obj: Any, imports: set[str] | None) -> str | None:
+    """Alembic render for ``LTree`` / ``TSVector``, or ``None`` for other types.
+
+    Rendered through our own classes (not ``postgresql.TSVECTOR``) so the same
+    revision also upgrades on SQLite, where they are ``TEXT``.
+    """
+    if isinstance(obj, (LTree, TSVector)):
+        if imports is not None:
+            imports.add("import simple_module_db.types")
+        return f"simple_module_db.types.{type(obj).__name__}()"
+    return None
+
+
+__all__ = [
+    "UnsupportedDatabaseError",
+    "declared_extensions",
+    "ensure_db_extensions",
+    "render_extension_type",
+]

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/simple_module_db/migrations.py

@@ -27,8 +27,13 @@ from simple_module_core.diagnostics._expression_index import index_is_expression
 from simple_module_core.discovery import discover_modules, get_module_package_name
 from sqlalchemy import Index, MetaData
 from sqlalchemy.schema import SchemaItem
+from sqlmodel.sql.sqltypes import UTCDateTime
 
 from simple_module_db.base import all_module_bases
+from simple_module_db.extensions import (  # noqa: F401  (ensure_db_extensions re-exported)
+    ensure_db_extensions,
+    render_extension_type,
+)
 from simple_module_db.migration_portability import (
     iter_ops_recursive,
     render_boolean_default,
@@ -232,14 +237,18 @@ def _inject_drop_index_before_drop_table(downgrade_ops, expression_indexes) -> N
 def render_item(type_, obj, autogen_context):
     """Alembic ``render_item`` callback for SQLModel + extension types.
 
-    * Collapses SQLModel's ``AutoString`` to ``sa.String`` so migrations don't
-      need to ``import sqlmodel``.
+    * Collapses SQLModel's ``AutoString`` to ``sa.String`` and ``UTCDateTime``
+      to ``sa.DateTime(timezone=True)`` so migrations don't need to
+      ``import sqlmodel`` (GH #440). Any other ``sqlmodel`` type still gets
+      the import added, so the migration stays importable.
     * Renders Python ``StrEnum`` columns with ``values_callable`` so the
       Postgres enum labels match the lowercase ``StrEnum`` values rather than
       SQLAlchemy's default of using uppercase attribute names. This means raw
       SQL like ``WHERE status = 'ready'`` actually works against the live DB.
     * Renders ``true()``/``false()`` server defaults as ``sa.true()``/``sa.false()``
       instead of the dialect-specific ``sa.text('1')``/``sa.text('0')`` (GH #342).
+    * Renders ``LTree``/``TSVector`` through ``simple_module_db.types`` (with
+      the import) so one revision upgrades on Postgres and SQLite alike.
     * Adds the necessary imports for ``fastapi_users_db_sqlalchemy.generics``
       and ``geoalchemy2`` types (rendered by their own classes elsewhere) so
       the generated migration is importable.
@@ -257,6 +266,14 @@ def render_item(type_, obj, autogen_context):
     if cls_name == "AutoString":
         length = getattr(obj, "length", None)
         return f"sa.String(length={length})" if length is not None else "sa.String()"
+    if isinstance(obj, UTCDateTime):  # includes our ``AwareDateTime`` subclass
+        return "sa.DateTime(timezone=True)"
+
+    if (rendered := render_extension_type(obj, imports)) is not None:
+        return rendered
+
+    if imports is not None and cls_module.startswith("sqlmodel"):
+        imports.add("import sqlmodel")
 
     if imports is not None and cls_module.startswith("fastapi_users_db_sqlalchemy"):
         imports.add("import fastapi_users_db_sqlalchemy.generics")

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/simple_module_db/mixins.py

@@ -10,9 +10,11 @@ from __future__ import annotations
 
 from datetime import UTC, datetime
 
-from sqlalchemy import DateTime, func
+from sqlalchemy import func
 from sqlmodel import Field, SQLModel
 
+from simple_module_db.types import AwareDateTime
+
 
 def _utcnow() -> datetime:
     """Timezone-aware UTC ``now`` for the Python-side default of ``created_at``."""
@@ -32,12 +34,12 @@ class AuditMixin(SQLModel):
 
     created_at: datetime = Field(
         default_factory=_utcnow,
-        sa_type=DateTime(timezone=True),
+        sa_type=AwareDateTime(),
         sa_column_kwargs={"server_default": func.now()},
     )
     updated_at: datetime | None = Field(
         default=None,
-        sa_type=DateTime(timezone=True),
+        sa_type=AwareDateTime(),
         sa_column_kwargs={"onupdate": func.now()},
     )
     created_by: str | None = Field(default=None, max_length=255)
@@ -55,7 +57,7 @@ class SoftDeleteMixin(SQLModel):
     is_deleted: bool = Field(default=False)
     deleted_at: datetime | None = Field(
         default=None,
-        sa_type=DateTime(timezone=True),
+        sa_type=AwareDateTime(),
     )
     deleted_by: str | None = Field(default=None, max_length=255)
 

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/simple_module_db/tenancy.py

@@ -128,6 +128,24 @@ def all_tenants() -> Generator[None]:
         current_tenant_id.reset(tenant_token)
 
 
+@contextmanager
+def no_tenant() -> Generator[None]:
+    """Run the block with no tenant bound and outside any ``all_tenants()``.
+
+    The scope of code that has not resolved a tenant: under strict isolation a
+    tenant-scoped query fails closed. For work replayed later on behalf of such
+    code (a durable event published from a public route), so it runs with no
+    more reach than its publisher had, whatever scope the replaying code is in.
+    """
+    tenant_token = current_tenant_id.set(None)
+    bypass_token = _all_tenants.set(False)
+    try:
+        yield
+    finally:
+        _all_tenants.reset(bypass_token)
+        current_tenant_id.reset(tenant_token)
+
+
 def bind_current_tenant[**P, R](fn: Callable[P, R]) -> Callable[P, R]:
     """Wrap ``fn`` so it runs as the tenant bound *now*, whenever it is called.
 
@@ -197,5 +215,6 @@ __all__ = [
     "is_all_tenants",
     "is_valid_tenant_id",
     "missing_tenant_error",
+    "no_tenant",
     "tenant_context",
 ]

simple_module_db-0.0.37/simple_module_db/types.py

@@ -0,0 +1,94 @@
+"""Column types shared by every module.
+
+``AwareDateTime`` is the explicit-column counterpart of the ``UTCDateTime``
+SQLModel picks for a bare ``datetime`` field. Declaring
+``sa_type=DateTime(timezone=True)`` bypasses that type, and on SQLite (which
+stores no offset) such a column reads back *naive*: pydantic then serializes
+``2026-10-14T10:40:52`` with no offset and a browser parses UTC as local time
+(GH #468). Use ``sa_type=AwareDateTime()`` wherever a field needs an explicit
+column type.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from sqlalchemy import Text
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.engine.interfaces import Dialect
+from sqlalchemy.types import TypeDecorator, UserDefinedType
+from sqlmodel.sql.sqltypes import UTCDateTime
+
+
+class AwareDateTime(UTCDateTime):
+    """``DateTime(timezone=True)`` that always reads back an aware UTC value.
+
+    Unlike SQLModel's ``UTCDateTime`` a naive value is accepted on write and
+    taken to be UTC — the semantics a plain ``DateTime(timezone=True)`` column
+    had on SQLite — so existing callers that bind naive UTC keep working.
+    Migrations render it as ``sa.DateTime(timezone=True)`` (see
+    :func:`simple_module_db.migrations.render_item`), so adopting it needs no
+    schema change.
+    """
+
+    cache_ok = True
+
+    def __repr__(self) -> str:
+        return "AwareDateTime()"
+
+    def process_bind_param(self, value: datetime | None, dialect: Dialect) -> datetime | None:
+        if value is not None and value.utcoffset() is None:
+            value = value.replace(tzinfo=UTC)
+        return super().process_bind_param(value, dialect)
+
+
+class _PgLTree(UserDefinedType):
+    cache_ok = True
+
+    def get_col_spec(self, **kw: object) -> str:
+        return "LTREE"
+
+
+class LTree(TypeDecorator):
+    """Postgres ``ltree`` (label tree paths); ``TEXT`` on SQLite.
+
+    The ``ltree`` extension must be declared by the owning module through
+    :meth:`~simple_module_core.ModuleBase.db_extensions` (``["ltree"]``).
+    Values are plain dotted-path strings (``"top.science.physics"``). Query
+    operators (``<@``, ``@>``, ``~``) are Postgres-only: use ``column.op("<@")``.
+    """
+
+    impl = Text
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect: Dialect):
+        if dialect.name == "postgresql":
+            return dialect.type_descriptor(_PgLTree())
+        return dialect.type_descriptor(Text())
+
+    def __repr__(self) -> str:
+        return "LTree()"
+
+
+# Let Postgres reflection (autogenerate, ``alembic check``) return ``LTree``
+# instead of warning "Did not recognize type 'ltree'" and falling back to NullType.
+postgresql.base.ischema_names["ltree"] = LTree
+
+
+class TSVector(TypeDecorator):
+    """Postgres ``tsvector`` (full-text search); ``TEXT`` on SQLite.
+
+    Built in to Postgres, so no extension is needed. Pair with a GIN index and
+    ``func.to_tsvector`` / ``column.op("@@")(func.plainto_tsquery(...))``.
+    """
+
+    impl = Text
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect: Dialect):
+        if dialect.name == "postgresql":
+            return dialect.type_descriptor(postgresql.TSVECTOR())
+        return dialect.type_descriptor(Text())
+
+    def __repr__(self) -> str:
+        return "TSVector()"

simple_module_db-0.0.37/tests/test_aware_datetime.py

@@ -0,0 +1,76 @@
+"""GH #468: timezone-aware columns must read back aware on SQLite.
+
+SQLite stores no offset, so a plain ``DateTime(timezone=True)`` column reads
+back naive and pydantic serializes it without one — the browser then parses
+UTC as local time. ``AwareDateTime`` attaches UTC on read.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta, timezone
+from types import SimpleNamespace
+
+import sqlalchemy as sa
+from simple_module_db import AuditMixin, AwareDateTime, render_item
+from sqlalchemy.ext.asyncio import create_async_engine
+
+_md = sa.MetaData()
+_stamps = sa.Table(
+    "aware_dt_stamps",
+    _md,
+    sa.Column("id", sa.Integer, primary_key=True),
+    sa.Column("at", AwareDateTime()),
+)
+
+
+async def _roundtrip(value: datetime) -> datetime:
+    engine = create_async_engine("sqlite+aiosqlite://")
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(_md.create_all)
+            await conn.execute(_stamps.insert().values(id=1, at=value))
+            return (await conn.execute(sa.select(_stamps.c.at))).scalar_one()
+    finally:
+        await engine.dispose()
+
+
+async def test_aware_value_reads_back_aware_utc():
+    stamp = datetime(2026, 10, 14, 10, 40, 52, 123456, tzinfo=UTC)
+
+    loaded = await _roundtrip(stamp)
+
+    assert loaded == stamp
+    assert loaded.utcoffset() == timedelta(0)
+    assert loaded.isoformat().endswith("+00:00")
+
+
+async def test_non_utc_offset_is_normalised_to_utc():
+    stamp = datetime(2026, 10, 14, 12, 40, tzinfo=timezone(timedelta(hours=2)))
+
+    loaded = await _roundtrip(stamp)
+
+    assert loaded == stamp
+    assert loaded.tzinfo == UTC
+    assert loaded.hour == 10
+
+
+async def test_naive_value_is_taken_as_utc():
+    """Unlike SQLModel's ``UTCDateTime``, a naive bind is accepted as UTC."""
+    loaded = await _roundtrip(datetime(2026, 10, 14, 10, 40))
+
+    assert loaded == datetime(2026, 10, 14, 10, 40, tzinfo=UTC)
+
+
+def test_audit_mixin_columns_use_aware_type():
+    fields = AuditMixin.model_fields
+    for name in ("created_at", "updated_at"):
+        sa_type = getattr(fields[name], "sa_type", None)
+        assert isinstance(sa_type, AwareDateTime), name
+
+
+def test_renders_as_plain_timezone_datetime():
+    """Adopting the type must not make autogenerate emit a diff or a sqlmodel import."""
+    ctx = SimpleNamespace(imports=set())
+
+    assert render_item("type", AwareDateTime(), ctx) == "sa.DateTime(timezone=True)"
+    assert ctx.imports == set()

simple_module_db-0.0.37/tests/test_db_extensions.py

@@ -0,0 +1,94 @@
+"""Postgres extensions + LTree/TSVector fallbacks, on SQLite (GH #458)."""
+
+from __future__ import annotations
+
+import pytest
+import sqlalchemy as sa
+from simple_module_core import ModuleBase, ModuleMeta
+from simple_module_db import LTree, TSVector, UnsupportedDatabaseError, ensure_db_extensions
+from simple_module_db.migrations import render_item
+from sqlalchemy.dialects import postgresql, sqlite
+
+
+def _module(name: str, *extensions: str) -> ModuleBase:
+    class _M(ModuleBase):
+        meta = ModuleMeta(name=name)
+
+        def db_extensions(self) -> list[str]:
+            return list(extensions)
+
+    return _M()
+
+
+def test_no_extensions_is_a_noop_even_on_sqlite():
+    engine = sa.create_engine("sqlite://")
+    with engine.connect() as conn:
+        assert ensure_db_extensions(conn, [_module("a")]) == []
+
+
+def test_sqlite_raises_naming_module_and_extensions():
+    engine = sa.create_engine("sqlite://")
+    with engine.connect() as conn, pytest.raises(UnsupportedDatabaseError) as exc:
+        ensure_db_extensions(conn, [_module("taxonomy", "ltree")])
+    assert "taxonomy" in str(exc.value)
+    assert "ltree" in str(exc.value)
+
+
+@pytest.mark.parametrize("bad", ["LTree", "X", "1abc", 'x"; DROP', 'bad"name', "x;drop", "-a", ""])
+def test_invalid_extension_name_is_rejected(bad: str):
+    engine = sa.create_engine("sqlite://")
+    with engine.connect() as conn, pytest.raises(ValueError, match="invalid database extension"):
+        ensure_db_extensions(conn, [_module("m", bad)])
+
+
+def test_hyphenated_extension_name_is_accepted_and_quoted(monkeypatch):
+    from alembic import context
+    from simple_module_db.extensions import declared_extensions
+
+    assert declared_extensions([_module("m", "uuid-ossp")]) == {"uuid-ossp": ["m"]}
+
+    emitted: list[str] = []
+
+    class _Ctx:
+        dialect = type("D", (), {"name": "postgresql"})()
+
+    monkeypatch.setattr(context, "get_context", lambda: _Ctx())
+    monkeypatch.setattr(context, "execute", emitted.append)
+    ensure_db_extensions(None, [_module("m", "uuid-ossp")])
+    assert emitted == ['CREATE EXTENSION IF NOT EXISTS "uuid-ossp"']
+
+
+def test_types_are_text_on_sqlite_and_native_on_postgres():
+    md = sa.MetaData()
+    t = sa.Table(
+        "dbext_t",
+        md,
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column("path", LTree()),
+        sa.Column("doc", TSVector()),
+    )
+    sqlite_ddl = str(sa.schema.CreateTable(t).compile(dialect=sqlite.dialect()))
+    pg_ddl = str(sa.schema.CreateTable(t).compile(dialect=postgresql.dialect()))
+    assert "path TEXT" in sqlite_ddl and "doc TEXT" in sqlite_ddl
+    assert "path LTREE" in pg_ddl and "doc TSVECTOR" in pg_ddl
+
+
+def test_types_round_trip_strings_on_sqlite():
+    md = sa.MetaData()
+    t = sa.Table("dbext_t", md, sa.Column("path", LTree()), sa.Column("doc", TSVector()))
+    engine = sa.create_engine("sqlite://")
+    md.create_all(engine)
+    with engine.begin() as conn:
+        conn.execute(t.insert().values(path="top.science", doc="'a':1"))
+        assert conn.execute(sa.select(t.c.path, t.c.doc)).one() == ("top.science", "'a':1")
+
+
+@pytest.mark.parametrize(("type_", "name"), [(LTree(), "LTree"), (TSVector(), "TSVector")])
+def test_render_item_emits_runnable_code_with_import(type_, name: str):
+    class _Ctx:
+        imports: set[str] = set()  # noqa: RUF012
+
+    ctx = _Ctx()
+    ctx.imports = set()
+    assert render_item("type", type_, ctx) == f"simple_module_db.types.{name}()"
+    assert "import simple_module_db.types" in ctx.imports

simple_module_db-0.0.37/tests/test_db_extensions_pg.py

@@ -0,0 +1,174 @@
+"""LTree/TSVector + extension migrations against a real Postgres (GH #458).
+
+Needs ``SM_TEST_DATABASE_URL=postgresql+asyncpg://...``; skipped otherwise.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import pytest
+import sqlalchemy as sa
+from alembic.autogenerate import compare_metadata, produce_migrations
+from alembic.autogenerate.api import AutogenContext
+from alembic.autogenerate.render import render_op_text
+from alembic.migration import MigrationContext
+from alembic.operations import Operations
+from simple_module_core import ModuleBase, ModuleMeta
+from simple_module_db import LTree, TSVector, ensure_db_extensions
+from simple_module_db.migrations import render_item
+from simple_module_test.database import database_url_for_tests
+from sqlalchemy.exc import SAWarning
+
+pytestmark = pytest.mark.postgres
+
+
+class _TaxonomyModule(ModuleBase):
+    meta = ModuleMeta(name="taxonomy")
+
+    def db_extensions(self) -> list[str]:
+        return ["ltree"]
+
+
+def _metadata() -> sa.MetaData:
+    md = sa.MetaData()
+    sa.Table(
+        "dbext_node",
+        md,
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column("path", LTree(), nullable=False),
+        sa.Column("search", TSVector()),
+    )
+    return md
+
+
+@pytest.fixture
+def pg_engine():
+    url = database_url_for_tests().replace("+asyncpg", "+psycopg2")
+    engine = sa.create_engine(url)
+    with engine.begin() as conn:
+        conn.execute(sa.text("DROP TABLE IF EXISTS dbext_node"))
+    yield engine
+    with engine.begin() as conn:
+        conn.execute(sa.text("DROP TABLE IF EXISTS dbext_node"))
+    engine.dispose()
+
+
+def test_ensure_db_extensions_is_idempotent(pg_engine):
+    with pg_engine.begin() as conn:
+        assert ensure_db_extensions(conn, [_TaxonomyModule()]) == ["ltree"]
+        assert ensure_db_extensions(conn, [_TaxonomyModule()]) == ["ltree"]
+        assert conn.execute(sa.text("SELECT 1 FROM pg_extension WHERE extname='ltree'")).scalar()
+
+
+def test_hyphenated_extension_creates(pg_engine):
+    class _Mod(ModuleBase):
+        meta = ModuleMeta(name="uuidmod")
+
+        def db_extensions(self) -> list[str]:
+            return ["uuid-ossp"]
+
+    with pg_engine.begin() as conn:
+        assert ensure_db_extensions(conn, [_Mod()]) == ["uuid-ossp"]
+        assert conn.execute(sa.text("SELECT uuid_generate_v4()")).scalar()
+
+
+def test_ltree_and_tsvector_queries(pg_engine):
+    md = _metadata()
+    table = md.tables["dbext_node"]
+    with pg_engine.begin() as conn:
+        ensure_db_extensions(conn, [_TaxonomyModule()])
+        md.create_all(conn)
+        conn.execute(
+            table.insert().values(
+                id=1, path="top.science", search=sa.func.to_tsvector("english", "red fox")
+            )
+        )
+        conn.execute(
+            table.insert(),
+            [{"id": 2, "path": "top.science.physics"}, {"id": 3, "path": "top.arts"}],
+        )
+        under = conn.execute(
+            sa.select(table.c.id).where(table.c.path.op("<@")(sa.literal("top.science", LTree())))
+        ).scalars()
+        assert sorted(under) == [1, 2]
+        hit = conn.execute(
+            sa.select(table.c.id).where(
+                table.c.search.op("@@")(sa.func.plainto_tsquery("english", "fox"))
+            )
+        ).scalars()
+        assert list(hit) == [1]
+
+
+def test_autogenerated_migration_round_trips(pg_engine):
+    """Autogenerate -> upgrade -> downgrade -> upgrade -> no drift left."""
+    md = _metadata()
+    with pg_engine.begin() as conn:
+        ensure_db_extensions(conn, [_TaxonomyModule()])
+        # Only this test's table: other tests leave theirs in the shared schema,
+        # and autogenerate would otherwise emit DROPs for them.
+        mc = MigrationContext.configure(
+            conn,
+            opts={
+                "render_item": render_item,
+                "include_name": lambda name, type_, _parent: (
+                    type_ != "table" or name == "dbext_node"
+                ),
+            },
+        )
+        ops = produce_migrations(mc, md)
+        assert ops.upgrade_ops is not None
+        auto = AutogenContext(
+            mc,
+            md,
+            opts={
+                "render_item": render_item,
+                "sqlalchemy_module_prefix": "sa.",
+                "alembic_module_prefix": "op.",
+                "user_module_prefix": None,
+                "render_as_batch": False,
+            },
+        )
+        upgrade = "\n".join(render_op_text(auto, op) for op in ops.upgrade_ops.ops)
+        downgrade = "\n".join(render_op_text(auto, op) for op in ops.upgrade_ops.reverse().ops)
+        assert "simple_module_db.types.LTree()" in upgrade
+        assert "simple_module_db.types.TSVector()" in upgrade
+
+        # The generated imports alone must make the code runnable.
+        namespace: dict = {"op": Operations(mc)}
+        exec("import sqlalchemy as sa\n" + "\n".join(sorted(auto.imports)), namespace)
+
+        def run(code: str) -> None:
+            with Operations.context(mc):
+                exec(code, namespace)
+
+        def has_table() -> bool:
+            return sa.inspect(conn).has_table("dbext_node")
+
+        run(upgrade)
+        assert has_table()
+        # No "Did not recognize type 'ltree'" warning: reflection knows LTree.
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", SAWarning)
+            assert compare_metadata(mc, md) == []
+        run(downgrade)
+        assert not sa.inspect(conn).has_table("dbext_node")
+        run(upgrade)
+        assert has_table()
+
+
+async def test_reset_schema_recreates_declared_extensions(monkeypatch):
+    from simple_module_core import discovery
+    from simple_module_test.database import init_db_kwargs, reset_schema
+    from sqlalchemy.ext.asyncio import create_async_engine
+
+    monkeypatch.setattr(discovery, "discover_modules", lambda *a, **k: [_TaxonomyModule()])
+    url = database_url_for_tests()
+    engine = create_async_engine(url, **init_db_kwargs(url))
+    try:
+        await reset_schema(engine)
+        async with engine.connect() as conn:
+            found = await conn.execute(sa.text("SELECT 1 FROM pg_extension WHERE extname='ltree'"))
+            assert found.scalar() == 1
+    finally:
+        await engine.dispose()

{simple_module_db-0.0.36 → simple_module_db-0.0.37}/tests/test_migration_portability.py

@@ -162,3 +162,32 @@ def test_downgrade_recreated_boolean_defaults_render_portably():
 
     assert code.count("sa.false()") == 2
     assert code.count("sa.true()") == 2
+
+
+def test_sqlmodel_utc_datetime_renders_without_sqlmodel():
+    """GH #440: sqlmodel>=0.0.48 maps ``datetime`` fields to ``UTCDateTime``."""
+    from sqlmodel.sql.sqltypes import UTCDateTime
+
+    md = sa.MetaData()
+    sa.Table(
+        "stamps",
+        md,
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column("created_at", UTCDateTime(), nullable=False),
+    )
+    code, _, _ = _autogenerate(md)
+
+    assert "sa.Column('created_at', sa.DateTime(timezone=True), nullable=False)" in code
+    assert "sqlmodel" not in code
+
+
+def test_other_sqlmodel_types_add_the_import():
+    class FakeType(sa.types.TypeDecorator):
+        impl = sa.Integer
+        cache_ok = True
+
+    FakeType.__module__ = "sqlmodel.sql.sqltypes"
+    autogen_context = SimpleNamespace(imports=set())
+
+    assert render_item("type", FakeType(), autogen_context) is False
+    assert autogen_context.imports == {"import sqlmodel"}