litestar-vite 0.11.0__tar.gz → 0.12.0__tar.gz

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/.gitignore

@@ -26,7 +26,7 @@ share/python-wheels/
 *.egg
 MANIFEST
 tmp/
-
+docs-build/
 # PyInstaller
 #  Usually these files are written by a python script from a template
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: litestar-vite
-Version: 0.11.0
+Version: 0.12.0
 Summary: Vite plugin for Litestar
 Project-URL: Changelog, https://cofin.github.io/litestar-vite/latest/changelog
 Project-URL: Discord, https://discord.gg/X3FJqy8d2j
@@ -10,6 +10,7 @@ Project-URL: Issue, https://github.com/cofin/litestar-vite/issues/
 Project-URL: Source, https://github.com/cofin/litestar-vite
 Author-email: Cody Fincher <cody.fincher@gmail.com>
 License: MIT
+License-File: LICENSE
 Keywords: litestar,vite
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/pyproject.toml

@@ -25,7 +25,7 @@ license = { text = "MIT" }
 name = "litestar-vite"
 readme = "README.md"
 requires-python = ">=3.8"
-version = "0.11.0"
+version = "0.12.0"
 
 [project.urls]
 Changelog = "https://cofin.github.io/litestar-vite/latest/changelog"
@@ -55,7 +55,8 @@ packages = ["src/py/litestar_vite"]
 sources = ["src/py"]
 
 [dependency-groups]
