skrift 0.1.0a16__tar.gz → 0.1.0a17__tar.gz

{skrift-0.1.0a16 → skrift-0.1.0a17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skrift
-Version: 0.1.0a16
+Version: 0.1.0a17
 Summary: A lightweight async Python CMS for crafting modern websites
 Requires-Python: >=3.13
 Requires-Dist: advanced-alchemy>=0.26.0

{skrift-0.1.0a16 → skrift-0.1.0a17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "skrift"
-version = "0.1.0a16"
+version = "0.1.0a17"
 description = "A lightweight async Python CMS for crafting modern websites"
 readme = "README.md"
 requires-python = ">=3.13"

{skrift-0.1.0a16 → skrift-0.1.0a17}/skrift/asgi.py

@@ -22,6 +22,8 @@ from advanced_alchemy.extensions.litestar import (
     SQLAlchemyAsyncConfig,
     SQLAlchemyPlugin,
 )
+
+from skrift.db.session import SafeSQLAlchemyAsyncConfig
 from litestar import Litestar
 from litestar.config.compression import CompressionConfig
 from litestar.contrib.jinja import JinjaTemplateEngine
@@ -398,10 +400,11 @@ def create_app() -> Litestar:
             pool_size=settings.db.pool_size,
             max_overflow=settings.db.pool_overflow,
             pool_timeout=settings.db.pool_timeout,
+            pool_pre_ping=settings.db.pool_pre_ping,
             echo=settings.db.echo,
         )
 
-    db_config = SQLAlchemyAsyncConfig(
+    db_config = SafeSQLAlchemyAsyncConfig(
         connection_string=settings.db.url,
         metadata=Base.metadata,
         create_all=False,
@@ -564,10 +567,11 @@ def create_setup_app() -> Litestar:
                 pool_size=5,
                 max_overflow=10,
                 pool_timeout=30,
+                pool_pre_ping=True,
                 echo=False,
             )
 
-        db_config = SQLAlchemyAsyncConfig(
+        db_config = SafeSQLAlchemyAsyncConfig(
             connection_string=db_url,
             metadata=Base.metadata,
             create_all=False,

{skrift-0.1.0a16 → skrift-0.1.0a17}/skrift/config.py

@@ -110,6 +110,7 @@ class DatabaseConfig(BaseModel):
     pool_size: int = 5
     pool_overflow: int = 10
     pool_timeout: int = 30
+    pool_pre_ping: bool = True  # Validate connections before use
     echo: bool = False
 
 

skrift-0.1.0a17/skrift/db/session.py

@@ -0,0 +1,90 @@
+"""Safe SQLAlchemy async session provider with CancelledError handling.
+
+This module provides a custom session configuration that properly handles
+connection cleanup when HTTP requests are cancelled (client disconnect, timeout).
+Without this, CancelledError can prevent session cleanup, leading to connection
+pool leaks.
+"""
+
+import asyncio
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, Callable, cast
+
+from advanced_alchemy._listeners import set_async_context
+from advanced_alchemy.extensions.litestar import SQLAlchemyAsyncConfig
+from advanced_alchemy.extensions.litestar._utils import (
+    delete_aa_scope_state,
+    get_aa_scope_state,
+    set_aa_scope_state,
+)
+from sqlalchemy.ext.asyncio import AsyncSession
+
+if TYPE_CHECKING:
+    from litestar.datastructures import State
+    from litestar.types import Scope
+
+
+class SafeSQLAlchemyAsyncConfig(SQLAlchemyAsyncConfig):
+    """SQLAlchemy async config with safe session cleanup on request cancellation.
+
+    This subclass overrides `provide_session` to use an async generator that
+    catches CancelledError and ensures sessions are properly closed, preventing
+    connection pool leaks when HTTP requests are cancelled.
+
+    The standard advanced_alchemy session management relies on ASGI events
+    (http.response.body, http.disconnect) to trigger cleanup via before_send_handler.
+    However, CancelledError can prevent these events from firing, leaving sessions
+    in an unclosed state.
+
+    By using an async generator, Litestar's dependency injection system ensures
+    cleanup runs even when CancelledError is raised.
+    """
+
+    async def provide_session(
+        self,
+        state: "State",
+        scope: "Scope",
+    ) -> AsyncGenerator[AsyncSession, None]:
+        """Provide a database session with proper cleanup on cancellation.
+
+        This async generator wraps session creation to ensure that
+        CancelledError (raised when an HTTP request is cancelled) doesn't
+        prevent session cleanup, which would leak connections.
+
+        Args:
+            state: The application state
+            scope: The ASGI scope
+
+        Yields:
+            AsyncSession: The database session
+        """
+        # Check if we already have a session in scope
+        session = cast(
+            "AsyncSession | None",
+            get_aa_scope_state(scope, self.session_scope_key),
+        )
+
+        if session is None:
+            # Create a new session
+            session_maker = cast(
+                "Callable[[], AsyncSession]",
+                state[self.session_maker_app_state_key],
+            )
+            session = session_maker()
+            # Store in scope for reuse within this request
+            set_aa_scope_state(scope, self.session_scope_key, session)
+
+        set_async_context(True)
+
+        try:
+            yield session
+        except asyncio.CancelledError:
+            # Request was cancelled - ensure we clean up the session
+            # This prevents connection pool leaks
+            await session.close()
+            # Remove the session from scope state to prevent double-close
+            delete_aa_scope_state(scope, self.session_scope_key)
+            raise
+
+
+__all__ = ["SafeSQLAlchemyAsyncConfig"]

{skrift-0.1.0a16 → skrift-0.1.0a17}/skrift/setup/config_writer.py

@@ -21,6 +21,7 @@ DEFAULT_CONFIG = {
         "pool_size": 5,
         "pool_overflow": 10,
         "pool_timeout": 30,
+        "pool_pre_ping": True,
         "echo": False,
     },
     "auth": {

{skrift-0.1.0a16 → skrift-0.1.0a17}/skrift/setup/state.py

@@ -172,9 +172,9 @@ def run_migrations_if_needed() -> tuple[bool, str | None]:
         return True, None
 
     try:
-        # Try skrift-db first
+        # Try skrift db first (the correct command)
         result = subprocess.run(
-            ["skrift-db", "upgrade", "head"],
+            ["skrift", "db", "upgrade", "head"],
             capture_output=True,
             text=True,
             cwd=Path.cwd(),
@@ -183,7 +183,7 @@ def run_migrations_if_needed() -> tuple[bool, str | None]:
         if result.returncode == 0:
             _migrations_run = True
             return True, None
-        # If skrift-db fails, try alembic directly
+        # If skrift db fails, try alembic directly
     except (subprocess.TimeoutExpired, FileNotFoundError):
         pass
 
@@ -202,7 +202,7 @@ def run_migrations_if_needed() -> tuple[bool, str | None]:
     except subprocess.TimeoutExpired:
         return False, "Migration timed out"
     except FileNotFoundError:
-        return False, "Neither skrift-db nor alembic found"
+        return False, "skrift db command not found"
     except Exception as e:
         return False, str(e)