lex-app 2.3.3__tar.gz → 2.3.4__tar.gz

{lex_app-2.3.3/lex_app.egg-info → lex_app-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lex-app
-Version: 2.3.3
+Version: 2.3.4
 Summary: A Python / Django library to create business applications easily with complex logic
 Author-email: Melih Sünbül <m.sunbul@excellence-cloud.com>
 License-Expression: MIT

lex_app-2.3.4/lex/_version.py

@@ -0,0 +1 @@
+__version__ = "2.3.4"

{lex_app-2.3.3 → lex_app-2.3.4}/lex/lex_app/reflex/config.py

@@ -81,22 +81,29 @@ def _make_app_module_findable() -> None:
 
 
 def _repair_single_port_proxy() -> None:
-    """Hand Reflex Enterprise's single-port proxy the Starlette app it is written for.
+    """Mount Reflex Enterprise's single-port proxy on the Reflex backend itself.
 
     ``use_single_port`` (``REFLEX_USE_SINGLE_PORT``) has the backend answer its
     own routes and pass every other request to the frontend server, so that a
     development run -- two servers -- works behind the one port a pod exposes.
-    reflex-enterprise 0.9.6 registers that proxy as a lifespan task whose
-    parameter is named ``app``, and Reflex 0.9.12 passes a task the *Reflex*
-    app under that name, the Starlette app only as ``starlette_app``. The proxy
-    then finds nothing to mount on, logs "Unable to find the base Starlette
-    app", and every page 404s.
-
-    Reflex Enterprise imports the proxy when it builds the app, after
-    ``rxconfig.py`` has run, so replacing the module's function is enough. Only
-    a proxy taking ``app`` and not ``starlette_app`` is replaced; the rest are
-    left alone -- one already asking for ``starlette_app``, the stand-in Reflex
-    Enterprise defines when asgiproxy is missing, and this replacement itself.
+    reflex-enterprise 0.9.6 never manages it on Reflex 0.9.12:
+
+    * its lifespan task names its parameter ``app``, and Reflex passes the
+      *Reflex* app under that name (the Starlette app only as
+      ``starlette_app``), so it logs "Unable to find the base Starlette app";
+    * given the Starlette app, it mounts on the outermost one, and Reflex
+      reaches its backend through a catch-all ``Mount("")`` there. Behind an
+      ``api_transformer`` that wraps the backend in ASGI middleware (RFDS's
+      security headers do), the proxy lands after that mount and is never
+      reached. Every page 404s either way.
+
+    So the replacement takes the Reflex app and hands the proxy its backend,
+    ``app._api`` -- where Reflex itself mounts a compiled frontend -- inside
+    every wrapper, after every backend route. Reflex Enterprise imports the
+    proxy when it builds the app, after ``rxconfig.py`` has run, so replacing
+    the module's function is enough. The stand-in Reflex Enterprise defines
+    when asgiproxy is missing, which names no parameter, is left alone, and so
+    is this replacement itself.
     """
     import contextlib
     import inspect
@@ -104,15 +111,17 @@ def _repair_single_port_proxy() -> None:
     from reflex_enterprise import proxy
 
     upstream = proxy.proxy_middleware
-    parameters = inspect.signature(upstream).parameters
-    if "app" not in parameters or "starlette_app" in parameters:
+    if getattr(upstream, "lex_mounts_on_backend", False):
+        return
+    if not {"app", "starlette_app"} & set(inspect.signature(upstream).parameters):
         return
 
     @contextlib.asynccontextmanager
-    async def proxy_middleware(starlette_app):
-        async with upstream(starlette_app):
+    async def proxy_middleware(app):
+        async with upstream(app._api):
             yield
 
+    proxy_middleware.lex_mounts_on_backend = True
     proxy.proxy_middleware = proxy_middleware
 
 

{lex_app-2.3.3 → lex_app-2.3.4}/lex/test_project/tests/init/test_1at_reflex_single_port_proxy.py

@@ -11,16 +11,19 @@ platform starts a project's dashboards. On reflex-enterprise 0.9.6 with Reflex
 0.9.12 the mode did nothing but log "Unable to find the base Starlette app":
 Reflex passes a lifespan task the Reflex app under a parameter named ``app`` and
 the Starlette app only as ``starlette_app``, and the proxy names its parameter
-``app``. lex-app hands it the Starlette app, so:
+``app``. Handed the Starlette app, it mounts on the outermost one, where Reflex
+reaches its backend through a catch-all mount -- behind an ``api_transformer``
+that wraps the backend in middleware, as RFDS's security headers do, the proxy
+is never reached. lex-app mounts it on the Reflex backend itself, so:
 
 * a project's ``rxconfig.py`` repairs the proxy as Reflex loads it --
   ``lex_config()`` in the one ``lex reflex`` writes, ``lex_auth_plugin()`` in a
   hand-written one -- and the configuration is still the project's;
-* run the way Reflex runs it, the backend's port answers the backend's routes
-  itself and every other path, query string included, from the frontend server;
-* repairing again changes nothing, and a proxy that already takes the
-  Starlette app -- a fixed Reflex Enterprise -- or names no ``app`` parameter is
-  left exactly as it is.
+* run the way Reflex runs it, with or without middleware around the backend,
+  the backend's port answers the backend's routes itself and every other path,
+  query string included, from the frontend server;
+* repairing again changes nothing, and the stand-in Reflex Enterprise defines
+  without asgiproxy is left exactly as it is.
 
 A regression reads as "the dashboard's URL answers /ping and 404s every page".
 
@@ -79,7 +82,7 @@ _LOAD_CONFIG = (
     "config = get_config()\n"
     "from reflex_enterprise import proxy\n"
     "print(config.app_name, config.module,\n"
-    "      ','.join(inspect.signature(proxy.proxy_middleware).parameters))\n"
+    "      getattr(proxy.proxy_middleware, 'lex_mounts_on_backend', False))\n"
 )
 
 
@@ -146,7 +149,7 @@ class TestCluster01at_SinglePortProxy(TestCase):
                interpreter -- the way every Reflex worker starts.
         When:  Reflex loads the configuration, before it would build the app.
         Then:  the configuration is the project's own, and Reflex Enterprise's
-               proxy takes ``starlette_app``, the Starlette app Reflex passes.
+               proxy is lex-app's, which mounts on the Reflex backend.
         """
         from lex.bin.lex import _ensure_reflex_config
 
@@ -165,82 +168,89 @@ class TestCluster01at_SinglePortProxy(TestCase):
                     timeout=300, cwd=tmp,
                 )
                 self.assertEqual(result.returncode, 0, msg=result.stderr[-2000:])
