sqlspec 0.70.0__tar.gz → 0.70.1__tar.gz

{sqlspec-0.70.0 → sqlspec-0.70.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlspec
-Version: 0.70.0
+Version: 0.70.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Documentation, https://sqlspec.dev

{sqlspec-0.70.0 → sqlspec-0.70.1}/pyproject.toml

@@ -23,7 +23,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.11, <4.0"
-version = "0.70.0"
+version = "0.70.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -301,6 +301,7 @@ include = [
   "sqlspec/adapters/oracledb/_vector_handlers.py", # DB_TYPE_VECTOR inputtypehandler / outputtypehandler dispatch
   "sqlspec/adapters/oracledb/_storage.py",         # Pure extension-table storage capability and DDL gates
   "sqlspec/utils/text.py",                         # Text utilities
+  "sqlspec/utils/adapters.py",                     # Adapter and extension store resolution helpers
   "sqlspec/utils/sync_tools.py",                   # Synchronous utility functions
   "sqlspec/utils/env.py",                          # Environment variable parsing utilities
   "sqlspec/utils/module_loader.py",                # Optional dependency loader helpers
@@ -340,7 +341,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.70.0"
+current_version = "0.70.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/adapters/oracledb/events/backend.py

@@ -9,6 +9,7 @@ from sqlspec.adapters.oracledb._typing import DEQ_IMMEDIATE, DEQ_ON_COMMIT
 from sqlspec.adapters.oracledb.events._hub import OracleAsyncAQHub, OracleSyncAQHub
 from sqlspec.exceptions import ImproperConfigurationError, MissingDependencyError
 from sqlspec.extensions.events import EventMessage, parse_event_timestamp
+from sqlspec.utils.adapters import resolve_adapter_name
 from sqlspec.utils.logging import get_logger, log_with_context
 from sqlspec.utils.serializers import from_json
 from sqlspec.utils.uuids import uuid4
@@ -42,7 +43,7 @@ class OracleSyncAQEventBackend:
     backend_name = "aq"
 
     def __init__(self, config: "OracleSyncConfig", settings: "dict[str, Any] | None" = None) -> None:
-        if "oracledb" not in type(config).__module__:
+        if resolve_adapter_name(config) != "oracledb":
             msg = "Oracle AQ backend requires an Oracle adapter"
             raise ImproperConfigurationError(msg)
         if config.is_async:
@@ -123,7 +124,7 @@ class OracleAsyncAQEventBackend:
     backend_name = "aq"
 
     def __init__(self, config: "OracleAsyncConfig", settings: "dict[str, Any] | None" = None) -> None:
-        if "oracledb" not in type(config).__module__:
+        if resolve_adapter_name(config) != "oracledb":
             msg = "Oracle AQ backend requires an Oracle adapter"
             raise ImproperConfigurationError(msg)
         if not config.is_async:

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/adapters/psqlpy/events/backend.py

@@ -16,6 +16,7 @@ from sqlspec.extensions.events import (
     decode_notify_payload,
     encode_notify_payload,
 )
+from sqlspec.utils.adapters import resolve_adapter_name
 from sqlspec.utils.logging import get_logger, log_with_context
 from sqlspec.utils.serializers import from_json, to_json
 from sqlspec.utils.uuids import uuid4
@@ -88,7 +89,7 @@ class PsqlpyEventsBackend:
     backend_name = "notify"
 
     def __init__(self, config: "PsqlpyConfig") -> None:
-        if "psqlpy" not in type(config).__module__:
+        if resolve_adapter_name(config) != "psqlpy":
             msg = "Psqlpy events backend requires a Psqlpy adapter"
             raise ImproperConfigurationError(msg)
         self._config = config
@@ -177,7 +178,7 @@ class PsqlpyHybridEventsBackend:
     backend_name = "notify_queue"
 
     def __init__(self, config: "PsqlpyConfig", queue: "AsyncTableEventQueue") -> None:
-        if "psqlpy" not in type(config).__module__:
+        if resolve_adapter_name(config) != "psqlpy":
             msg = "Psqlpy hybrid backend requires a Psqlpy adapter"
             raise ImproperConfigurationError(msg)
         self._config = config

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/adapters/psycopg/events/backend.py

@@ -17,6 +17,7 @@ from sqlspec.extensions.events import (
     decode_notify_payload,
     encode_notify_payload,
 )
+from sqlspec.utils.adapters import resolve_adapter_name
 from sqlspec.utils.logging import get_logger, log_with_context
 from sqlspec.utils.serializers import from_json, to_json
 from sqlspec.utils.uuids import uuid4
@@ -103,7 +104,7 @@ class PsycopgSyncEventsBackend:
     backend_name = "notify"
 
     def __init__(self, config: "PsycopgSyncConfig") -> None:
-        if "psycopg" not in type(config).__module__:
+        if resolve_adapter_name(config) not in {"psycopg", "cockroach_psycopg"}:
             msg = "Psycopg events backend requires a Psycopg adapter"
             raise ImproperConfigurationError(msg)
         if config.is_async:
@@ -202,7 +203,7 @@ class PsycopgAsyncEventsBackend:
     backend_name = "notify"
 
     def __init__(self, config: "PsycopgAsyncConfig") -> None:
-        if "psycopg" not in type(config).__module__:
+        if resolve_adapter_name(config) not in {"psycopg", "cockroach_psycopg"}:
             msg = "Psycopg events backend requires a Psycopg adapter"
             raise ImproperConfigurationError(msg)
         if not config.is_async:
@@ -292,7 +293,7 @@ class PsycopgSyncHybridEventsBackend:
     backend_name = "notify_queue"
 
     def __init__(self, config: "PsycopgSyncConfig", queue: "SyncTableEventQueue") -> None:
-        if "psycopg" not in type(config).__module__:
+        if resolve_adapter_name(config) not in {"psycopg", "cockroach_psycopg"}:
             msg = "Psycopg hybrid backend requires a Psycopg adapter"
             raise ImproperConfigurationError(msg)
         if config.is_async:
@@ -473,7 +474,7 @@ class PsycopgAsyncHybridEventsBackend:
     backend_name = "notify_queue"
 
     def __init__(self, config: "PsycopgAsyncConfig", queue: "AsyncTableEventQueue") -> None:
-        if "psycopg" not in type(config).__module__:
+        if resolve_adapter_name(config) not in {"psycopg", "cockroach_psycopg"}:
             msg = "Psycopg hybrid backend requires a Psycopg adapter"
             raise ImproperConfigurationError(msg)
         if not config.is_async:

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/cli.py

@@ -20,7 +20,6 @@ from sqlspec.migrations import commands as migration_commands_module
 from sqlspec.migrations.squash import parse_version_range
 from sqlspec.utils.config_tools import discover_config_from_pyproject, resolve_config_sync
 from sqlspec.utils.logging import get_logger
-from sqlspec.utils.module_loader import import_string
 from sqlspec.utils.sync_tools import run_
 
 if TYPE_CHECKING:
@@ -238,19 +237,14 @@ def add_migration_commands(database_group: "Group | None" = None) -> "Group":
     def _get_memory_store_class(
         config: "AnyDatabaseConfig",
     ) -> "type[BaseAsyncADKMemoryStore[Any] | BaseSyncADKMemoryStore[Any]] | None":
-        config_module = type(config).__module__
-        config_name = type(config).__name__
-
-        if not config_module.startswith("sqlspec.adapters."):
-            return None
-
-        adapter_name = config_module.split(".")[2]
-        store_class_name = config_name.replace("Config", "ADKMemoryStore")
-        store_path = f"sqlspec.adapters.{adapter_name}.adk.store.{store_class_name}"
+        from sqlspec.extensions.adk._config_utils import _adk_memory_migration_store_class
 
         try:
-            return cast("type[BaseAsyncADKMemoryStore[Any] | BaseSyncADKMemoryStore[Any]]", import_string(store_path))
-        except ImportError:
+            return cast(
+                "type[BaseAsyncADKMemoryStore[Any] | BaseSyncADKMemoryStore[Any]] | None",
+                _adk_memory_migration_store_class(config),
+            )
+        except Exception:
             return None
 
     def _is_adk_memory_enabled(config: "AnyDatabaseConfig") -> bool:

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/config.py

@@ -858,6 +858,11 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
     type_coercion_capabilities: "ClassVar[TypeCoercionCapabilities]" = TypeCoercionCapabilities(
         datetime_binding="native", timestamp_precision="microsecond", json_columns_decoded=False, uuid_binding="native"
     )
+    adapter_name: "ClassVar[str | None]" = None
+    events_store_class: "ClassVar[type[Any] | None]" = None
+    adk_store_class: "ClassVar[type[Any] | None]" = None
+    adk_memory_store_class: "ClassVar[type[Any] | None]" = None
+    litestar_store_class: "ClassVar[type[Any] | None]" = None
     bind_key: "str | None"
     statement_config: "StatementConfig"
     connection_config: "dict[str, Any]"

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/adk/_config_utils.py

@@ -6,6 +6,7 @@ from typing import Any, NoReturn, NotRequired, Protocol, cast
 from typing_extensions import TypedDict
 
 from sqlspec.exceptions import ImproperConfigurationError, SQLSpecError
+from sqlspec.utils.adapters import resolve_adapter_name, resolve_extension_store_class
 from sqlspec.utils.module_loader import import_string
 
 __all__ = (
@@ -130,11 +131,11 @@ def _adk_store_path(config: Any, store_suffix: str) -> str:
     config_class = type(config)
     config_module = config_class.__module__
     config_name = config_class.__name__
+    adapter_name = resolve_adapter_name(config)
 
-    if not config_module.startswith("sqlspec.adapters."):
+    if adapter_name is None:
         _raise_unsupported_config(f"{config_module}.{config_name}")
 
-    adapter_name = config_module.split(".")[2]
     store_class_name = config_name.replace("Config", store_suffix)
     return f"sqlspec.adapters.{adapter_name}.adk.{store_class_name}"
 
@@ -142,6 +143,13 @@ def _adk_store_path(config: Any, store_suffix: str) -> str:
 def _adk_adapter_store_class(config: Any, store_suffix: str) -> Any:
     """Import an adapter-specific ADK store class for a config."""
 
+    store_attr = "adk_memory_store_class" if store_suffix == "ADKMemoryStore" else "adk_store_class"
+    explicit_store = getattr(config, store_attr, None)
+    if not isinstance(explicit_store, type):
+        explicit_store = getattr(type(config), store_attr, None)
+    if isinstance(explicit_store, type):
+        return explicit_store
+
     store_path = _adk_store_path(config, store_suffix)
     try:
         return import_string(store_path)
@@ -155,6 +163,12 @@ def _adk_adapter_store_class(config: Any, store_suffix: str) -> Any:
 def _adk_memory_migration_store_class(config: Any) -> Any | None:
     """Import the ADK memory store class when the adapter provides one."""
 
+    explicit_store = getattr(config, "adk_memory_store_class", None)
+    if not isinstance(explicit_store, type):
+        explicit_store = getattr(type(config), "adk_memory_store_class", None)
+    if isinstance(explicit_store, type):
+        return explicit_store
+
     store_path = _adk_store_path(config, "ADKMemoryStore")
     try:
         return import_string(store_path)
@@ -163,23 +177,35 @@ def _adk_memory_migration_store_class(config: Any) -> Any | None:
 
 
 def _adk_exported_store_class(config: Any, store_suffix: str) -> Any | None:
-    """Return an ADK store export that matches a config name case-insensitively."""
+    """Return an ADK store export that matches a config name or sync/async mode."""
 
-    config_class = type(config)
-    config_module = config_class.__module__
-    config_name = config_class.__name__
-    if not config_module.startswith("sqlspec.adapters."):
+    store_attr = "adk_memory_store_class" if store_suffix == "ADKMemoryStore" else "adk_store_class"
+    try:
+        resolved = resolve_extension_store_class(
+            config, extension="adk", store_attr=store_attr, store_suffix=store_suffix
+        )
+    except ImportError:
+        resolved = None
+    if resolved is not None:
+        return resolved
+
+    adapter_name = resolve_adapter_name(config)
+    if adapter_name is None:
         return None
 
-    adapter_name = config_module.split(".")[2]
     module_path = f"sqlspec.adapters.{adapter_name}.adk"
     try:
         module = importlib.import_module(module_path)
     except ImportError:
         return None
 
+    config_name = type(config).__name__
     expected_prefix = config_name.removesuffix("Config").lower()
-    store_names = tuple(name for name in getattr(module, "__all__", ()) if name.endswith(store_suffix))
+    store_names = tuple(
+        name
+        for name in getattr(module, "__all__", ())
+        if name.endswith(store_suffix) and not (store_suffix == "ADKStore" and name.endswith("ADKMemoryStore"))
+    )
 
     for store_name in store_names:
         if store_name[: -len(store_suffix)].lower() == expected_prefix:
@@ -221,11 +247,16 @@ def _validate_adk_extension_config(config: _ADKConfigSource, settings: dict[str,
     """Reject ADK options that the selected adapter cannot honor."""
     from sqlspec.config import ADKConfig
 
-    config_module = type(config).__module__
-    if not config_module.startswith("sqlspec.adapters."):
+    adapter_name = resolve_adapter_name(config)
+    if adapter_name is None:
+        return
+    module_name = f"sqlspec.adapters.{adapter_name}.adk.store"
+    try:
+        store_module = importlib.import_module(module_name)
+    except ModuleNotFoundError as error:
+        if error.name not in {module_name, module_name.rsplit(".", 1)[0], f"sqlspec.adapters.{adapter_name}"}:
+            raise
         return
-    adapter_name = config_module.split(".")[2]
-    store_module = importlib.import_module(f"sqlspec.adapters.{adapter_name}.adk.store")
     accepted = set(ADKConfig.__required_keys__) | set(ADKConfig.__optional_keys__)
     for exported_name in getattr(store_module, "__all__", ()):
         if not exported_name.endswith("ADKConfig"):

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/adk/memory/store.py

@@ -47,6 +47,7 @@ class _ADKMemoryStoreCommon(Generic[ConfigT]):
     )
 
     _max_table_name_parts: ClassVar[int] = 1
+    adapter_name: ClassVar[str | None] = None
 
     def __init__(self, config: ConfigT) -> None:
         """Initialize the ADK memory store.

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/adk/migrations/0002_create_mssql_python_memory.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.extensions.adk._config_utils import _adk_memory_migration_enabled
+from sqlspec.utils.adapters import resolve_adapter_name
 
 if TYPE_CHECKING:
     from sqlspec.migrations.context import MigrationContext
@@ -23,7 +24,7 @@ async def up(context: "MigrationContext | None" = None) -> list[str]:
     config = context.config
     if not _adk_memory_migration_enabled(config):
         return []
-    if not any(cls.__module__.startswith("sqlspec.adapters.mssql_python.") for cls in type(config).__mro__):
+    if resolve_adapter_name(config) != "mssql_python":
         return []
 
     from sqlspec.adapters.mssql_python.adk.store import MssqlPythonADKMemoryStore, _create_index_sql, _table_ref

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/adk/store.py

@@ -48,6 +48,7 @@ class _ADKStoreCommon(Generic[ConfigT]):
     )
 
     _max_table_name_parts: ClassVar[int] = 1
+    adapter_name: ClassVar[str | None] = None
 
     def __init__(self, config: ConfigT) -> None:
         """Initialize the ADK store.

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/events/_channel.py

@@ -853,7 +853,7 @@ def _resolve_event_backend(
     Returns:
         Tuple of resolved backend and backend label.
     """
-    _validate_adapter_event_settings(extension_settings, adapter_name)
+    _validate_adapter_event_settings(extension_settings, adapter_name, config=config)
     queue_backend = build_queue_backend(config, extension_settings, adapter_name=adapter_name, hints=hints)
     backend_name = _resolve_backend_name(config, extension_settings, adapter_name)
     native_backend = load_native_backend(config, backend_name, extension_settings, adapter_name=adapter_name)
@@ -874,30 +874,41 @@ def _resolve_event_backend(
     return native_backend, backend_name or "poll_queue"
 
 
-def _validate_adapter_event_settings(settings: "dict[str, Any]", adapter_name: "str | None") -> None:
+def _validate_adapter_event_settings(
+    settings: "dict[str, Any]", adapter_name: "str | None", *, config: Any = None
+) -> None:
     """Apply the adapter store's accepted keys to native and polling channels."""
-    if adapter_name is None:
-        return
-    module_name = f"sqlspec.adapters.{adapter_name}.events.store"
-    try:
-        module = importlib.import_module(module_name)
-    except ModuleNotFoundError as error:
-        if error.name not in {module_name, module_name.rsplit(".", 1)[0]}:
-            raise
-        return
-    allowed = BaseEventQueueStore.extension_config_options
-    for name in getattr(module, "__all__", ()):
-        store_type = cast("type[BaseEventQueueStore[Any]]", getattr(module, name))
-        if (
-            isinstance(store_type, type)
-            and issubclass(store_type, BaseEventQueueStore)
-            and store_type.__module__ == module_name
-        ):
-            allowed = allowed | store_type.extension_config_options
+    explicit_store = getattr(config, "events_store_class", None) if config is not None else None
+    if not isinstance(explicit_store, type) and config is not None:
+        explicit_store = getattr(type(config), "events_store_class", None)
+    if isinstance(explicit_store, type) and issubclass(explicit_store, BaseEventQueueStore):
+        store_options = cast("frozenset[str]", getattr(explicit_store, "extension_config_options", frozenset()))
+        allowed = BaseEventQueueStore.extension_config_options | store_options
+        target_label = adapter_name or resolve_adapter_name(explicit_store) or explicit_store.__name__
+    else:
+        if adapter_name is None:
+            return
+        module_name = f"sqlspec.adapters.{adapter_name}.events.store"
+        try:
+            module = importlib.import_module(module_name)
+        except ModuleNotFoundError as error:
+            if error.name not in {module_name, module_name.rsplit(".", 1)[0], f"sqlspec.adapters.{adapter_name}"}:
+                raise
+            return
+        allowed = BaseEventQueueStore.extension_config_options
+        for name in getattr(module, "__all__", ()):
+            store_type = cast("type[BaseEventQueueStore[Any]]", getattr(module, name))
+            if (
+                isinstance(store_type, type)
+                and issubclass(store_type, BaseEventQueueStore)
+                and resolve_adapter_name(store_type) == adapter_name
+            ):
+                allowed = allowed | store_type.extension_config_options
+        target_label = adapter_name
     unsupported = sorted(set(settings).difference(allowed))
     if unsupported:
         keys = ", ".join(repr(key) for key in unsupported)
-        msg = f"Unsupported events configuration key(s) for {adapter_name}: {keys}"
+        msg = f"Unsupported events configuration key(s) for {target_label}: {keys}"
         raise ImproperConfigurationError(msg)
 
 

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/events/_hints.py

@@ -3,9 +3,9 @@
 from dataclasses import dataclass
 from typing import Any, Final, final
 
-__all__ = ("EventRuntimeHints", "get_runtime_hints", "resolve_adapter_name")
+from sqlspec.utils.adapters import resolve_adapter_name
 
-_ADAPTER_MODULE_PARTS = 3
+__all__ = ("EventRuntimeHints", "get_runtime_hints", "resolve_adapter_name")
 
 
 @final
@@ -36,12 +36,3 @@ def get_runtime_hints(adapter: "str | None", config: "Any" = None) -> "EventRunt
     if isinstance(hints, EventRuntimeHints):
         return hints
     return _DEFAULT_HINTS
-
-
-def resolve_adapter_name(config: Any) -> "str | None":
-    """Resolve adapter name from config module path."""
-    module_name = type(config).__module__
-    parts = module_name.split(".")
-    if len(parts) >= _ADAPTER_MODULE_PARTS and parts[0] == "sqlspec" and parts[1] == "adapters":
-        return parts[2]
-    return None

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/events/_store.py

@@ -7,6 +7,7 @@ from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events._buffer import validate_queue_capacity
 from sqlspec.extensions.events._names import normalize_event_channel_name, normalize_queue_table_name
 from sqlspec.migrations.schema import SchemaEnsureResult, SchemaTarget
+from sqlspec.utils.adapters import resolve_adapter_name
 
 if TYPE_CHECKING:
     from sqlspec.config import DatabaseConfigProtocol
@@ -35,6 +36,8 @@ class BaseEventQueueStore(ABC, Generic[ConfigT]):
 
     __slots__ = ("_config", "_extension_settings", "_table_name")
 
+    adapter_name: ClassVar[str | None] = None
+
     extension_config_options: ClassVar[frozenset[str]] = frozenset({
         "backend",
         "cleanup_on_ack",
@@ -117,7 +120,7 @@ class BaseEventQueueStore(ABC, Generic[ConfigT]):
         """Reject events options that this adapter store cannot honor."""
         unsupported = sorted(set(self._extension_settings).difference(type(self).extension_config_options))
         if unsupported:
-            adapter = type(self).__module__.split(".")[2]
+            adapter = resolve_adapter_name(self) or type(self).__name__
             keys = ", ".join(repr(key) for key in unsupported)
             msg = f"Unsupported events configuration key(s) for {adapter}: {keys}"
             raise ImproperConfigurationError(msg)

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/events/migrations/0001_create_event_queue.py

@@ -5,8 +5,8 @@ import logging
 from typing import TYPE_CHECKING, Any, Final
 
 from sqlspec.exceptions import SQLSpecError
+from sqlspec.utils.adapters import resolve_adapter_name, resolve_extension_store_class
 from sqlspec.utils.logging import get_logger, log_with_context
-from sqlspec.utils.module_loader import import_string
 
 if TYPE_CHECKING:
     from sqlspec.extensions.events._store import BaseEventQueueStore
@@ -82,18 +82,23 @@ def _load_store(context: "MigrationContext | None") -> "BaseEventQueueStore[Any]
         raise SQLSpecError(msg)
     config = context.config
     config_class = type(config)
-    module_path = config_class.__module__
-    if not module_path.startswith("sqlspec.adapters."):
-        msg = f"Unsupported configuration for events extension: {module_path}.{config_class.__name__}"
-        raise SQLSpecError(msg)
-    adapter_name = module_path.split(".")[2]
-    store_class_name = config_class.__name__.replace("Config", "EventQueueStore")
-    store_path = f"sqlspec.adapters.{adapter_name}.events.store.{store_class_name}"
     try:
-        store_class = import_string(store_path)
+        store_class = resolve_extension_store_class(
+            config, extension="events", store_attr="events_store_class", store_suffix="EventQueueStore"
+        )
     except ImportError as error:  # pragma: no cover
+        adapter_name = resolve_adapter_name(config) or config_class.__name__
+        store_class_name = config_class.__name__.replace("Config", "EventQueueStore")
         msg = f"Adapter {adapter_name} missing events store {store_class_name}"
         raise SQLSpecError(msg) from error
+    if store_class is None:
+        target_adapter = resolve_adapter_name(config)
+        if target_adapter is None:
+            msg = f"Unsupported configuration for events extension: {config_class.__module__}.{config_class.__name__}"
+            raise SQLSpecError(msg)
+        store_class_name = config_class.__name__.replace("Config", "EventQueueStore")
+        msg = f"Adapter {target_adapter} missing events store {store_class_name}"
+        raise SQLSpecError(msg)
     try:
         store: BaseEventQueueStore[Any] = store_class(config)
     except ValueError as error:  # pragma: no cover

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/litestar/migrations/0001_create_session_table.py

@@ -3,8 +3,8 @@
 from typing import TYPE_CHECKING, NoReturn
 
 from sqlspec.exceptions import SQLSpecError
+from sqlspec.utils.adapters import resolve_adapter_name, resolve_extension_store_class
 from sqlspec.utils.logging import get_logger
-from sqlspec.utils.module_loader import import_string
 
 if TYPE_CHECKING:
     from sqlspec.extensions.litestar.store import BaseSQLSpecStore
@@ -63,7 +63,7 @@ async def down(context: "MigrationContext | None" = None) -> "list[str]":
 
 
 def _get_store_class(context: "MigrationContext | None") -> "type[BaseSQLSpecStore]":
-    """Get the appropriate store class based on the config's module path.
+    """Get the appropriate store class for the migration context configuration.
 
     Args:
         context: Migration context containing config.
@@ -74,23 +74,30 @@ def _get_store_class(context: "MigrationContext | None") -> "type[BaseSQLSpecSto
     if not context or not context.config:
         _raise_missing_config()
 
-    config_class = type(context.config)
+    config = context.config
+    config_class = type(config)
     config_module = config_class.__module__
     config_name = config_class.__name__
-
-    if not config_module.startswith("sqlspec.adapters."):
-        _raise_unsupported_config(f"{config_module}.{config_name}")
-
-    adapter_name = config_module.split(".")[2]
+    adapter_name = resolve_adapter_name(config)
     store_class_name = config_name.replace("Config", "Store")
-
-    store_path = f"sqlspec.adapters.{adapter_name}.litestar.store.{store_class_name}"
+    store_path = (
+        f"sqlspec.adapters.{adapter_name}.litestar.store.{store_class_name}"
+        if adapter_name is not None
+        else f"{config_module}.{store_class_name}"
+    )
 
     try:
-        store_class: type[BaseSQLSpecStore] = import_string(store_path)
+        store_class = resolve_extension_store_class(
+            config, extension="litestar", store_attr="litestar_store_class", store_suffix="Store"
+        )
     except ImportError as e:
         _raise_store_import_failed(store_path, e)
 
+    if store_class is None:
+        if adapter_name is None:
+            _raise_unsupported_config(f"{config_module}.{config_name}")
+        _raise_store_import_failed(store_path, ImportError(store_class_name))
+
     return store_class
 
 

{sqlspec-0.70.0 → sqlspec-0.70.1}/sqlspec/extensions/litestar/store.py

@@ -10,6 +10,7 @@ from litestar.stores.base import Store
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.migrations.schema import SchemaTarget, ensure_schema_async, ensure_schema_sync
 from sqlspec.observability import resolve_db_system
+from sqlspec.utils.adapters import resolve_adapter_name
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.sync_tools import async_
 from sqlspec.utils.type_guards import has_extension_config
@@ -47,6 +48,8 @@ class BaseSQLSpecStore(Store, Generic[ConfigT]):
 
     __slots__ = ("_config", "_table_name")
 
+    adapter_name: ClassVar[str | None] = None
+
     extension_config_options: ClassVar[frozenset[str]] = frozenset({
         "auto_trace_headers",
         "commit_mode",
@@ -157,7 +160,7 @@ class BaseSQLSpecStore(Store, Generic[ConfigT]):
         settings = extension_config.get("litestar", {})
         unsupported = sorted(set(settings).difference(type(self).extension_config_options))
         if unsupported:
-            adapter = type(self).__module__.split(".")[2]
+            adapter = resolve_adapter_name(self) or type(self).__name__
             keys = ", ".join(repr(key) for key in unsupported)
             msg = f"Unsupported Litestar configuration key(s) for {adapter}: {keys}"
             raise ImproperConfigurationError(msg)