litestar-vite 0.15.0__py3-none-any.whl → 0.15.0rc2__py3-none-any.whl

litestar_vite/inertia/plugin.py

@@ -1,7 +1,6 @@
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
-import httpx
 from anyio.from_thread import start_blocking_portal
 from litestar.plugins import InitPluginProtocol
 
@@ -38,16 +37,6 @@ class InertiaPlugin(InitPluginProtocol):
         custom serialization), ensure the app lifespan is active and the
         portal is available via ``inertia_plugin.portal``.
 
-    SSR Client Pooling:
-        When SSR is enabled, the plugin maintains a shared ``httpx.AsyncClient``
-        for all SSR requests. This provides significant performance benefits:
-        - Connection pooling with keep-alive
-        - TLS session reuse
-        - HTTP/2 multiplexing (when available)
-
-        The client is initialized during app lifespan and properly closed on shutdown.
-        Access via ``inertia_plugin.ssr_client`` if needed.
-
     Example::
 
         from litestar_vite.inertia import InertiaPlugin, InertiaConfig
@@ -58,46 +47,26 @@ class InertiaPlugin(InitPluginProtocol):
         )
     """
 
-    __slots__ = ("_portal", "_ssr_client", "config")
+    __slots__ = ("_portal", "config")
 
     def __init__(self, config: "InertiaConfig") -> "None":
         """Initialize the plugin with Inertia configuration."""
         self.config = config
-        self._ssr_client: "httpx.AsyncClient | None" = None
-        self._portal: "BlockingPortal | None" = None  # pyright: ignore[reportInvalidTypeForm]
 
     @asynccontextmanager
     async def lifespan(self, app: "Litestar") -> "AsyncGenerator[None, None]":
         """Lifespan to ensure the event loop is available.
 
-        Initializes:
-        - BlockingPortal for sync-to-async DeferredProp resolution
-        - Shared httpx.AsyncClient for SSR requests (connection pooling)
-
         Args:
             app: The :class:`Litestar <litestar.app.Litestar>` instance.
 
         Yields:
             An asynchronous context manager.
         """
-        # Initialize shared SSR client with connection pooling
-        # These limits are tuned for typical SSR workloads:
-        # - max_keepalive_connections: 10 per-host keep-alive connections
-        # - max_connections: 20 total concurrent connections
-        # - keepalive_expiry: 30s idle timeout before closing
-        limits = httpx.Limits(max_keepalive_connections=10, max_connections=20, keepalive_expiry=30.0)
-        self._ssr_client = httpx.AsyncClient(
-            limits=limits,
-            timeout=httpx.Timeout(10.0),  # Default timeout, can be overridden per-request
-        )
 
-        try:
-            with start_blocking_portal() as portal:
-                self._portal = portal
-                yield
-        finally:
-            await self._ssr_client.aclose()
-            self._ssr_client = None  # Reset to signal client is closed
+        with start_blocking_portal() as portal:
+            self._portal = portal
+            yield
 
     @property
     def portal(self) -> "BlockingPortal":
@@ -105,27 +74,9 @@ class InertiaPlugin(InitPluginProtocol):
 
         Returns:
             The BlockingPortal instance.
-
-        Raises:
-            RuntimeError: If accessed before app lifespan is active.
         """
-        if self._portal is None:
-            msg = "BlockingPortal not available. Ensure app lifespan is active."
-            raise RuntimeError(msg)
         return self._portal
 
-    @property
-    def ssr_client(self) -> "httpx.AsyncClient | None":
-        """Return the shared httpx.AsyncClient for SSR requests.
-
-        The client is initialized during app lifespan and provides connection
-        pooling, TLS session reuse, and HTTP/2 multiplexing benefits.
-
-        Returns:
-            The shared AsyncClient instance, or None if not initialized.
-        """
-        return self._ssr_client
-
     def on_app_init(self, app_config: "AppConfig") -> "AppConfig":
         """Configure application for use with Vite.
 
@@ -139,7 +90,7 @@ class InertiaPlugin(InitPluginProtocol):
             The :class:`AppConfig <litestar.config.app.AppConfig>` instance.
         """
 
-        from litestar.exceptions import HTTPException, ImproperlyConfiguredException, ValidationException
+        from litestar.exceptions import ImproperlyConfiguredException
         from litestar.middleware import DefineMiddleware
         from litestar.middleware.session import SessionMiddleware
         from litestar.security.session_auth.middleware import MiddlewareWrapper
