litestar-vite 0.11.1__py3-none-any.whl → 0.12.1__py3-none-any.whl

litestar_vite/inertia/_utils.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable
-
-if TYPE_CHECKING:
-    from litestar_vite.inertia.types import InertiaHeaderType
-
-
-class InertiaHeaders(str, Enum):
-    """Enum for Inertia Headers"""
-
-    ENABLED = "X-Inertia"
-    VERSION = "X-Inertia-Version"
-    PARTIAL_DATA = "X-Inertia-Partial-Data"
-    PARTIAL_COMPONENT = "X-Inertia-Partial-Component"
-    LOCATION = "X-Inertia-Location"
-    REFERER = "Referer"
-
-
-def get_enabled_header(enabled: bool = True) -> dict[str, Any]:
-    """True if inertia is enabled."""
-
-    return {InertiaHeaders.ENABLED.value: "true" if enabled else "false"}
-
-
-def get_version_header(version: str) -> dict[str, Any]:
-    """Return headers for change swap method response."""
-    return {InertiaHeaders.VERSION.value: version}
-
-
-def get_partial_data_header(partial: str) -> dict[str, Any]:
-    """Return headers for a partial data response."""
-    return {InertiaHeaders.PARTIAL_DATA.value: partial}
-
-
-def get_partial_component_header(partial: str) -> dict[str, Any]:
-    """Return headers for a partial data response."""
-    return {InertiaHeaders.PARTIAL_COMPONENT.value: partial}
-
-
-def get_headers(inertia_headers: InertiaHeaderType) -> dict[str, Any]:
-    """Return headers for Inertia responses."""
-    if not inertia_headers:
-        msg = "Value for inertia_headers cannot be None."
-        raise ValueError(msg)
-    inertia_headers_dict: dict[str, Callable[..., dict[str, Any]]] = {
-        "enabled": get_enabled_header,
-        "partial_data": get_partial_data_header,
-        "partial_component": get_partial_component_header,
-        "version": get_version_header,
-    }
-
-    header: dict[str, Any] = {}
-    response: dict[str, Any]
-    key: str
-    value: Any
-
-    for key, value in inertia_headers.items():
-        if value is not None:
-            response = inertia_headers_dict[key](value)
-            header.update(response)
-    return header

litestar_vite/inertia/config.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any
-
-__all__ = ("InertiaConfig",)
-
-
-@dataclass
-class InertiaConfig:
-    """Configuration for InertiaJS support."""
-
-    root_template: str = "index.html"
-    """Name of the root template to use.
-
-    This must be a path that is found by the Vite Plugin template config
-    """
-    component_opt_key: str = "component"
-    """An identifier to use on routes to get the inertia component to render."""
-    exclude_from_js_routes_key: str = "exclude_from_routes"
-    """An identifier to use on routes to exclude a route from the generated routes typescript file."""
-    redirect_unauthorized_to: str | None = None
-    """Optionally supply a path where unauthorized requests should redirect."""
-    redirect_404: str | None = None
-    """Optionally supply a path where 404 requests should redirect."""
-    extra_static_page_props: dict[str, Any] = field(default_factory=dict)
-    """A dictionary of values to automatically add in to page props on every response."""
-    extra_session_page_props: set[str] = field(default_factory=set)
-    """A set of session keys for which the value automatically be added (if it exists) to the response."""

litestar_vite/inertia/exception_handler.py

