skrift 0.1.0a9__tar.gz → 0.1.0a11__tar.gz

{skrift-0.1.0a9 → skrift-0.1.0a11}/PKG-INFO

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

{skrift-0.1.0a9 → skrift-0.1.0a11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "skrift"
-version = "0.1.0a9"
+version = "0.1.0a11"
 description = "A lightweight async Python CMS for crafting modern websites"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -30,6 +30,10 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+]
 docs = [
     "zensical>=0.0.19",
 ]

{skrift-0.1.0a9 → skrift-0.1.0a11}/skrift/asgi.py

@@ -26,6 +26,7 @@ from litestar import Litestar
 from litestar.config.compression import CompressionConfig
 from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar.exceptions import HTTPException
+from litestar.middleware import DefineMiddleware
 from litestar.middleware.session.client_side import CookieBackendConfig
 from litestar.static_files import create_static_files_router
 from litestar.template import TemplateConfig
@@ -73,6 +74,109 @@ def load_controllers() -> list:
     return controllers
 
 
+def _load_middleware_factory(spec: str):
+    """Import a single middleware factory from a module:name spec.
+
+    Args:
+        spec: String in format "module.path:factory_name"
+
+    Returns:
+        The callable middleware factory
+
+    Raises:
+        ValueError: If spec doesn't contain exactly one colon
+        ImportError: If the module cannot be imported
+        AttributeError: If the factory doesn't exist in the module
+        TypeError: If the factory is not callable
+    """
+    if ":" not in spec:
+        raise ValueError(
+            f"Invalid middleware spec '{spec}': must be in format 'module:factory'"
+        )
+
+    parts = spec.split(":")
+    if len(parts) != 2:
+        raise ValueError(
+            f"Invalid middleware spec '{spec}': must contain exactly one colon"
+        )
+
+    module_path, factory_name = parts
+    module = importlib.import_module(module_path)
+    factory = getattr(module, factory_name)
+
+    if not callable(factory):
+        raise TypeError(
+            f"Middleware factory '{spec}' is not callable"
+        )
+
+    return factory
+
+
+def load_middleware() -> list:
+    """Load middleware from app.yaml configuration.
+
+    Supports two formats in app.yaml:
+
+    Simple (no args):
+        middleware:
+          - myapp.middleware:create_logging_middleware
+
+    With kwargs:
+        middleware:
+          - factory: myapp.middleware:create_rate_limit_middleware
+            kwargs:
+              requests_per_minute: 100
+
+    Returns:
+        List of middleware factories or DefineMiddleware instances
+    """
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        return []
+
+    with open(config_path, "r") as f:
+        config = yaml.safe_load(f)
+
+    if not config:
+        return []
+
+    middleware_specs = config.get("middleware", [])
+    if not middleware_specs:
+        return []
+
+    # Add working directory to sys.path for local middleware imports
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+    middleware = []
+    for spec in middleware_specs:
+        if isinstance(spec, str):
+            # Simple format: "module:factory"
+            factory = _load_middleware_factory(spec)
+            middleware.append(factory)
+        elif isinstance(spec, dict):
+            # Dict format with optional kwargs
+            if "factory" not in spec:
+                raise ValueError(
+                    f"Middleware dict spec must have 'factory' key: {spec}"
+                )
+            factory = _load_middleware_factory(spec["factory"])
+            kwargs = spec.get("kwargs", {})
+            if kwargs:
+                middleware.append(DefineMiddleware(factory, **kwargs))
+            else:
+                middleware.append(factory)
+        else:
+            raise ValueError(
+                f"Invalid middleware spec type: {type(spec).__name__}. "
+                "Must be string or dict."
+            )
+
+    return middleware
+
+
 async def check_setup_complete(db_config: SQLAlchemyAsyncConfig) -> bool:
     """Check if setup has been completed."""
     try:
@@ -282,6 +386,9 @@ def create_app() -> Litestar:
     # Load controllers from app.yaml
     controllers = load_controllers()
 
+    # Load middleware from app.yaml
+    user_middleware = load_middleware()
+
     # Database configuration
     if "sqlite" in settings.db.url:
         engine_config = EngineConfig(echo=settings.db.echo)
@@ -350,7 +457,7 @@ def create_app() -> Litestar:
         on_startup=[on_startup],
         route_handlers=[*controllers, static_files_router],
         plugins=[SQLAlchemyPlugin(config=db_config)],