@@ -159,35 +110,18 @@ class InertiaPlugin(InitPluginProtocol):
         else:
             msg = "The Inertia plugin require a session middleware."
             raise ImproperlyConfiguredException(msg)
+        from litestar.exceptions import HTTPException
 
-        # Register exception handlers
-        exception_handlers: "dict[type[Exception] | int, Any]" = {
-            Exception: exception_to_http_response,
-            HTTPException: exception_to_http_response,
-        }
-
-        # Add Precognition exception handler when enabled
-        # Note: The exception handler formats validation errors in Laravel's format.
-        # For successful validation to return 204 (without executing the handler),
-        # use the @precognition decorator on your route handlers.
-        if self.config.precognition:
-            from litestar_vite.inertia.precognition import create_precognition_exception_handler
-
-            exception_handlers[ValidationException] = create_precognition_exception_handler(
-                fallback_handler=exception_to_http_response
-            )
-
-        app_config.exception_handlers.update(exception_handlers)  # pyright: ignore[reportUnknownMemberType]
+        app_config.exception_handlers.update(  # pyright: ignore[reportUnknownMemberType]
+            {Exception: exception_to_http_response, HTTPException: exception_to_http_response}
+        )
         app_config.request_class = InertiaRequest
         app_config.response_class = InertiaResponse
         app_config.middleware.append(InertiaMiddleware)
         app_config.signature_types.extend([InertiaRequest, InertiaResponse, InertiaBack, StaticProp, DeferredProp])