@@ -1,116 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import TYPE_CHECKING, Any, cast
-
-from litestar import MediaType
-from litestar.connection import Request
-from litestar.connection.base import AuthT, StateT, UserT
-from litestar.exceptions import (
-    HTTPException,
-    ImproperlyConfiguredException,
-    InternalServerException,
-    NotAuthorizedException,
-    NotFoundException,
-    PermissionDeniedException,
-)
-from litestar.exceptions.responses import (
-    create_debug_response,  # pyright: ignore[reportUnknownVariableType]
-    create_exception_response,  # pyright: ignore[reportUnknownVariableType]
-)
-from litestar.plugins.flash import flash
-from litestar.repository.exceptions import (
-    ConflictError,  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue]
-    NotFoundError,  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue]
-    RepositoryError,  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue]
-)
-from litestar.response import Response
-from litestar.status_codes import (
-    HTTP_400_BAD_REQUEST,
-    HTTP_401_UNAUTHORIZED,
-    HTTP_404_NOT_FOUND,
-    HTTP_405_METHOD_NOT_ALLOWED,
-    HTTP_409_CONFLICT,
-    HTTP_422_UNPROCESSABLE_ENTITY,
-    HTTP_500_INTERNAL_SERVER_ERROR,
-)
-
-from litestar_vite.inertia.response import InertiaBack, InertiaRedirect, InertiaResponse, error
-
-if TYPE_CHECKING:
-    from litestar.connection import Request
-    from litestar.connection.base import AuthT, StateT, UserT
-    from litestar.response import Response
-
-    from litestar_vite.inertia.plugin import InertiaPlugin
-
-FIELD_ERR_RE = re.compile(r"field `(.+)`$")
-
-
-class _HTTPConflictException(HTTPException):
-    """Request conflict with the current state of the target resource."""
-
-    status_code: int = HTTP_409_CONFLICT
-
-
-def exception_to_http_response(request: Request[UserT, AuthT, StateT], exc: Exception) -> Response[Any]:
-    """Handler for all exceptions subclassed from HTTPException."""
-    inertia_enabled = getattr(request, "inertia_enabled", False) or getattr(request, "is_inertia", False)
-
-    if not inertia_enabled:
-        if isinstance(exc, NotFoundError):
-            http_exc = NotFoundException
-        elif isinstance(exc, (RepositoryError, ConflictError)):
-            http_exc = _HTTPConflictException  # type: ignore[assignment]
-        else:
-            http_exc = InternalServerException  # type: ignore[assignment]
-        if request.app.debug and http_exc not in (PermissionDeniedException, NotFoundError):
-            return cast("Response[Any]", create_debug_response(request, exc))
-        return cast("Response[Any]", create_exception_response(request, http_exc(detail=str(exc.__cause__))))  # pyright: ignore[reportUnknownArgumentType]
-    return create_inertia_exception_response(request, exc)
-
-
-def create_inertia_exception_response(request: Request[UserT, AuthT, StateT], exc: Exception) -> Response[Any]:
-    """Create the inertia exception response"""
-    is_inertia = getattr(request, "is_inertia", False)
-    status_code = getattr(exc, "status_code", HTTP_500_INTERNAL_SERVER_ERROR)
-    preferred_type = MediaType.HTML if not is_inertia else MediaType.JSON
-    detail = getattr(exc, "detail", "")  # litestar exceptions
-    extras = getattr(exc, "extra", "")  # msgspec exceptions
-    content: dict[str, Any] = {"status_code": status_code, "message": getattr(exc, "detail", "")}
-    inertia_plugin = cast("InertiaPlugin", request.app.plugins.get("InertiaPlugin"))
-    if extras:
-        content.update({"extra": extras})
-    try:
-        flash(request, detail, category="error")
-    except (AttributeError, ImproperlyConfiguredException):
-        msg = "Unable to set `flash` session state.  A valid session was not found for this request."
-        request.logger.warning(msg)
-    if extras and len(extras) >= 1:
-        message = extras[0]
-        default_field = f"root.{message.get('key')}" if message.get("key", None) is not None else "root"  # type: ignore
-        error_detail = cast("str", message.get("message", detail))  # type: ignore[union-attr] # pyright: ignore[reportUnknownMemberType]
-        match = FIELD_ERR_RE.search(error_detail)
-        field = match.group(1) if match else default_field
-        if isinstance(message, dict):
-            error(request, field, error_detail if error_detail else detail)
-    if status_code in {HTTP_422_UNPROCESSABLE_ENTITY, HTTP_400_BAD_REQUEST}:
-        return InertiaBack(request)
-    if isinstance(exc, PermissionDeniedException):
-        return InertiaBack(request)
-    if (status_code == HTTP_401_UNAUTHORIZED or isinstance(exc, NotAuthorizedException)) and (
-        inertia_plugin.config.redirect_unauthorized_to is not None
-        and request.url.path != inertia_plugin.config.redirect_unauthorized_to
-    ):
-        return InertiaRedirect(request, redirect_to=inertia_plugin.config.redirect_unauthorized_to)
-
-    if status_code in {HTTP_404_NOT_FOUND, HTTP_405_METHOD_NOT_ALLOWED} and (
-        inertia_plugin.config.redirect_404 is not None and request.url.path != inertia_plugin.config.redirect_404
-    ):
-        return InertiaRedirect(request, redirect_to=inertia_plugin.config.redirect_404)
-
-    return InertiaResponse[Any](
-        media_type=preferred_type,
-        content=content,
-        status_code=status_code,
-    )

