reflex 0.9.8a2__tar.gz → 0.9.8a3__tar.gz

{reflex-0.9.8a2 → reflex-0.9.8a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.9.8a2
+Version: 0.9.8a3
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex
@@ -28,7 +28,7 @@ Requires-Dist: psutil<8.0,>=7.0.0; sys_platform == 'win32'
 Requires-Dist: python-multipart<1.0,>=0.0.32
 Requires-Dist: python-socketio<6.0,>=5.12.0
 Requires-Dist: redis<8.0,>=6.4
-Requires-Dist: reflex-base==0.9.8a2
+Requires-Dist: reflex-base==0.9.8a3
 Requires-Dist: reflex-components-code>=0.9.0
 Requires-Dist: reflex-components-core>=0.9.6
 Requires-Dist: reflex-components-dataeditor>=0.9.0

{reflex-0.9.8a2 → reflex-0.9.8a3}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
   "starlette >=1.3.1",
   "typing_extensions >=4.13.0",
   "wrapt >=1.17.0,<2.2",
-  "reflex-base == 0.9.8a2",
+  "reflex-base == 0.9.8a3",
   "reflex-components-code >= 0.9.0",
   "reflex-components-core >= 0.9.6",
   "reflex-components-dataeditor >= 0.9.0",

{reflex-0.9.8a2 → reflex-0.9.8a3}/reflex/utils/frontend_skeleton.py

@@ -407,32 +407,42 @@ def sync_web_lockfiles_to_root():
         sync_web_lockfile_to_root(name)
 
 
-def _read_persisted_package_json() -> dict:
-    """Read the persisted package.json from the app root.
+def _read_package_json_object(package_json_path: Path) -> dict:
+    """Read a package.json file as a JSON object.
+
+    Args:
+        package_json_path: The package.json file to read.
 
     Returns:
         The parsed JSON object, or an empty dict if the file is missing,
         cannot be parsed, or is not a JSON object.
     """
-    root_package_json_path = get_root_lockfile_path(constants.PackageJson.PATH)
-    if not root_package_json_path.exists():
+    if not package_json_path.exists():
         return {}
     try:
-        parsed = json.loads(root_package_json_path.read_text())
+        parsed = json.loads(package_json_path.read_text())
     except (json.JSONDecodeError, OSError) as e:
-        console.warn(
-            f"Failed to read {root_package_json_path}: {e}; starting with empty dependency lists."
-        )
+        console.warn(f"Failed to read {package_json_path}: {e}; treating it as empty.")
         return {}
     if not isinstance(parsed, dict):
         console.warn(
-            f"Expected {root_package_json_path} to contain a JSON object, "
-            f"got {type(parsed).__name__}; starting with empty dependency lists."
+            f"Expected {package_json_path} to contain a JSON object, "
+            f"got {type(parsed).__name__}; treating it as empty."
         )
         return {}
     return parsed
 
 
+def _read_persisted_package_json() -> dict:
+    """Read the persisted package.json from the app root.
+
+    Returns:
+        The parsed JSON object, or an empty dict if the file is missing,
+        cannot be parsed, or is not a JSON object.
+    """
+    return _read_package_json_object(get_root_lockfile_path(constants.PackageJson.PATH))
+
+
 def initialize_web_directory():
     """Initialize the web directory on reflex init."""
     console.log("Initializing the web directory.")
@@ -522,12 +532,16 @@ def _compile_package_json():
     ``reflex.lock/package.json`` (when present) so resolved version pins
     survive a fresh ``reflex init``. User-added ``scripts`` are preserved;
     only the framework-owned ``dev`` and ``export`` entries are refreshed
-    from constants. User-added ``overrides`` are kept, with the
-    framework-owned entries refreshed on top. Any other persisted fields
-    (e.g. ``packageManager``, ``engines``) are passed through unchanged.
-    The framework-managed entries in ``constants.PackageJson.DEPENDENCIES``
-    / ``DEV_DEPENDENCIES`` are added later at install time via ``bun add``
-    so they pick up strict pins.
+    from constants. Any other persisted fields (e.g. ``packageManager``,
+    ``engines``) are passed through unchanged.
+
+    Everything a lockfile resolves against is reproduced verbatim, so the
+    rendered file still pairs with the persisted lockfile: the framework
+    entries in ``constants.PackageJson.DEPENDENCIES`` / ``DEV_DEPENDENCIES``
+    are added later at install time via ``bun add`` (picking up strict pins),
+    and ``overrides`` are carried over as persisted, with
+    ``constants.PackageJson.OVERRIDES`` merged in by
+    :func:`update_package_json_overrides` after the frozen install.
 
     Returns:
         Rendered package.json content as string.
@@ -542,14 +556,47 @@ def _compile_package_json():
         scripts=scripts,
         dependencies=persisted.pop("dependencies", None) or {},
         dev_dependencies=persisted.pop("devDependencies", None) or {},
-        overrides={
-            **(persisted.pop("overrides", None) or {}),
-            **constants.PackageJson.OVERRIDES,
-        },
+        overrides=persisted.pop("overrides", None) or {},
         **persisted,
     )
 
 
+def update_package_json_overrides() -> bool:
+    """Merge the framework-owned overrides into ``.web/package.json``.
+
+    ``overrides`` participate in dependency resolution, so injecting them
+    while restoring the persisted ``package.json`` would desync it from the
+    persisted lockfile and make ``--frozen-lockfile`` fail outright on any
+    Reflex upgrade that introduces a new override. Applying them here instead
+    keeps the restored pair intact for the frozen install; the caller
+    refreshes the lockfile afterwards.
+
+    User-added and previously resolved overrides are kept, with the
+    framework-owned entries taking precedence on conflict.
+
+    Returns:
+        Whether ``.web/package.json`` was changed.
+    """
+    package_json_path = get_web_lockfile_path(constants.PackageJson.PATH)
+    package_json = _read_package_json_object(package_json_path)
+    if not package_json:
+        # Nothing usable to merge into. initialize_package_json() renders a
+        # full file upstream, so this only happens for a hand-damaged .web.
+        return False
+
+    overrides = package_json.get("overrides") or {}
+    if all(
+        overrides.get(name) == version
+        for name, version in constants.PackageJson.OVERRIDES.items()
+    ):
+        return False
+
+    package_json["overrides"] = {**overrides, **constants.PackageJson.OVERRIDES}
+    console.debug(f"Applying framework overrides to {package_json_path}")
+    package_json_path.write_text(json.dumps(package_json))
+    return True
+
+
 def initialize_package_json():
     """Render and write in .web the package.json file."""
     output_path = get_web_dir() / constants.PackageJson.PATH

{reflex-0.9.8a2 → reflex-0.9.8a3}/reflex/utils/js_runtimes.py

@@ -589,7 +589,8 @@ def _frontend_packages_cache_payload(
     return (
         f"{sorted(packages)!r},{config.json()},{list(install_package_managers)!r},"
         f"{sorted(constants.PackageJson.DEPENDENCIES.items())!r},"
-        f"{sorted(constants.PackageJson.DEV_DEPENDENCIES.items())!r}"
+        f"{sorted(constants.PackageJson.DEV_DEPENDENCIES.items())!r},"
+        f"{sorted(constants.PackageJson.OVERRIDES.items())!r}"
     )
 
 
@@ -706,6 +707,11 @@ def _install_frontend_packages(
     ):
         _run_initial_install(primary_package_manager, env, config.frozen_lockfile)
 
+    # Framework overrides are withheld while the persisted package.json is
+    # restored so the frozen install above sees exactly the file that produced
+    # the persisted lockfile. Merge them now, before any resolution happens.
+    overrides_changed = frontend_skeleton.update_package_json_overrides()
+
     pinned_packages, unpinned_packages = _split_by_version_specifier(packages)
     pinned_dev_deps, unpinned_dev_deps = _split_by_version_specifier(development_deps)
 
@@ -754,6 +760,14 @@ def _install_frontend_packages(
             show_status_message="Installing frontend packages",
         )
 
+    if overrides_changed and not (dev_deps_to_add or deps_to_add):
+        # Newly merged overrides with no add to carry them into the lockfile:
+        # resolve them now so the persisted pair stays frozen-install ready.
+        run_package_manager(
+            [primary_package_manager, "install", "--legacy-peer-deps"],
+            show_status_message="Applying frontend package overrides",
+        )
+
 
 def install_frontend_packages(packages: set[str], config: Config):
     """Install frontend packages while respecting the canonical root bun.lock."""