-                app_name, loaded_module, parameters = result.stdout.strip().splitlines()[-1].split()
+                app_name, loaded_module, repaired = result.stdout.strip().splitlines()[-1].split()
                 self.assertEqual(
                     loaded_module, app_module, f"Reflex must still load the project's configuration ({case})",
                 )
                 self.assertNotEqual(app_name, "", "the configuration names the app")
-                self.assertEqual(
-                    parameters, "starlette_app",
-                    f"rxconfig.py ({case}) must leave the proxy taking the Starlette app, not the Reflex app",
-                )
+                self.assertEqual(repaired, "True", f"rxconfig.py ({case}) must leave lex-app's proxy in place")
 
     # -- 1.382 ---------------------------------------------------------
     def test_1_382_one_port_answers_the_backend_routes_and_proxies_every_page(self) -> None:
         """
         Scenario 1.382: run the way Reflex runs it, one port serves the backend and the pages.
         Given: a frontend server on its own port, a single-port configuration,
-               and Reflex Enterprise's proxy as it ships, once rxconfig.py has
-               built lex-app's sign-in plugin.
+               Reflex Enterprise's proxy as it ships once rxconfig.py has built
+               lex-app's sign-in plugin, and the backend assembled as Reflex
+               assembles it -- mounted under a catch-all in the outermost app,
+               bare or wrapped in ASGI middleware by an ``api_transformer``.
         When:  Reflex Enterprise registers the proxy, as it does when it builds
-               the app; Reflex runs its lifespan tasks for the backend's
-               Starlette app; and a browser asks the backend's port for
-               ``/ping`` and for a page.
+               the app; Reflex runs its lifespan tasks; and a browser asks the
+               backend's port for ``/ping`` and for a page.
         Then:  ``/ping`` is the backend's own answer, and the page -- its path
-               and query string -- is the frontend server's.
+               and query string -- is the frontend server's, through the
+               middleware when there is some.
         """