litestar_vite/inertia/middleware.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from litestar import Request
-from litestar.middleware import AbstractMiddleware
-from litestar.types import Receive, Scope, Send
-
-from litestar_vite.inertia.response import InertiaRedirect
-from litestar_vite.plugin import VitePlugin
-
-if TYPE_CHECKING:
-    from litestar.connection.base import (
-        AuthT,
-        StateT,
-        UserT,
-    )
-    from litestar.types import ASGIApp, Receive, Scope, Send
-
-
-async def redirect_on_asset_version_mismatch(request: Request[UserT, AuthT, StateT]) -> InertiaRedirect | None:
-    if getattr(request, "is_inertia", None) is None:
-        return None
-    inertia_version = request.headers.get("X-Inertia-Version")
-    if inertia_version is None:
-        return None
-
-    vite_plugin = request.app.plugins.get(VitePlugin)
-    if inertia_version == vite_plugin.asset_loader.version_id:
-        return None
-    return InertiaRedirect(request, redirect_to=str(request.url))
-
-
-class InertiaMiddleware(AbstractMiddleware):
-    def __init__(self, app: ASGIApp) -> None:
-        super().__init__(app)
-        self.app = app
-
-    async def __call__(
-        self,
-        scope: "Scope",
-        receive: "Receive",
-        send: "Send",
-    ) -> None:
-        request = Request[Any, Any, Any](scope=scope)
-        redirect = await redirect_on_asset_version_mismatch(request)
-        if redirect is not None:
-            response = redirect.to_asgi_response(app=None, request=request)  # pyright: ignore[reportUnknownMemberType]
-            await response(scope, receive, send)
-        else:
-            await self.app(scope, receive, send)

litestar_vite/inertia/plugin.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from litestar.exceptions import ImproperlyConfiguredException
-from litestar.middleware import DefineMiddleware
-from litestar.middleware.session import SessionMiddleware
-from litestar.plugins import InitPluginProtocol
-from litestar.security.session_auth.middleware import MiddlewareWrapper
-from litestar.utils.predicates import is_class_and_subclass
-
-from litestar_vite.inertia.exception_handler import exception_to_http_response
-from litestar_vite.inertia.middleware import InertiaMiddleware
-from litestar_vite.inertia.request import InertiaRequest
-from litestar_vite.inertia.response import InertiaResponse
-from litestar_vite.inertia.routes import generate_js_routes
-
-if TYPE_CHECKING:
-    from litestar import Litestar
-    from litestar.config.app import AppConfig
-
-    from litestar_vite.inertia.config import InertiaConfig
-
-
-def set_js_routes(app: Litestar) -> None:
-    """Generate the route structure of the application on startup."""
-    js_routes = generate_js_routes(app)
-    app.state.js_routes = js_routes
-
-
-class InertiaPlugin(InitPluginProtocol):
-    """Inertia plugin."""
-
-    __slots__ = ("config",)
-
-    def __init__(self, config: InertiaConfig) -> None:
-        """Initialize ``Inertia``.
-
-        Args:
-            config: Inertia configuration.
-        """
-        self.config = config
-
-    def on_app_init(self, app_config: AppConfig) -> AppConfig:
-        """Configure application for use with Vite.
-
-        Args:
-            app_config: The :class:`AppConfig <litestar.config.app.AppConfig>` instance.
-        """
-        for mw in app_config.middleware:
-            if isinstance(mw, DefineMiddleware) and is_class_and_subclass(
-                mw.middleware,
-                (MiddlewareWrapper, SessionMiddleware),
-            ):
-                break
-        else:
-            msg = "The Inertia plugin require a session middleware."
-            raise ImproperlyConfiguredException(msg)
-        app_config.exception_handlers.update({Exception: exception_to_http_response})  # pyright: ignore[reportUnknownMemberType]
-        app_config.request_class = InertiaRequest
-        app_config.response_class = InertiaResponse
-        app_config.middleware.append(InertiaMiddleware)
-        app_config.on_startup.append(set_js_routes)
-        return app_config