-        # Type encoders for prop resolution
-        # DeferredProp encoder passes the plugin's portal for efficient async resolution
-        # This avoids creating a new BlockingPortal per DeferredProp (~5-10ms savings)
         app_config.type_encoders = {
             StaticProp: lambda val: val.render(),
-            DeferredProp: lambda val: val.render(portal=getattr(self, "_portal", None)),
+            DeferredProp: lambda val: val.render(),
             **(app_config.type_encoders or {}),
         }
         app_config.type_decoders = [

litestar_vite/inertia/request.py

@@ -186,30 +186,6 @@ class InertiaDetails:
         """
         return self.reset_props.split(",") if self.reset_props is not None else []
 
-    @cached_property
-    def is_precognition(self) -> bool:
-        """Return True when the request is a Precognition validation request.
-
-        Precognition requests allow real-time form validation without
-        executing handler side effects.
-
-        Returns:
-            True if Precognition header is present and "true".
-        """
-        return self._get_header_value(InertiaHeaders.PRECOGNITION) == "true"
-
-    @cached_property
-    def precognition_validate_only(self) -> list[str]:
-        """Return the fields to validate for partial Precognition validation.
-
-        When present, only errors for these fields should be returned.
-
-        Returns:
-            List of field names to validate, or empty list if validating all fields.
-        """
-        value = self._get_header_value(InertiaHeaders.PRECOGNITION_VALIDATE_ONLY)
-        return value.split(",") if value else []
-
 
 class InertiaRequest(Request[UserT, AuthT, StateT]):
     """Inertia Request class to work with Inertia client."""
@@ -308,27 +284,3 @@ class InertiaRequest(Request[UserT, AuthT, StateT]):
             The version string sent by the client, or None if not present.
         """
         return self.inertia.version
-
-    @property
-    def is_precognition(self) -> bool:
-        """Check if this is a Precognition validation request.
-
-        Precognition requests run validation without executing the handler body,
-        enabling real-time form validation.
-
-        Returns:
-            True if this is a Precognition request.
-        """
-        return self.inertia.is_precognition
-
-    @property
-    def precognition_validate_only(self) -> "set[str]":
-        """Get fields to validate for partial Precognition validation.
-
-        When present, only validation errors for these fields should be returned.
-        Used for validating individual fields as the user types.
-
-        Returns:
-            A set of field names to validate, or empty set if validating all.
-        """
-        return set(self.inertia.precognition_validate_only)

litestar_vite/inertia/response.py

@@ -24,12 +24,10 @@ from litestar_vite.inertia._utils import get_headers
 from litestar_vite.inertia.helpers import (
     extract_deferred_props,
     extract_merge_props,
-    extract_once_props,
     extract_pagination_scroll_props,
     get_shared_props,
     is_merge_prop,
     is_or_contains_lazy_prop,
-    is_or_contains_special_prop,
     is_pagination_container,
     lazy_render,
     pagination_to_dict,
@@ -129,12 +127,7 @@ def _parse_inertia_ssr_payload(payload: Any, url: str) -> _InertiaSSRResult:
 
 
 def _render_inertia_ssr_sync(
-    page: dict[str, Any],
-    url: str,
-    *,
-    timeout_seconds: float,
-    portal: "BlockingPortal",
-    client: "httpx.AsyncClient | None" = None,
+    page: dict[str, Any], url: str, *, timeout_seconds: float, portal: "BlockingPortal"
 ) -> _InertiaSSRResult:
     """Call the Inertia SSR server and return head/body HTML.
 
@@ -145,48 +138,15 @@ def _render_inertia_ssr_sync(
     This function uses the application's :class:`~anyio.from_thread.BlockingPortal`
     to call the async HTTP client without blocking the event loop thread.
 
-    Args:
-        page: The page object to send to the SSR server.
-        url: The SSR server URL.
-        timeout_seconds: Request timeout in seconds.
-        portal: BlockingPortal for sync-to-async bridging.
-        client: Optional shared httpx.AsyncClient for connection pooling.
-
     Returns:
         An _InertiaSSRResult with head and body HTML.
     """
-    return portal.call(_render_inertia_ssr, page, url, timeout_seconds, client)
+    return portal.call(_render_inertia_ssr, page, url, timeout_seconds)
 
 
-async def _render_inertia_ssr(
-    page: dict[str, Any], url: str, timeout_seconds: float, client: "httpx.AsyncClient | None" = None
-) -> _InertiaSSRResult:
+async def _render_inertia_ssr(page: dict[str, Any], url: str, timeout_seconds: float) -> _InertiaSSRResult:
     """Call the Inertia SSR server asynchronously and return head/body HTML.
 
-    Args:
-        page: The page object to send to the SSR server.
-        url: The SSR server URL (typically http://localhost:13714/render).
-        timeout_seconds: Request timeout in seconds.
-        client: Optional shared httpx.AsyncClient for connection pooling.
-            If None, creates a new client per request (slower).
-
-    Returns:
-        An _InertiaSSRResult with head and body HTML.
-    """
-    return await _do_ssr_request(page, url, timeout_seconds, client)
-
-
-async def _do_ssr_request(
-    page: dict[str, Any], url: str, timeout_seconds: float, client: "httpx.AsyncClient | None"
-) -> _InertiaSSRResult:
-    """Execute the SSR request with optional client reuse.
-
-    Args:
-        page: The page object to send to the SSR server.
-        url: The SSR server URL.
-        timeout_seconds: Request timeout in seconds.
-        client: Optional shared httpx.AsyncClient.
-
     Raises:
         ImproperlyConfiguredException: If the SSR server is unreachable,
             returns an error status, or returns invalid payload.
@@ -194,37 +154,19 @@ async def _do_ssr_request(
     Returns:
         An _InertiaSSRResult with head and body HTML.
     """
-    response: "httpx.Response"
-
-    if client is not None:
-        # Use shared client for connection pooling benefits
-        try:
+    try:
+        async with httpx.AsyncClient() as client:
             response = await client.post(url, json=page, timeout=timeout_seconds)
             response.raise_for_status()
-        except httpx.RequestError as exc:
-            msg = (
-                f"Inertia SSR is enabled but the SSR server is not reachable at {url!r}. "
-                "Start the SSR server (Node) or disable InertiaConfig.ssr."
-            )
-            raise ImproperlyConfiguredException(msg) from exc
-        except httpx.HTTPStatusError as exc:
-            msg = f"Inertia SSR server at {url!r} returned HTTP {exc.response.status_code}. Check the SSR server logs."
-            raise ImproperlyConfiguredException(msg) from exc
-    else:
-        # Fallback: create a new client per request (graceful degradation)
-        try:
-            async with httpx.AsyncClient() as fallback_client:
-                response = await fallback_client.post(url, json=page, timeout=timeout_seconds)
-                response.raise_for_status()
-        except httpx.RequestError as exc:
-            msg = (
-                f"Inertia SSR is enabled but the SSR server is not reachable at {url!r}. "
-                "Start the SSR server (Node) or disable InertiaConfig.ssr."
-            )
-            raise ImproperlyConfiguredException(msg) from exc
-        except httpx.HTTPStatusError as exc:
-            msg = f"Inertia SSR server at {url!r} returned HTTP {exc.response.status_code}. Check the SSR server logs."
-            raise ImproperlyConfiguredException(msg) from exc
+    except httpx.RequestError as exc:
+        msg = (
+            f"Inertia SSR is enabled but the SSR server is not reachable at {url!r}. "
+            "Start the SSR server (Node) or disable InertiaConfig.ssr."
+        )
+        raise ImproperlyConfiguredException(msg) from exc
+    except httpx.HTTPStatusError as exc:
+        msg = f"Inertia SSR server at {url!r} returned HTTP {exc.response.status_code}. Check the SSR server logs."
+        raise ImproperlyConfiguredException(msg) from exc
 
     try:
         payload = response.json()
@@ -265,28 +207,6 @@ def _get_redirect_url(request: "Request[Any, Any, Any]", url: str | None) -> str
     return url
 
 
-def _get_relative_url(request: "Request[Any, Any, Any]") -> str:
-    """Return the relative URL including query string for Inertia page props.
-
-    The Inertia.js protocol requires the ``url`` property to include query parameters
-    so that page state (e.g., filters, pagination) is preserved on refresh.
-
-    This matches the behavior of other Inertia adapters:
-    - Laravel: Uses ``fullUrl()`` minus scheme/host
-    - Rails: Uses ``request.fullpath``
-    - Django: Uses ``request.get_full_path()``
-
-    Args:
-        request: The request object.
-
-    Returns:
-        The path with query string if present, e.g., ``/reports?page=1&status=active``.
-    """
-    path = request.url.path
-    query = request.url.query
-    return f"{path}?{query}" if query else path
-
-
 class InertiaResponse(Response[T]):
     """Inertia Response"""
 
@@ -418,7 +338,7 @@ class InertiaResponse(Response[T]):
             shared_props.pop(key, None)
 
         route_content: Any | None = None
-        if is_or_contains_lazy_prop(self.content) or is_or_contains_special_prop(self.content):
+        if is_or_contains_lazy_prop(self.content):
             filtered_content = lazy_render(self.content, partial_data, inertia_plugin.portal, partial_except)
             if filtered_content is not None:
                 route_content = filtered_content
@@ -438,11 +358,6 @@ class InertiaResponse(Response[T]):
                 shared_props["content"] = route_content
 
         deferred_props = extract_deferred_props(shared_props) or None
-        # Extract once props tracked during get_shared_props (already rendered)
-        once_props_from_shared = shared_props.pop("_once_props", [])
-        # Also check route content for once props
-        once_props_from_content = extract_once_props(shared_props) or []
-        once_props = (once_props_from_shared + once_props_from_content) or None
 
         merge_props_list, prepend_props_list, deep_merge_props_list, match_props_on = extract_merge_props(shared_props)
 
@@ -474,26 +389,19 @@ class InertiaResponse(Response[T]):
             with contextlib.suppress(AttributeError, ImproperlyConfiguredException):
                 clear_history_flag = request.session.pop("_inertia_clear_history", False)  # pyright: ignore[reportUnknownMemberType,reportAttributeAccessIssue]
 
-        # v2.3+ protocol: Extract flash to top level (not in props)
-        # This prevents flash from persisting in browser history state
-        # Always send {} for empty flash to support router.flash((current) => ({ ...current }))
-        flash_data: "dict[str, list[str]]" = shared_props.pop("flash", None) or {}
-
         return PageProps[T](
             component=request.inertia.route_component,  # type: ignore[attr-defined] # pyright: ignore[reportUnknownArgumentType,reportUnknownMemberType,reportAttributeAccessIssue]
             props=shared_props,  # pyright: ignore[reportArgumentType]
             version=vite_plugin.asset_loader.version_id,
-            url=_get_relative_url(request),
+            url=request.url.path,
             encrypt_history=encrypt_history,
             clear_history=clear_history_flag,
             deferred_props=deferred_props,
-            once_props=once_props,
             merge_props=merge_props_list or None,
             prepend_props=prepend_props_list or None,
             deep_merge_props=deep_merge_props_list or None,
             match_props_on=match_props_on or None,
             scroll_props=extracted_scroll_props,
-            flash=flash_data,
         )
 
     def _render_template(
@@ -583,11 +491,7 @@ class InertiaResponse(Response[T]):
         ssr_config = inertia_plugin.config.ssr_config
         if ssr_config is not None:
             ssr_payload = _render_inertia_ssr_sync(
-                page_dict,
-                ssr_config.url,
-                timeout_seconds=ssr_config.timeout,
-                portal=inertia_plugin.portal,
-                client=inertia_plugin.ssr_client,
+                page_dict, ssr_config.url, timeout_seconds=ssr_config.timeout, portal=inertia_plugin.portal
             )
 
             csrf_token = self._get_csrf_token(request)

litestar_vite/inertia/types.py

@@ -27,15 +27,6 @@ MergeStrategy = Literal["append", "prepend", "deep"]
 _SNAKE_CASE_PATTERN = re.compile(r"_([a-z])")
 
 
-def _empty_flash_factory() -> "dict[str, list[str]]":
-    """Return an empty flash dict with proper type annotation.
-
-    Returns:
-        Empty dict[str, list[str]] for flash messages.
-    """
-    return {}
-
-
 def to_camel_case(snake_str: str) -> str:
     """Convert snake_case string to camelCase.
 
@@ -277,8 +268,6 @@ class PageProps(Generic[T]):
         match_props_on: Keys for matching items during merge (v2).
         deferred_props: Configuration for lazy-loaded props (v2).
         scroll_props: Configuration for infinite scroll (v2).
-        flash: Flash messages as top-level property (v2.3+). Unlike props, flash
-            messages are NOT persisted in browser history state.
     """
 
     component: str
@@ -296,16 +285,8 @@ class PageProps(Generic[T]):
 
     deferred_props: "dict[str, list[str]] | None" = None
 
-    # v2.2.20+ protocol: Props that should only be resolved once and cached client-side
-    once_props: "list[str] | None" = None
-
     scroll_props: "ScrollPropsConfig | None" = None
 
-    # v2.3+ protocol: Flash messages at top level (not in props)
-    # This prevents flash from persisting in browser history state
-    # Always send {} for empty flash to support router.flash((current) => ({ ...current }))
-    flash: "dict[str, list[str]]" = field(default_factory=_empty_flash_factory)
-
     def to_dict(self) -> dict[str, Any]:
         """Convert to Inertia.js protocol format with camelCase keys.
 

litestar_vite/loader.py

@@ -12,7 +12,6 @@ Key features:
 """
 
 import hashlib
-import html
 from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
@@ -270,7 +269,10 @@ class ViteAssetLoader:
         Returns:
             Absolute path to the Vite manifest file.
         """
-        return self._config.resolve_manifest_path()
+        bundle_dir = self._config.bundle_dir
+        if not bundle_dir.is_absolute():
+            bundle_dir = self._config.root_dir / bundle_dir
+        return bundle_dir / self._config.manifest_name
 
     def _get_hot_file_path(self) -> Path:
         """Get the path to the hot file.
@@ -400,7 +402,7 @@ class ViteAssetLoader:
         if path not in self._manifest:
             raise AssetNotFoundError(path, str(self._get_manifest_path()))
 
-        return urljoin(self._config.asset_url, self._manifest[path]["file"])
+        return urljoin(self._config.base_url or self._config.asset_url, self._manifest[path]["file"])
 
     def generate_ws_client_tags(self) -> str:
         """Generate the Vite HMR client script tag.
@@ -423,10 +425,8 @@ class ViteAssetLoader:
             React refresh script HTML or empty string.
         """
         if self._config.is_react and self._is_hot_dev:
-            nonce = self._config.csp_nonce
-            nonce_attr = f' nonce="{html.escape(nonce, quote=True)}"' if nonce else ""
             return dedent(f"""
-                <script type="module"{nonce_attr}>
+                <script type="module">
                 import RefreshRuntime from '{self._vite_server_url()}@react-refresh'
                 RefreshRuntime.injectIntoGlobalHook(window)
                 window.$RefreshReg$ = () => {{}}
@@ -472,7 +472,7 @@ class ViteAssetLoader:
         if not scripts_attrs:
             scripts_attrs = {"type": "module", "async": "", "defer": ""}
 
-        asset_url_base = self._config.asset_url
+        asset_url_base = self._config.base_url or self._config.asset_url
 
         for manifest in manifest_entries.values():
             if "css" in manifest: