Merge remote-tracking branch 'upstream/main' into sqla-mutable-proxy

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/assets.py

@@ -92,6 +92,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

@@ -502,6 +502,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.
 
@@ -511,10 +512,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";
@@ -586,7 +594,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/utils/frontend_skeleton.py

@@ -168,11 +168,14 @@ def _update_react_router_config(config: Config, prerender_routes: bool = False):
 
 
 def _compile_package_json():
+    config = get_config()
     return templates.package_json_template(
         scripts={
             "dev": constants.PackageJson.Commands.DEV,
             "export": constants.PackageJson.Commands.EXPORT,
-            "prod": constants.PackageJson.Commands.PROD,
+            "prod": constants.PackageJson.Commands.get_prod_command(
+                config.frontend_path
+            ),
         },
         dependencies=constants.PackageJson.DEPENDENCIES,
         dev_dependencies=constants.PackageJson.DEV_DEPENDENCIES,
@@ -197,6 +200,7 @@ def _compile_vite_config(config: Config):
         force_full_reload=environment.VITE_FORCE_FULL_RELOAD.get(),
         experimental_hmr=environment.VITE_EXPERIMENTAL_HMR.get(),
         sourcemap=environment.VITE_SOURCEMAP.get(),
+        allowed_hosts=config.vite_allowed_hosts,
     )
 
 

tests/units/test_config.py

@@ -17,6 +17,8 @@
     interpret_enum_env,
     interpret_int_env,
 )
+from reflex.plugins import Plugin
+from reflex.plugins.sitemap import SitemapPlugin
 
 
 def test_requires_app_name():
@@ -402,3 +404,61 @@ def test_env_file(
     )
     for key, value in exp_env_vars.items():
         assert os.environ.get(key) == value
+
+
+class TestDisablePlugins:
+    """Tests for the disable_plugins config option."""
+
+    def test_disable_with_plugin_class(self):
+        """Test disabling a plugin by passing the class (type)."""
+        config = rx.Config(app_name="test", disable_plugins=[SitemapPlugin])
+        assert not any(isinstance(p, SitemapPlugin) for p in config.plugins)
+
+    def test_disable_with_plugin_instance_backward_compat(self):
+        """Test disabling a plugin by passing an instance (deprecated)."""
+        config = rx.Config(app_name="test", disable_plugins=[SitemapPlugin()])  # pyright: ignore[reportArgumentType]
+        assert not any(isinstance(p, SitemapPlugin) for p in config.plugins)
+
+    def test_disable_with_string_backward_compat(self):
+        """Test disabling a plugin by passing a string (deprecated)."""
+        config = rx.Config(
+            app_name="test",
+            disable_plugins=["reflex.plugins.sitemap.SitemapPlugin"],  # pyright: ignore[reportArgumentType]
+        )
+        assert not any(isinstance(p, SitemapPlugin) for p in config.plugins)
+
+    def test_disable_plugins_normalized_to_classes(self):
+        """Test that disable_plugins entries are normalized to Plugin subclasses."""
+        config = rx.Config(app_name="test", disable_plugins=[SitemapPlugin])
+        assert all(
+            isinstance(dp, type) and issubclass(dp, Plugin)
+            for dp in config.disable_plugins
+        )
+
+    def test_disable_instance_normalized_to_class(self):
+        """Test that a Plugin instance in disable_plugins is normalized to its class."""
+        config = rx.Config(app_name="test", disable_plugins=[SitemapPlugin()])  # pyright: ignore[reportArgumentType]
+        assert config.disable_plugins == [SitemapPlugin]
+
+    def test_disable_string_normalized_to_class(self):
+        """Test that a string in disable_plugins is normalized to the class."""
+        config = rx.Config(
+            app_name="test",
+            disable_plugins=["reflex.plugins.sitemap.SitemapPlugin"],  # pyright: ignore[reportArgumentType]
+        )
+        assert config.disable_plugins == [SitemapPlugin]
+
+    def test_disable_and_plugins_conflict_warns(self):
+        """Test that a warning is issued when a plugin is both enabled and disabled."""
+        config = rx.Config(
+            app_name="test",
+            plugins=[SitemapPlugin()],
+            disable_plugins=[SitemapPlugin],
+        )
+        # Plugin should still be in plugins list (just warned)
+        assert any(isinstance(p, SitemapPlugin) for p in config.plugins)
+
+    def test_no_disable_adds_builtin(self):
+        """Test that builtin plugins are added when not disabled."""
+        config = rx.Config(app_name="test")
+        assert any(isinstance(p, SitemapPlugin) for p in config.plugins)