litestar_vite/inertia/request.py

@@ -1,116 +0,0 @@
-from __future__ import annotations
-
-from functools import cached_property
-from typing import TYPE_CHECKING
-from urllib.parse import unquote
-
-from litestar import Request
-from litestar.connection.base import (
-    AuthT,
-    StateT,
-    UserT,
-    empty_receive,
-    empty_send,
-)
-
-from litestar_vite.inertia._utils import InertiaHeaders
-
-__all__ = ("InertiaDetails", "InertiaRequest")
-
-
-if TYPE_CHECKING:
-    from litestar.types import Receive, Scope, Send
-
-
-class InertiaDetails:
-    """InertiaDetails holds all the values sent by Inertia client in headers and provide convenient properties."""
-
-    def __init__(self, request: Request[UserT, AuthT, StateT]) -> None:
-        """Initialize :class:`InertiaDetails`"""
-        self.request = request
-
-    def _get_header_value(self, name: InertiaHeaders) -> str | None:
-        """Parse request header
-
-        Check for uri encoded header and unquotes it in readable format.
-        """
-
-        if value := self.request.headers.get(name.value.lower()):
-            is_uri_encoded = self.request.headers.get(f"{name.value.lower()}-uri-autoencoded") == "true"
-            return unquote(value) if is_uri_encoded else value
-        return None
-
-    def _get_route_component(self) -> str | None:
-        """Get the route component.
-
-        Checks for the `component` key within the route  configuration.
-        """
-        rh = self.request.scope.get("route_handler")  # pyright: ignore[reportUnknownMemberType]
-        if rh:
-            return rh.opt.get("component")
-        return None
-
-    def __bool__(self) -> bool:
-        """Check if request is sent by an Inertia client."""
-        return self._get_header_value(InertiaHeaders.ENABLED) == "true"
-
-    @cached_property
-    def route_component(self) -> str | None:
-        """Partial Data Reload."""
-        return self._get_route_component()
-
-    @cached_property
-    def partial_component(self) -> str | None:
-        """Partial Data Reload."""
-        return self._get_header_value(InertiaHeaders.PARTIAL_COMPONENT)
-
-    @cached_property
-    def partial_data(self) -> str | None:
-        """Partial Data Reload."""
-        return self._get_header_value(InertiaHeaders.PARTIAL_DATA)
-
-    @cached_property
-    def referer(self) -> str | None:
-        """Partial Data Reload."""
-        return self._get_header_value(InertiaHeaders.REFERER)
-
-    @cached_property
-    def is_partial_render(self) -> bool:
-        """Is Partial Data Reload."""
-        return bool(self.partial_component == self.route_component and self.partial_data)
-
-    @cached_property
-    def partial_keys(self) -> list[str]:
-        """Is Partial Data Reload."""
-        return self.partial_data.split(",") if self.partial_data is not None else []
-
-
-class InertiaRequest(Request[UserT, AuthT, StateT]):
-    """Inertia Request class to work with Inertia client."""
-
-    __slots__ = ("inertia",)
-
-    def __init__(self, scope: Scope, receive: Receive = empty_receive, send: Send = empty_send) -> None:
-        """Initialize :class:`InertiaRequest`"""
-        super().__init__(scope=scope, receive=receive, send=send)
-        self.inertia = InertiaDetails(self)
-
-    @property
-    def is_inertia(self) -> bool:
-        """True if the request contained inertia headers."""
-        return bool(self.inertia)
-
-    @property
-    def inertia_enabled(self) -> bool:
-        """True if the route handler contains an inertia enabled configuration."""
-        return bool(self.inertia.route_component is not None)
-
-    @property
-    def is_partial_render(self) -> bool:
-        """True if the route handler contains an inertia enabled configuration."""
-        return self.inertia.is_partial_render
-
-    @property
-    def partial_keys(self) -> set[str]:
-        """True if the route handler contains an inertia enabled configuration."""
-        return set(self.inertia.partial_keys)