Merge branch 'main', remote-tracking branch 'upstream' into explicit-event-id-minification

Author: benedikt-bartscher

.devcontainer/devcontainer.json

@@ -1,5 +1,5 @@
 {
-  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bookworm",
+  "image": "mcr.microsoft.com/devcontainers/python:3.14-trixie",
   "postCreateCommand": "/bin/bash -c 'python -m pip install uv && python -m uv sync & git clone https://github.com/reflex-dev/reflex-examples; wait'",
   "forwardPorts": [3000, 8000],
   "portsAttributes": {

reflex/app.py

@@ -615,8 +615,13 @@ def __call__(self) -> ASGIApp:
         Returns:
             The backend api.
         """
+        from reflex.assets import remove_stale_external_asset_symlinks
         from reflex.vars.base import GLOBAL_CACHE
 
+        # Clean up stale symlinks in assets/external/ before compiling, so that
+        # rx.asset(shared=True) symlink re-creation doesn't trigger further reloads.
+        remove_stale_external_asset_symlinks()
+
         self._compile(prerender_routes=should_prerender_routes())
 
         config = get_config()

reflex/assets.py

@@ -7,6 +7,35 @@
 from reflex.environment import EnvironmentVariables
 
 
+def remove_stale_external_asset_symlinks():
+    """Remove broken symlinks and empty directories in assets/external/.
+
+    When a Python module directory that uses rx.asset(shared=True) is renamed
+    or deleted, stale symlinks remain in assets/external/ pointing to the old
+    path. This cleanup prevents issues with file watchers detecting symlink
+    re-creation during import.
+    """
+    external_dir = (
+        Path.cwd() / constants.Dirs.APP_ASSETS / constants.Dirs.EXTERNAL_APP_ASSETS
+    )
+    if not external_dir.exists():
+        return
+
+    # Remove broken symlinks.
+    broken = [
+        p
+        for p in external_dir.rglob("*")
+        if p.is_symlink() and not p.resolve().exists()
+    ]
+    for path in broken:
+        path.unlink()
+
+    # Remove empty directories left behind (deepest first).
+    for dirpath in sorted(external_dir.rglob("*"), reverse=True):
+        if dirpath.is_dir() and not dirpath.is_symlink() and not any(dirpath.iterdir()):
+            dirpath.rmdir()
+
+
 def asset(
     path: str,
     shared: bool = False,
@@ -92,6 +121,11 @@ def asset(
         if not dst_file.exists() and (
             not dst_file.is_symlink() or dst_file.resolve() != src_file_shared.resolve()
         ):
-            dst_file.symlink_to(src_file_shared)
+            try:
+                dst_file.symlink_to(src_file_shared)
+            except FileExistsError:
+                # This happens when Simon builds the app on a bind mount in a docker container.
+                dst_file.unlink()
+                dst_file.symlink_to(src_file_shared)
 
     return f"/{external}/{subfolder}/{path}"

reflex/compiler/templates.py

@@ -528,6 +528,7 @@ def vite_config_template(
     force_full_reload: bool,
     experimental_hmr: bool,
     sourcemap: bool | Literal["inline", "hidden"],
+    allowed_hosts: bool | list[str] = False,
 ):
     """Template for vite.config.js.
 
@@ -537,10 +538,17 @@ def vite_config_template(
         force_full_reload: Whether to force a full reload on changes.
         experimental_hmr: Whether to enable experimental HMR features.
         sourcemap: The sourcemap configuration.
+        allowed_hosts: Allow all hosts (True), specific hosts (list of strings), or only localhost (False).
 
     Returns:
         Rendered vite.config.js content as string.
     """
+    if allowed_hosts is True:
+        allowed_hosts_line = "\n    allowedHosts: true,"
+    elif isinstance(allowed_hosts, list) and allowed_hosts:
+        allowed_hosts_line = f"\n    allowedHosts: {json.dumps(allowed_hosts)},"
+    else:
+        allowed_hosts_line = ""
     return rf"""import {{ fileURLToPath, URL }} from "url";
 import {{ reactRouter }} from "@react-router/dev/vite";
 import {{ defineConfig }} from "vite";
@@ -612,7 +620,7 @@ def vite_config_template(
     hmr: {"true" if experimental_hmr else "false"},
   }},
   server: {{
-    port: process.env.PORT,
+    port: process.env.PORT,{allowed_hosts_line}
     hmr: {"true" if hmr else "false"},
     watch: {{
       ignored: [

reflex/config.py

@@ -213,6 +213,11 @@ class BaseConfig:
         dataclasses.field(default=("*",))
     )
 
+    # Allowed hosts for the Vite dev server. Set to True to allow all hosts,
+    # or provide a list of hostnames (e.g. ["myservice.local"]) to allow specific ones.
+    # Prevents 403 errors in Docker, Codespaces, reverse proxies, etc.
+    vite_allowed_hosts: bool | list[str] = False
+
     # Whether to use React strict mode.
     react_strict_mode: bool = True
 
@@ -254,8 +259,8 @@ class BaseConfig:
     # List of plugins to use in the app.
     plugins: list[Plugin] = dataclasses.field(default_factory=list)
 
-    # List of fully qualified import paths of plugins to disable in the app (e.g. reflex.plugins.sitemap.SitemapPlugin).
-    disable_plugins: list[str] = dataclasses.field(default_factory=list)
+    # List of plugin types to disable in the app.
+    disable_plugins: list[type[Plugin]] = dataclasses.field(default_factory=list)
 
     # The transport method for client-server communication.
     transport: Literal["websocket", "polling"] = "websocket"
@@ -353,6 +358,9 @@ def _post_init(self, **kwargs):
         for key, env_value in env_kwargs.items():
             setattr(self, key, env_value)
 
+        # Normalize disable_plugins: convert strings and Plugin subclasses to instances.
+        self._normalize_disable_plugins()
+
         # Add builtin plugins if not disabled.
         if not self._skip_plugins_checks:
             self._add_builtin_plugins()
@@ -369,16 +377,52 @@ def _post_init(self, **kwargs):
             msg = f"{self._prefixes[0]}REDIS_URL is required when using the redis state manager."
             raise ConfigError(msg)
 
+    def _normalize_disable_plugins(self):
+        """Normalize disable_plugins list entries to Plugin subclasses.
+
+        Handles backward compatibility by converting strings (fully qualified
+        import paths) and Plugin instances to their associated classes.
+        """
+        normalized: list[type[Plugin]] = []
+        for entry in self.disable_plugins:
+            if isinstance(entry, type) and issubclass(entry, Plugin):
+                normalized.append(entry)
+            elif isinstance(entry, Plugin):
+                normalized.append(type(entry))
+            elif isinstance(entry, str):
+                console.deprecate(
+                    feature_name="Passing strings to disable_plugins",
+                    reason="pass Plugin classes directly instead, e.g. disable_plugins=[SitemapPlugin]",
+                    deprecation_version="0.8.28",
+                    removal_version="0.9.0",
+                )
+                try:
+                    from reflex.environment import interpret_plugin_class_env
+
+                    normalized.append(
+                        interpret_plugin_class_env(entry, "disable_plugins")
+                    )
+                except Exception:
+                    console.warn(
+                        f"Failed to import plugin from string {entry!r} in disable_plugins. "
+                        "Please pass Plugin subclasses directly.",
+                    )
+            else:
+                console.warn(
+                    f"reflex.Config.disable_plugins should contain Plugin subclasses, but got {entry!r}.",
+                )
+        self.disable_plugins = normalized
+
     def _add_builtin_plugins(self):
         """Add the builtin plugins to the config."""
         for plugin in _PLUGINS_ENABLED_BY_DEFAULT:
             plugin_name = plugin.__module__ + "." + plugin.__qualname__
-            if plugin_name not in self.disable_plugins:
+            if plugin not in self.disable_plugins:
                 if not any(isinstance(p, plugin) for p in self.plugins):
                     console.warn(
                         f"`{plugin_name}` plugin is enabled by default, but not explicitly added to the config. "
                         "If you want to use it, please add it to the `plugins` list in your config inside of `rxconfig.py`. "
-                        f"To disable this plugin, set `disable_plugins` to `{[plugin_name, *self.disable_plugins]!r}`.",
+                        f"To disable this plugin, add `{plugin.__name__}` to the `disable_plugins` list.",
                     )
                     self.plugins.append(plugin())
             else:
@@ -389,16 +433,9 @@ def _add_builtin_plugins(self):
                     )
 
         for disabled_plugin in self.disable_plugins:
-            if not isinstance(disabled_plugin, str):
-                console.warn(
-                    f"reflex.Config.disable_plugins should only contain strings, but got {disabled_plugin!r}. "
-                )
-            if not any(
-                plugin.__module__ + "." + plugin.__qualname__ == disabled_plugin
-                for plugin in _PLUGINS_ENABLED_BY_DEFAULT
-            ):
+            if disabled_plugin not in _PLUGINS_ENABLED_BY_DEFAULT:
                 console.warn(
-                    f"`{disabled_plugin}` is disabled in the config, but it is not a built-in plugin. "
+                    f"`{disabled_plugin!r}` is disabled in the config, but it is not a built-in plugin. "
                     "Please remove it from the `disable_plugins` list in your config inside of `rxconfig.py`.",
                 )
 

reflex/constants/installer.py

@@ -106,7 +106,20 @@ class Commands(SimpleNamespace):
 
         DEV = "react-router dev --host"
         EXPORT = "react-router build"
-        PROD = "sirv ./build/client --single 404.html --host"
+
+        @staticmethod
+        def get_prod_command(frontend_path: str = "") -> str:
+            """Get the prod command with the correct 404.html path for the given frontend_path.
+
+            Args:
+                frontend_path: The frontend path prefix (e.g. "/app").
+
+            Returns:
+                The sirv command with the correct --single fallback path.
+            """
+            stripped = frontend_path.strip("/")
+            fallback = f"{stripped}/404.html" if stripped else "404.html"
+            return f"sirv ./build/client --single {fallback} --host"
 
     PATH = "package.json"
 

reflex/environment.py

@@ -149,15 +149,17 @@ def interpret_path_env(value: str, field_name: str) -> Path:
     return Path(value)
 
 
-def interpret_plugin_env(value: str, field_name: str) -> Plugin:
-    """Interpret a plugin environment variable value.
+def interpret_plugin_class_env(value: str, field_name: str) -> type[Plugin]:
+    """Interpret an environment variable value as a Plugin subclass.
+
+    Resolves a fully qualified import path to the Plugin subclass it refers to.
 
     Args:
-        value: The environment variable value.
+        value: The environment variable value (e.g. "reflex.plugins.sitemap.SitemapPlugin").
         field_name: The field name.
 
     Returns:
-        The interpreted value.
+        The Plugin subclass.
 
     Raises:
         EnvironmentVarValueError: If the value is invalid.
@@ -184,10 +186,30 @@ def interpret_plugin_env(value: str, field_name: str) -> Plugin:
         msg = f"Invalid plugin class: {plugin_name!r} for {field_name}. Must be a subclass of Plugin."
         raise EnvironmentVarValueError(msg)
 
+    return plugin_class
+
+
+def interpret_plugin_env(value: str, field_name: str) -> Plugin:
+    """Interpret a plugin environment variable value.
+
+    Resolves a fully qualified import path and returns an instance of the Plugin.
+
+    Args:
+        value: The environment variable value (e.g. "reflex.plugins.sitemap.SitemapPlugin").
+        field_name: The field name.
+
+    Returns:
+        An instance of the Plugin subclass.
+
+    Raises:
+        EnvironmentVarValueError: If the value is invalid.
+    """
+    plugin_class = interpret_plugin_class_env(value, field_name)
+
     try:
         return plugin_class()
     except Exception as e:
-        msg = f"Failed to instantiate plugin {plugin_name!r} for {field_name}: {e}"
+        msg = f"Failed to instantiate plugin {plugin_class.__name__!r} for {field_name}: {e}"
         raise EnvironmentVarValueError(msg) from e
 
 
@@ -243,8 +265,14 @@ def interpret_env_var_value(
     field_type = value_inside_optional(field_type)
 
     if is_union(field_type):
-        msg = f"Union types are not supported for environment variables: {field_name}."
-        raise ValueError(msg)
+        errors = []
+        for arg in (union_types := get_args(field_type)):
+            try:
+                return interpret_env_var_value(value, arg, field_name)
+            except (ValueError, EnvironmentVarValueError) as e:  # noqa: PERF203
+                errors.append(e)
+        msg = f"Could not interpret {value!r} for {field_name} as any of {union_types}: {errors}"
+        raise EnvironmentVarValueError(msg)
 
     value = value.strip()
 
@@ -268,6 +296,14 @@ def interpret_env_var_value(
         return interpret_existing_path_env(value, field_name)
     if field_type is Plugin:
         return interpret_plugin_env(value, field_name)
+    if get_origin(field_type) is type:
+        type_args = get_args(field_type)
+        if (
+            type_args
+            and isinstance(type_args[0], type)
+            and issubclass(type_args[0], Plugin)
+        ):
+            return interpret_plugin_class_env(value, field_name)
     if get_origin(field_type) is Literal:
         literal_values = get_args(field_type)
         for literal_value in literal_values:

reflex/istate/proxy.py

@@ -8,6 +8,7 @@
 import functools
 import inspect
 import json
+import sys
 from collections.abc import Callable, Sequence
 from importlib.util import find_spec
 from types import MethodType
@@ -132,15 +133,20 @@ async def __aenter__(self) -> Self:
             raise ImmutableStateError(msg)
 
         await self._self_actx_lock.acquire()
-        self._self_actx_lock_holder = current_task
-        self._self_actx = self._self_app.modify_state(
-            token=self._self_substate_token, background=True
-        )
-        mutable_state = await self._self_actx.__aenter__()
-        super().__setattr__(
-            "__wrapped__", mutable_state.get_substate(self._self_substate_path)
-        )
-        self._self_mutable = True
+        try:
+            self._self_actx_lock_holder = current_task
+            self._self_actx = self._self_app.modify_state(
+                token=self._self_substate_token, background=True
+            )
+            mutable_state = await self._self_actx.__aenter__()
+            self._self_mutable = True
+            super().__setattr__(
+                "__wrapped__", mutable_state.get_substate(self._self_substate_path)
+            )
+        except (Exception, asyncio.CancelledError):
+            # Restore the proxy to a consistent state since __aexit__ will not be called when __aenter__ raises.
+            await self.__aexit__(*sys.exc_info())
+            raise
         return self
 
     async def __aexit__(self, *exc_info: Any) -> None:
@@ -154,15 +160,14 @@ async def __aexit__(self, *exc_info: Any) -> None:
         if self._self_parent_state_proxy is not None:
             await self._self_parent_state_proxy.__aexit__(*exc_info)
             return
-        if self._self_actx is None:
-            return
-        self._self_mutable = False
         try:
-            await self._self_actx.__aexit__(*exc_info)
+            if self._self_mutable and self._self_actx is not None:
+                await self._self_actx.__aexit__(*exc_info)
         finally:
+            self._self_actx = None
+            self._self_mutable = False
             self._self_actx_lock_holder = None
             self._self_actx_lock.release()
-        self._self_actx = None
 
     def __enter__(self):
         """Enter the regular context manager protocol.
@@ -572,6 +577,8 @@ def __getattr__(self, __name: str) -> Any:
                 )
                 and (func := getattr(value, "__func__", None)) is not None
                 and not inspect.isclass(getattr(value, "__self__", None))
+                # skip SQLAlchemy instrumented methods
+                and not getattr(value, "_sa_instrumented", False)
             ):
                 # Rebind `self` to the proxy on methods to capture nested mutations.
                 return functools.partial(func, self)