-dev = ["nodeenv", "litestar[standard]",  "bump-my-version", { include-group = "linting" }, { include-group = "test" }, { include-group = "docs" } ]
+dev = [ {include-group = "build"}, { include-group = "linting" }, { include-group = "test" }, { include-group = "docs" } ]
+build = ["bump-my-version"]
 docs = [
     "auto-pytabs[sphinx]>=0.4.0",
     "sphinx-autobuild>=2021.3.14",
@@ -71,6 +72,7 @@ docs = [
 ]
 linting = ["pre-commit>=3.4.0", "mypy>=1.5.1", "ruff>=0.0.287", "types-docutils", "slotscheck", "basedpyright", "pyright"]
 test = [
+  "litestar[standard]",
   "pytest>=7.4.1",
   "pytest-cov",
   "coverage",
@@ -85,7 +87,7 @@ test = [
 allow_dirty = true
 commit = true
 commit_args = "--no-verify"
-current_version = "0.11.0"
+current_version = "0.12.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -148,7 +150,7 @@ replace = '    "litestar-vite-plugin": "^{new_version}",'
 search = '    "litestar-vite-plugin": "^{current_version}",'
 
 [tool.pytest.ini_options]
-addopts = "--dist loadfile -n auto"
+addopts = ["-q", "-ra"]
 filterwarnings = ["ignore::DeprecationWarning:pkg_resources.*"]
 testpaths = ["src/py/tests"]
 
@@ -338,6 +340,12 @@ show_column_numbers = true
 warn_no_return = false
 warn_unused_ignores = true
 
+[[tool.mypy.overrides]]
+ignore_missing_imports = true
+module = [
+  "awaitlet",
+]
+
 [[tool.mypy.overrides]]
 disable_error_code = "attr-defined"
 disallow_untyped_decorators = false

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/src/py/litestar_vite/commands.py

@@ -14,7 +14,7 @@ DEFAULT_RESOURCES: set[str] = {"styles.css.j2", "main.ts.j2"}
 DEFAULT_DEV_DEPENDENCIES: dict[str, str] = {
     "typescript": "^5.7.2",
     "vite": "^6.0.3",
-    "litestar-vite-plugin": "^0.11.0",
+    "litestar-vite-plugin": "^0.12.0",
     "@types/node": "^22.10.1",
 }
 DEFAULT_DEPENDENCIES: dict[str, str] = {"axios": "^1.7.2"}

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/src/py/litestar_vite/inertia/plugin.py

@@ -2,18 +2,8 @@ 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 anyio.from_thread import BlockingPortalProvider
 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
@@ -24,6 +14,8 @@ if TYPE_CHECKING:
 
 def set_js_routes(app: Litestar) -> None:
     """Generate the route structure of the application on startup."""
+    from litestar_vite.inertia.routes import generate_js_routes
+
     js_routes = generate_js_routes(app)
     app.state.js_routes = js_routes
 
@@ -31,7 +23,7 @@ def set_js_routes(app: Litestar) -> None:
 class InertiaPlugin(InitPluginProtocol):
     """Inertia plugin."""
 
-    __slots__ = ("config",)
+    __slots__ = ("config", "portal")
 
     def __init__(self, config: InertiaConfig) -> None:
         """Initialize ``Inertia``.
@@ -41,12 +33,29 @@ class InertiaPlugin(InitPluginProtocol):
         """
         self.config = config
 
+        self.portal = BlockingPortalProvider()
+
+    def get_portal(self) -> BlockingPortalProvider:
+        return self.portal
+
     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.
         """
+
+        from litestar.exceptions import ImproperlyConfiguredException
+        from litestar.middleware import DefineMiddleware
+        from litestar.middleware.session import SessionMiddleware
+        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 DeferredProp, InertiaBack, InertiaResponse, StaticProp
+
         for mw in app_config.middleware:
             if isinstance(mw, DefineMiddleware) and is_class_and_subclass(
                 mw.middleware,
@@ -61,4 +70,15 @@ class InertiaPlugin(InitPluginProtocol):
         app_config.response_class = InertiaResponse
         app_config.middleware.append(InertiaMiddleware)
         app_config.on_startup.append(set_js_routes)
+        app_config.signature_types.extend([InertiaRequest, InertiaResponse, InertiaBack, StaticProp, DeferredProp])
+        app_config.type_encoders = {
+            StaticProp: lambda val: val.render(),
+            DeferredProp: lambda val: val.render(),
+            **(app_config.type_encoders or {}),
+        }
+        app_config.type_decoders = [
+            (lambda x: x is StaticProp, lambda t, v: t(v)),
+            (lambda x: x is DeferredProp, lambda t, v: t(v)),
+            *(app_config.type_decoders or []),
+        ]
         return app_config

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/src/py/litestar_vite/inertia/response.py

@@ -1,14 +1,31 @@
 from __future__ import annotations
 
+import inspect
 import itertools
 from collections import defaultdict
+from collections.abc import Mapping
+from contextlib import contextmanager
 from functools import lru_cache
 from mimetypes import guess_type
 from pathlib import PurePath
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Mapping, TypeVar, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    TypeVar,
+    cast,
+    overload,
+)
 from urllib.parse import quote, urlparse, urlunparse
 
+from anyio.from_thread import BlockingPortal, start_blocking_portal
 from litestar import Litestar, MediaType, Request, Response
 from litestar.datastructures.cookie import Cookie
 from litestar.exceptions import ImproperlyConfiguredException
@@ -21,6 +38,7 @@ from litestar.utils.empty import value_or_default
 from litestar.utils.helpers import get_enum_string_value
 from litestar.utils.scope.state import ScopeState
 from markupsafe import Markup
+from typing_extensions import ParamSpec, TypeGuard
 
 from litestar_vite.inertia._utils import get_headers
 from litestar_vite.inertia.types import InertiaHeaderType, PageProps
@@ -33,53 +51,224 @@ if TYPE_CHECKING:
     from litestar.connection.base import AuthT, StateT, UserT
     from litestar.types import ResponseCookies, ResponseHeaders, TypeEncodersMap
 
+    from litestar_vite.inertia.plugin import InertiaPlugin
     from litestar_vite.inertia.routes import Routes
 
-    from .plugin import InertiaPlugin
-
 T = TypeVar("T")
+T_ParamSpec = ParamSpec("T_ParamSpec")
+PropKeyT = TypeVar("PropKeyT", bound=str)
+StaticT = TypeVar("StaticT", bound=object)
 
 
-def share(
-    connection: ASGIConnection[Any, Any, Any, Any],
+@overload
+def lazy(key: str, value_or_callable: None) -> StaticProp[str, None]: ...
+
+
+@overload
+def lazy(key: str, value_or_callable: T) -> StaticProp[str, T]: ...
+
+
+@overload
+def lazy(
     key: str,
-    value: Any,
-) -> None:
-    try:
-        connection.session.setdefault("_shared", {}).update({key: value})
-    except (AttributeError, ImproperlyConfiguredException):
-        msg = "Unable to set `share` session state.  A valid session was not found for this request."
-        connection.logger.warning(msg)
+    value_or_callable: Callable[..., None] = ...,
+) -> DeferredProp[str, None]: ...
 
 
-def error(
-    connection: ASGIConnection[Any, Any, Any, Any],
+@overload
+def lazy(
     key: str,
-    message: str,
-) -> None:
-    try:
-        connection.session.setdefault("_errors", {}).update({key: message})
-    except (AttributeError, ImproperlyConfiguredException):
-        msg = "Unable to set `error` session state.  A valid session was not found for this request."
-        connection.logger.warning(msg)
+    value_or_callable: Callable[T_ParamSpec, T | Coroutine[Any, Any, T]] = ...,  # pyright: ignore[reportInvalidTypeVarUse]
+) -> DeferredProp[str, T]: ...
+
+
+def lazy(  # type: ignore[misc]
+    key: str,
+    value_or_callable: T | Callable[T_ParamSpec, T | Coroutine[Any, Any, T]],  # pyright: ignore[reportInvalidTypeVarUse]
+) -> StaticProp[str, None] | StaticProp[str, T] | DeferredProp[str, T] | DeferredProp[str, None]:
+    """Wrap an async function to return a DeferredProp."""
+    if value_or_callable is None:
+        return StaticProp[str, None](key=key, value=None)
+
+    if not callable(value_or_callable):
+        return StaticProp[str, T](key=key, value=value_or_callable)
+
+    return DeferredProp[str, T](key=key, value=value_or_callable)  # pyright: ignore[reportArgumentType]
+
+
+class StaticProp(Generic[PropKeyT, StaticT]):
+    """A wrapper for static property evaluation."""
+
+    def __init__(self, key: PropKeyT, value: StaticT) -> None:
+        self._key = key
+        self._result = value
+
+    @property
+    def key(self) -> PropKeyT:
+        return self._key
+
+    def render(self, portal: BlockingPortal | None = None) -> StaticT:
+        return self._result
+
+
+class DeferredProp(Generic[PropKeyT, T]):
+    """A wrapper for deferred property evaluation."""
+
+    def __init__(self, key: PropKeyT, value: Callable[T_ParamSpec, T | Coroutine[Any, Any, T]] | None = None) -> None:
+        self._key = key
+        self._value = value
+        self._evaluated = False
+        self._result: T | None = None
+
+    @property
+    def key(self) -> PropKeyT:
+        return self._key
+
+    @staticmethod
+    def _is_awaitable(
+        v: Callable[T_ParamSpec, T | Coroutine[Any, Any, T]],
+    ) -> TypeGuard[Coroutine[Any, Any, T]]:
+        return inspect.iscoroutinefunction(v)
+
+    @staticmethod
+    @contextmanager
+    def _with_portal(portal: BlockingPortal | None = None) -> Generator[BlockingPortal, None, None]:
+        if portal is None:
+            with start_blocking_portal() as new_portal:
+                yield new_portal
+        else:
+            yield portal
+
+    def render(self, portal: BlockingPortal | None = None) -> T | None:
+        if self._evaluated:
+            return self._result
+        if self._value is None or not callable(self._value):
+            self._result = self._value
+        elif not self._is_awaitable(self._value):
+            self._result = self._value()  # type: ignore[call-arg,assignment,unused-ignore]
+        else:
+            with self._with_portal(portal) as bp:
+                self._result = bp.call(self._value)  # type: ignore[call-overload]
+        self._evaluated = True
+        return self._result  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
+
+
+def is_lazy_prop(value: Any) -> TypeGuard[DeferredProp[Any, Any]]:
+    """Check if value is a deferred property.
+
+    Args:
+        value: Any value to check
+
+    Returns:
+        bool: True if value is a deferred property
+    """
+    return isinstance(value, (DeferredProp, StaticProp))
+
+
+def should_render(value: Any, partial_data: set[str] | None = None) -> bool:
+    """Check if value should be rendered.
+
+    Args:
+        value: Any value to check
+        partial_data: Optional set of keys for partial rendering
+
+    Returns:
+        bool: True if value should be rendered
+    """
+    partial_data = partial_data or set()
+    if is_lazy_prop(value):
+        return value.key in partial_data
+    return True
+
+
+def is_or_contains_lazy_prop(value: Any) -> bool:
+    """Check if value is or contains a deferred property.
+
+    Args:
+        value: Any value to check
+
+    Returns:
+        bool: True if value is or contains a deferred property
+    """
+    if is_lazy_prop(value):
+        return True
+    if isinstance(value, str):
+        return False
+    if isinstance(value, Mapping):
+        return any(is_or_contains_lazy_prop(v) for v in cast("Mapping[str, Any]", value).values())
+    if isinstance(value, Iterable):
+        return any(is_or_contains_lazy_prop(v) for v in cast("Iterable[Any]", value))
+    return False
+
+
+def lazy_render(value: T, partial_data: set[str] | None = None, portal: BlockingPortal | None = None) -> T:
+    """Filter deferred properties from the value based on partial data.
+
+    Args:
+        value: The value to filter
+        partial_data: Keys for partial rendering
+        portal: Optional portal to use for async rendering
+    Returns:
+        The filtered value
+    """
+    partial_data = partial_data or set()
+    if isinstance(value, str):
+        return cast("T", value)
+    if isinstance(value, Mapping):
+        return cast(
+            "T",
+            {
+                k: lazy_render(v, partial_data)
+                for k, v in cast("Mapping[str, Any]", value).items()
+                if should_render(v, partial_data)
+            },
+        )
+
+    if isinstance(value, (list, tuple)):
+        filtered = [
+            lazy_render(v, partial_data) for v in cast("Iterable[Any]", value) if should_render(v, partial_data)
+        ]
+        return cast("T", type(value)(filtered))  # pyright: ignore[reportUnknownArgumentType]
+
+    if is_lazy_prop(value) and should_render(value, partial_data):
+        return cast("T", value.render())
+
+    return cast("T", value)
 
 
 def get_shared_props(
     request: ASGIConnection[Any, Any, Any, Any],
     partial_data: set[str] | None = None,
-) -> Dict[str, Any]:  # noqa: UP006
-    """Return shared session props for a request
+) -> dict[str, Any]:
+    """Return shared session props for a request.
+
+    Args:
+        request: The ASGI connection.
+        partial_data: Optional set of keys for partial rendering.
 
+    Returns:
+        Dict[str, Any]: The shared props.
 
-    Be sure to call this before `self.create_template_context` if you would like to include the `flash` message details.
+    Note:
+        Be sure to call this before `self.create_template_context` if you would like to include the `flash` message details.
     """
     props: dict[str, Any] = {}
     flash: dict[str, list[str]] = defaultdict(list)
     errors: dict[str, Any] = {}
     error_bag = request.headers.get("X-Inertia-Error-Bag", None)
+
     try:
         errors = request.session.pop("_errors", {})
-        props.update(cast("Dict[str,Any]", request.session.pop("_shared", {})))
+        shared_props = cast("Dict[str,Any]", request.session.pop("_shared", {}))
+
+        # Handle deferred props
+        for key, value in shared_props.items():
+            if is_lazy_prop(value) and should_render(value, partial_data):
+                props[key] = value.render()
+                continue
+            if should_render(value, partial_data):
+                props[key] = value
+
         for message in cast("List[Dict[str,Any]]", request.session.pop("_messages", [])):
             flash[message["category"]].append(message["message"])
 
@@ -92,12 +281,51 @@ def get_shared_props(
     except (AttributeError, ImproperlyConfiguredException):
         msg = "Unable to generate all shared props.  A valid session was not found for this request."
         request.logger.warning(msg)
+
     props["flash"] = flash
     props["errors"] = {error_bag: errors} if error_bag is not None else errors
     props["csrf_token"] = value_or_default(ScopeState.from_scope(request.scope).csrf_token, "")
     return props
 
 
+def share(
+    connection: ASGIConnection[Any, Any, Any, Any],
+    key: str,
+    value: Any,
+) -> None:
+    """Share a value in the session.
+
+    Args:
+        connection: The ASGI connection.
+        key: The key to store the value under.
+        value: The value to store.
+    """
+    try:
+        connection.session.setdefault("_shared", {}).update({key: value})
+    except (AttributeError, ImproperlyConfiguredException):
+        msg = "Unable to set `share` session state.  A valid session was not found for this request."
+        connection.logger.warning(msg)
+
+
+def error(
+    connection: ASGIConnection[Any, Any, Any, Any],
+    key: str,
+    message: str,
+) -> None:
+    """Set an error message in the session.
+
+    Args:
+        connection: The ASGI connection.
+        key: The key to store the error under.
+        message: The error message.
+    """
+    try:
+        connection.session.setdefault("_errors", {}).update({key: message})
+    except (AttributeError, ImproperlyConfiguredException):
+        msg = "Unable to set `error` session state.  A valid session was not found for this request."
+        connection.logger.warning(msg)
+
+
 def js_routes_script(js_routes: Routes) -> Markup:
     @lru_cache
     def _markup_safe_json_dumps(js_routes: str) -> Markup:
@@ -197,7 +425,7 @@ class InertiaResponse(Response[T]):
             "csrf_input": f'<input type="hidden" name="_csrf_token" value="{csrf_token}" />',
         }
 
-    def to_asgi_response(
+    def to_asgi_response(  # noqa: C901, PLR0912
         self,
         app: Litestar | None,
         request: Request[UserT, AuthT, StateT],
@@ -250,7 +478,13 @@ class InertiaResponse(Response[T]):
             {"Vary": "Accept", **get_headers(InertiaHeaderType(enabled=True))},
         )
         shared_props = get_shared_props(request, partial_data=partial_keys if is_partial_render else None)
-        shared_props["content"] = self.content
+        if is_or_contains_lazy_prop(self.content):
+            filtered_content = lazy_render(self.content, partial_keys if is_partial_render else None)
+            if filtered_content is not None:
+                shared_props["content"] = filtered_content
+        elif should_render(self.content, partial_keys):
+            shared_props["content"] = self.content
+
         page_props = PageProps[T](
             component=request.inertia.route_component,  # type: ignore[attr-defined] # pyright: ignore[reportUnknownArgumentType,reportUnknownMemberType,reportAttributeAccessIssue]
             props=shared_props,  # pyright: ignore[reportArgumentType]

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/src/py/litestar_vite/plugin.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 import os
+import platform
 import signal
+import subprocess
 import threading
 from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING, Iterator, cast
 
+from litestar.cli._utils import console
 from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar.exceptions import ImproperlyConfiguredException
 from litestar.plugins import CLIPlugin, InitPluginProtocol
@@ -37,50 +40,43 @@ class ViteProcess:
     """Manages the Vite process."""
 
     def __init__(self) -> None:
-        self.process: threading.Thread | None = None
+        self.process: subprocess.Popen | None = None  # pyright: ignore[reportUnknownMemberType,reportMissingTypeArgument]
         self._lock = threading.Lock()
 
     def start(self, command: list[str], cwd: Path | str | None) -> None:
         """Start the Vite process."""
-        from litestar.cli._utils import console
-
-        from litestar_vite.commands import execute_command
 
         try:
             with self._lock:
-                if self.process and self.process.is_alive():
+                if self.process and self.process.poll() is None:  # pyright: ignore[reportUnknownMemberType]
                     return
 
-                self.process = threading.Thread(
-                    name="vite",
-                    target=execute_command,
-                    args=[],
-                    kwargs={"command_to_run": command, "cwd": cwd},
-                    daemon=True,  # Make thread daemon so it exits when main thread exits
-                )
                 console.print(f"Starting Vite process with command: {command}")
-                self.process.start()
+                self.process = subprocess.Popen(
+                    command,
+                    cwd=cwd,
+                    shell=platform.system() == "Windows",
+                )
         except Exception as e:
             console.print(f"[red]Failed to start Vite process: {e!s}[/]")
             raise
 
     def stop(self, timeout: float = 5.0) -> None:
         """Stop the Vite process."""
-        from litestar.cli._utils import console
 
         try:
             with self._lock:
-                if self.process and self.process.is_alive():
+                if self.process and self.process.poll() is None:  # pyright: ignore[reportUnknownMemberType]
                     # Send SIGTERM to child process
-                    if hasattr(signal, "SIGTERM") and self.process.ident is not None:
-                        os.kill(self.process.ident, signal.SIGTERM)
-                    self.process.join(timeout=timeout)
-
-                    # Force kill if still alive
-                    if self.process.is_alive():
-                        if hasattr(signal, "SIGKILL") and self.process.ident is not None:
-                            os.kill(self.process.ident, signal.SIGKILL)
-                        self.process.join(timeout=1.0)
+                    if hasattr(signal, "SIGTERM"):
+                        self.process.terminate()  # pyright: ignore[reportUnknownMemberType]
+                    try:
+                        self.process.wait(timeout=timeout)  # pyright: ignore[reportUnknownMemberType]
+                    except subprocess.TimeoutExpired:
+                        # Force kill if still alive
+                        if hasattr(signal, "SIGKILL"):
+                            self.process.kill()  # pyright: ignore[reportUnknownMemberType]
+                        self.process.wait(timeout=1.0)  # pyright: ignore[reportUnknownMemberType]
                 console.print("Stopping Vite process")
         except Exception as e:
             console.print(f"[red]Failed to stop Vite process: {e!s}[/]")
@@ -168,7 +164,6 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
     @contextmanager
     def server_lifespan(self, app: Litestar) -> Iterator[None]:
         """Manage Vite server process lifecycle."""
-        from litestar.cli._utils import console
 
         if self._config.use_server_lifespan and self._config.dev_mode:
             command_to_run = self._config.run_command if self._config.hot_reload else self._config.build_watch_command

{litestar_vite-0.11.0 → litestar_vite-0.12.0}/src/py/tests/conftest.py

@@ -18,21 +18,28 @@ def anyio_backend() -> str:
     return "asyncio"
 
 
+@pytest.fixture(autouse=True)
+def permissive_tmp_path(tmp_path: Path) -> Generator[Path, None, None]:
+    tmp_path.chmod(0o775)
+    tmp_path.parent.chmod(0o775)
+    yield tmp_path
+
+
 @pytest.fixture
 def test_app_path() -> Generator[Path, None, None]:
     yield Path(here / "test_app" / "web")
 
 
 @pytest.fixture
-def template_config(test_app_path: Path) -> TemplateConfig[JinjaTemplateEngine]:
-    return TemplateConfig(engine=JinjaTemplateEngine(directory=test_app_path / "templates"))
+def template_config(test_app_path: Path) -> Generator[TemplateConfig[JinjaTemplateEngine], None, None]:
+    yield TemplateConfig(engine=JinjaTemplateEngine(directory=test_app_path / "templates"))
 
 
 # Define a fixture for ViteConfig
 @pytest.fixture
-def vite_config(test_app_path: Path) -> ViteConfig:
+def vite_config(test_app_path: Path) -> Generator[ViteConfig, None, None]:
     # Mock the ViteConfig with necessary attributes for testing
-    return ViteConfig(
+    yield ViteConfig(
         bundle_dir=test_app_path / "public",
         resource_dir=test_app_path / "resources",
         hot_reload=True,