feat: async migrations and callable config support (#87)

Implements async migration support and callable config functions as outlined in
  the async migrations enhancement plan. This enables Python migrations to use
  `async def up/down` functions and allows the CLI to accept callable configuration
  functions.

Async Migration Support
  - Enhanced `MigrationRunner` to seamlessly handle both sync and async migrations
  - Added `MigrationContext` with async execution awareness and metadata tracking
  - Removed redundant async methods, unified the API around main methods that
  auto-detect driver types

Callable Config Support
  - Added `config_resolver.py` to resolve both direct config instances and callable
  functions
  - Enhanced CLI to support sync/async callable config functions

 CLI Usage:

  ```bash
  # Existing patterns (still supported)
  sqlspec --config myapp.config.database_configs upgrade head

  # New callable config support
  sqlspec --config myapp.config.get_database_configs upgrade head
  sqlspec --config myapp.config.async_get_database_configs upgrade head
```

Author: cofin

sqlspec/adapters/asyncmy/_types.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from asyncmy import Connection
+from asyncmy import Connection  # pyright: ignore
 
 if TYPE_CHECKING:
     from typing_extensions import TypeAlias

sqlspec/adapters/asyncmy/config.py

@@ -6,17 +6,17 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypedDict, Union
 
 import asyncmy
-from asyncmy.cursors import Cursor, DictCursor
-from asyncmy.pool import Pool as AsyncmyPool
+from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
+from asyncmy.pool import Pool as AsyncmyPool  # pyright: ignore
 from typing_extensions import NotRequired
 
 from sqlspec.adapters.asyncmy._types import AsyncmyConnection
 from sqlspec.adapters.asyncmy.driver import AsyncmyCursor, AsyncmyDriver, asyncmy_statement_config
 from sqlspec.config import AsyncDatabaseConfig
 
 if TYPE_CHECKING:
-    from asyncmy.cursors import Cursor, DictCursor
-    from asyncmy.pool import Pool
+    from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
+    from asyncmy.pool import Pool  # pyright: ignore
 
     from sqlspec.core.statement import StatementConfig
 
@@ -57,7 +57,7 @@ class AsyncmyPoolParams(AsyncmyConnectionParams, total=False):
     pool_recycle: NotRequired[int]
 
 
-class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver]):  # pyright: ignore
+class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "AsyncmyPool", AsyncmyDriver]):  # pyright: ignore
     """Configuration for Asyncmy database connections."""
 
     driver_type: ClassVar[type[AsyncmyDriver]] = AsyncmyDriver
@@ -67,7 +67,7 @@ def __init__(
         self,
         *,
         pool_config: "Optional[Union[AsyncmyPoolParams, dict[str, Any]]]" = None,
-        pool_instance: "Optional[Pool]" = None,
+        pool_instance: "Optional[AsyncmyPool]" = None,
         migration_config: Optional[dict[str, Any]] = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
@@ -102,9 +102,9 @@ def __init__(
             driver_features=driver_features or {},
         )
 
-    async def _create_pool(self) -> "Pool":  # pyright: ignore
+    async def _create_pool(self) -> "AsyncmyPool":  # pyright: ignore
         """Create the actual async connection pool."""
-        return await asyncmy.create_pool(**dict(self.pool_config))
+        return await asyncmy.create_pool(**dict(self.pool_config))  # pyright: ignore
 
     async def _close_pool(self) -> None:
         """Close the actual async connection pool."""

sqlspec/adapters/sqlite/pool.py

@@ -1,5 +1,6 @@
 """SQLite database configuration with thread-local connections."""
 
+import contextlib
 import sqlite3
 import threading
 from contextlib import contextmanager
@@ -49,6 +50,8 @@ def __init__(
             enable_optimizations: Whether to apply performance PRAGMAs
             **kwargs: Ignored pool parameters for compatibility
         """
+        if "check_same_thread" not in connection_parameters:
+            connection_parameters = {**connection_parameters, "check_same_thread": False}
         self._connection_parameters = connection_parameters
         self._thread_local = threading.local()
         self._enable_optimizations = enable_optimizations
@@ -62,8 +65,7 @@ def _create_connection(self) -> SqliteConnection:
             is_memory = database == ":memory:" or database.startswith("file::memory:")
 
             if not is_memory:
-                connection.execute("PRAGMA journal_mode = WAL")
-
+                connection.execute("PRAGMA journal_mode = DELETE")
                 connection.execute("PRAGMA busy_timeout = 5000")
                 connection.execute("PRAGMA optimize")
 
@@ -97,7 +99,13 @@ def get_connection(self) -> "Generator[SqliteConnection, None, None]":
         Yields:
             SqliteConnection: A thread-local connection.
         """
-        yield self._get_thread_connection()
+        connection = self._get_thread_connection()
+        try:
+            yield connection
+        finally:
+            with contextlib.suppress(Exception):
+                if connection.in_transaction:
+                    connection.commit()
 
     def close(self) -> None:
         """Close the thread-local connection if it exists."""
@@ -124,7 +132,8 @@ def size(self) -> int:
             _ = self._thread_local.connection
         except AttributeError:
             return 0
-        return 1
+        else:
+            return 1
 
     def checked_out(self) -> int:
         """Get number of checked out connections (always 0)."""