-        # In a directory of its own: Reflex Enterprise's registration notes its session in `.web/` under the cwd.
-        with tempfile.TemporaryDirectory() as tmp, contextlib.chdir(tmp), \
-                _frontend_server() as frontend_port, _shipped_proxy(), _clean_reflex_env():
-            self.assertEqual(_parameters(proxy.proxy_middleware), ["app"], "the proxy as reflex-enterprise ships it")
-            lex_auth_plugin()
 
-            config = rxe.Config(
-                app_name="single_port_probe", use_single_port=True,
-                frontend_port=frontend_port, backend_port=frontend_port + 1,
-            )
-            reflex_app = LifespanMixin()
-            with patch("reflex_enterprise.app.get_config", return_value=config), \
-                    patch("reflex_enterprise.proxy.get_config", return_value=config):
-                AppEnterprise._verify_and_setup_proxy(reflex_app)
-                self.assertEqual(
-                    len(reflex_app.get_lifespan_tasks()), 1, "single-port mode registers its proxy as a lifespan task",
+        def wrapped(inner):
+            async def middleware(scope, receive, send):
+                if scope["type"] != "http":
+                    return await inner(scope, receive, send)
+
+                async def marked(message):
+                    if message["type"] == "http.response.start":
+                        message = {**message, "headers": [*message.get("headers", []), (b"x-wrapped", b"yes")]}
+                    await send(message)
+
+                await inner(scope, receive, marked)
+
+            return middleware
+
+        for case, transform in {"bare": None, "wrapped in middleware": wrapped}.items():
+            # In a directory of its own: Reflex Enterprise's registration notes its session in `.web/` under the cwd.
+            with self.subTest(backend=case), tempfile.TemporaryDirectory() as tmp, contextlib.chdir(tmp), \
+                    _frontend_server() as frontend_port, _shipped_proxy(), _clean_reflex_env():
+                self.assertEqual(_parameters(proxy.proxy_middleware), ["app"], "the proxy as it ships")
+                lex_auth_plugin()
+
+                config = rxe.Config(
+                    app_name="single_port_probe", use_single_port=True,
+                    frontend_port=frontend_port, backend_port=frontend_port + 1,
                 )
-                backend = Starlette(
-                    routes=[Route("/ping", lambda request: PlainTextResponse("pong"))],
-                    lifespan=reflex_app._run_lifespan_tasks,
+                reflex_app = LifespanMixin()
+                reflex_app._api = Starlette(routes=[Route("/ping", lambda request: PlainTextResponse("pong"))])
+                with patch("reflex_enterprise.app.get_config", return_value=config), \
+                        patch("reflex_enterprise.proxy.get_config", return_value=config):
+                    AppEnterprise._verify_and_setup_proxy(reflex_app)
+                    self.assertEqual(len(reflex_app.get_lifespan_tasks()), 1, "one lifespan task: the proxy")
+                    # What `reflex.app.App.__call__` builds: the backend, transformed, under a catch-all mount.
+                    backend = reflex_app._api if transform is None else transform(reflex_app._api)
+                    outermost = Starlette(lifespan=reflex_app._run_lifespan_tasks)
+                    outermost.mount("", backend)
+                    with TestClient(outermost) as browser:
+                        ping = browser.get("/ping")
+                        page = browser.get("/funds/42?tab=history")
+
+                self.assertEqual((ping.status_code, ping.text), (200, "pong"), "a backend route is the backend's")
+                self.assertEqual(
+                    (page.status_code, page.text), (200, "frontend:/funds/42?tab=history"),
+                    f"every other path must reach the frontend server through the backend's port ({case})",
                 )
-                with TestClient(backend) as browser:
-                    ping = browser.get("/ping")
-                    page = browser.get("/funds/42?tab=history")
-
-        self.assertEqual((ping.status_code, ping.text), (200, "pong"), "a backend route is answered by the backend")
-        self.assertEqual(
-            (page.status_code, page.text), (200, "frontend:/funds/42?tab=history"),
-            "every other path must reach the frontend server through the backend's port",
-        )
+                if transform is not None:
+                    self.assertEqual(page.headers.get("x-wrapped"), "yes", "a proxied page passes the middleware")
 
     # -- 1.383 ---------------------------------------------------------
     def test_1_383_repairing_again_or_a_proxy_that_needs_no_repair_changes_nothing(self) -> None:
         """
-        Scenario 1.383: the repair applies once, and only to a proxy that needs it.
-        Given: the proxy as it ships, already repaired once; and proxies that
-               need no repair -- one taking ``starlette_app`` as a fixed Reflex
-               Enterprise would, one taking both names, and the stand-in Reflex
-               Enterprise defines without asgiproxy, which names none.
+        Scenario 1.383: the repair applies once, and not to the stand-in.
+        Given: the proxy as it ships, already repaired once; and the stand-in
+               Reflex Enterprise defines without asgiproxy, which names no
+               parameter.
         When:  ``lex_auth_plugin()`` builds the sign-in plugin again, as a
                reloaded configuration does.
         Then:  each proxy is left exactly as it was.
         """
 
-        @contextlib.asynccontextmanager
-        async def fixed(starlette_app):
-            yield
-
-        @contextlib.asynccontextmanager
-        async def both(app, starlette_app):
-            yield
-
         @contextlib.asynccontextmanager
         async def stand_in(*args, **kwargs):
             yield
@@ -248,11 +258,11 @@ class TestCluster01at_SinglePortProxy(TestCase):
         with _shipped_proxy():
             lex_auth_plugin()
             repaired = proxy.proxy_middleware
-            self.assertEqual(_parameters(repaired), ["starlette_app"], "the first build repairs the proxy")
+            self.assertTrue(getattr(repaired, "lex_mounts_on_backend", False), "the first build repairs the proxy")
+            self.assertEqual(_parameters(repaired), ["app"], "it takes the Reflex app, whose backend it mounts on")
             lex_auth_plugin()
             self.assertIs(proxy.proxy_middleware, repaired, "a second build must not wrap the repair again")
 
-            for name, upstream in {"fixed": fixed, "both": both, "stand-in": stand_in}.items():
-                with self.subTest(proxy=name), patch.object(proxy, "proxy_middleware", upstream):
-                    lex_auth_plugin()
-                    self.assertIs(proxy.proxy_middleware, upstream, f"a {name} proxy needs no repair")
+            with patch.object(proxy, "proxy_middleware", stand_in):
+                lex_auth_plugin()
+                self.assertIs(proxy.proxy_middleware, stand_in, "the stand-in without asgiproxy needs no repair")

{lex_app-2.3.3 → lex_app-2.3.4/lex_app.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lex-app
-Version: 2.3.3
+Version: 2.3.4
 Summary: A Python / Django library to create business applications easily with complex logic
 Author-email: Melih Sünbül <m.sunbul@excellence-cloud.com>
 License-Expression: MIT

lex_app-2.3.3/lex/_version.py

@@ -1 +0,0 @@
-__version__ = "2.3.3"