-        middleware=[session_config.middleware],
+        middleware=[session_config.middleware, *user_middleware],
         template_config=template_config,
         compression_config=CompressionConfig(backend="gzip"),
         exception_handlers={

{skrift-0.1.0a9 → skrift-0.1.0a11}/skrift/config.py

@@ -137,6 +137,7 @@ class AuthConfig(BaseModel):
     """Authentication configuration."""
 
     redirect_base_url: str = "http://localhost:8000"
+    allowed_redirect_domains: list[str] = []
     providers: dict[str, ProviderConfig] = {}
 
     @classmethod

{skrift-0.1.0a9 → skrift-0.1.0a11}/skrift/controllers/auth.py

@@ -5,11 +5,12 @@ Also supports a development-only "dummy" provider for testing.
 """
 
 import base64
+import fnmatch
 import hashlib
 import secrets
 from datetime import UTC, datetime
 from typing import Annotated
-from urllib.parse import urlencode
+from urllib.parse import urlencode, urlparse
 
 import httpx
 from litestar import Controller, Request, get, post
@@ -26,6 +27,56 @@ from skrift.db.models.user import User
 from skrift.setup.providers import DUMMY_PROVIDER_KEY, OAUTH_PROVIDERS, get_provider_info
 
 
+def _is_safe_redirect_url(url: str, allowed_domains: list[str]) -> bool:
+    """Check if URL is safe to redirect to.
+
+    Supports wildcard patterns using fnmatch-style matching:
+    - "*.example.com" matches any subdomain of example.com
+    - "app-*.example.com" matches app-foo.example.com, app-bar.example.com, etc.
+    - "example.com" (no wildcards) matches example.com and all subdomains
+    """
+    # Relative paths are always safe (but not protocol-relative //domain.com)
+    if url.startswith("/") and not url.startswith("//"):
+        return True
+
+    # Parse absolute URL
+    try:
+        parsed = urlparse(url)
+    except Exception:
+        return False
+
+    # Must have scheme and netloc
+    if not parsed.scheme or not parsed.netloc:
+        return False
+
+    # Only allow http/https
+    if parsed.scheme not in ("http", "https"):
+        return False
+
+    # Check if domain matches allowed list
+    host = parsed.netloc.lower().split(":")[0]  # Remove port
+    for pattern in allowed_domains:
+        pattern = pattern.lower()
+        # If pattern contains wildcards, use fnmatch
+        if "*" in pattern or "?" in pattern:
+            if fnmatch.fnmatch(host, pattern):
+                return True
+        else:
+            # No wildcards: exact match or subdomain match
+            if host == pattern or host.endswith(f".{pattern}"):
+                return True
+
+    return False
+
+
+def _get_safe_redirect_url(request: Request, allowed_domains: list[str], default: str = "/") -> str:
+    """Get the next redirect URL from session, validating it's safe."""
+    next_url = request.session.pop("auth_next", None)
+    if next_url and _is_safe_redirect_url(next_url, allowed_domains):
+        return next_url
+    return default
+
+
 def get_auth_url(provider: str, settings, state: str, code_challenge: str | None = None) -> str:
     """Build the OAuth authorization URL for a provider."""
     provider_info = get_provider_info(provider)
@@ -230,11 +281,16 @@ class AuthController(Controller):
         self,
         request: Request,
         provider: str,
+        next_url: Annotated[str | None, Parameter(query="next")] = None,
     ) -> Redirect | TemplateResponse:
         """Redirect to OAuth provider consent screen, or show dummy login form."""
         settings = get_settings()
         provider_info = get_provider_info(provider)
 
+        # Store next URL in session if provided and valid
+        if next_url and _is_safe_redirect_url(next_url, settings.auth.allowed_redirect_domains):
+            request.session["auth_next"] = next_url
+
         if not provider_info:
             raise NotFoundException(f"Unknown provider: {provider}")
 
@@ -392,14 +448,22 @@ class AuthController(Controller):
         request.session["user_picture_url"] = user.picture_url
         request.session["flash"] = "Successfully logged in!"
 
-        return Redirect(path="/")
+        return Redirect(path=_get_safe_redirect_url(request, settings.auth.allowed_redirect_domains))
 
     @get("/login")
-    async def login_page(self, request: Request) -> TemplateResponse:
+    async def login_page(
+        self,
+        request: Request,
+        next_url: Annotated[str | None, Parameter(query="next")] = None,
+    ) -> TemplateResponse:
         """Show login page with available providers."""
         flash = request.session.pop("flash", None)
         settings = get_settings()
 
+        # Store next URL in session if provided and valid
+        if next_url and _is_safe_redirect_url(next_url, settings.auth.allowed_redirect_domains):
+            request.session["auth_next"] = next_url
+
         # Get configured providers (excluding dummy from main list)
         configured_providers = list(settings.auth.providers.keys())
         providers = {
@@ -522,7 +586,7 @@ class AuthController(Controller):
         request.session["user_picture_url"] = user.picture_url
         request.session["flash"] = "Successfully logged in!"
 
-        return Redirect(path="/")
+        return Redirect(path=_get_safe_redirect_url(request, settings.auth.allowed_redirect_domains))
 
     @get("/logout")
     async def logout(self, request: Request) -> Redirect: