🐛 fix(web): expose loader failures (#1860)

* 🐛 fix(web): expose loader failures

Deserialize browser responses into strict endpoint wire types so malformed or
failed requests cannot become valid empty UI models.

Keep the last loaded data visible while displaying the bounded loader error.

Refs #1358

* 🧪 test(web): cover loader failure state

CI caught six untested error-formatting lines and one retained-state branch.
The missing cases left the refresh failure contract unverified in native builds.

Table-driven message cases cover each error kind. A state transition test
verifies that a failed refresh reports the error while preserving the prior
value.

Author: gaborbernat

crates/peryx-ecosystem-pypi/tests/frontend/tests/ui.spec.mjs

@@ -387,7 +387,7 @@ test("admin table shows upstream and upload state per index", async ({
   await expect(table.locator("[class*='badge upload-']").first()).toBeVisible();
 });
 
-test("admin status is read-only and tolerates failed stats fetches", async ({
+test("admin status is read-only and reports failed stats fetches", async ({
   page,
 }) => {
   await operatorPage(page);
@@ -430,9 +430,10 @@ test("admin status is read-only and tolerates failed stats fetches", async ({
     page.locator(".ops-table", { hasText: "veloxdemo-1.0.0" }),
   ).toBeVisible();
   await expect(page.locator(".ops-table").first()).not.toContainText(TOKEN);
-  await expect(
-    page.locator(".dim", { hasText: "No usage recorded yet." }),
-  ).toBeVisible();
+  await expect(page.getByRole("alert")).toHaveText(
+    "/+stats returned HTTP 503.",
+  );
+  await expect(page.getByText("No usage recorded yet.")).toHaveCount(0);
   await expect(page.locator(".token")).toHaveCount(0);
   await expect(page.locator(".admin-table")).toHaveCount(0);
 });

crates/peryx-web/src/data/browse.rs

@@ -2,52 +2,82 @@ use peryx_core::BrowsePage;
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
 use peryx_core::UiActionMethod;
 
-#[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
-pub(super) async fn fetch_json(url: &str) -> Option<serde_json::Value> {
-    fetch_json_required(url).await.ok()
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
+pub enum LoaderEndpoint {
+    Browse,
+    Session,
+    Stats,
+    Status,
+    Topology,
+}
+
+impl std::fmt::Display for LoaderEndpoint {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str(match self {
+            Self::Browse => "/+ui/browse",
+            Self::Session => "/_/session",
+            Self::Stats => "/+stats",
+            Self::Status => "/+status",
+            Self::Topology => "/+availability/topology",
+        })
+    }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
+pub enum LoaderError {
+    Request(LoaderEndpoint),
+    Status { endpoint: LoaderEndpoint, status: u16 },
+    Invalid(LoaderEndpoint),
+}
+
+impl std::fmt::Display for LoaderError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Request(endpoint) => write!(formatter, "Request to {endpoint} failed."),
+            Self::Status { endpoint, status } => write!(formatter, "{endpoint} returned HTTP {status}."),
+            Self::Invalid(endpoint) => write!(formatter, "{endpoint} returned invalid data."),
+        }
+    }
+}
+
+impl std::error::Error for LoaderError {}
+
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
-pub(super) async fn fetch_json_required(url: &str) -> Result<serde_json::Value, String> {
-    let Some(value) = fetch_json_optional(url).await? else {
-        return Err(format!("404 from {url}: not found"));
+pub(super) async fn fetch_json_required<T>(url: &str, endpoint: LoaderEndpoint) -> Result<T, LoaderError>
+where
+    T: serde::de::DeserializeOwned,
+{
+    let Some(value) = fetch_json_optional(url, endpoint).await? else {
+        return Err(LoaderError::Status { endpoint, status: 404 });
     };
     Ok(value)
 }
 
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
-pub(super) async fn fetch_json_optional(url: &str) -> Result<Option<serde_json::Value>, String> {
+pub(super) async fn fetch_json_optional<T>(url: &str, endpoint: LoaderEndpoint) -> Result<Option<T>, LoaderError>
+where
+    T: serde::de::DeserializeOwned,
+{
     send_wrapper::SendWrapper::new(async {
         let response = gloo_net::http::Request::get(url)
             .header("accept", "application/json")
             .send()
             .await
-            .map_err(|error| format!("request failed for {url}: {error}"))?;
+            .map_err(|_| LoaderError::Request(endpoint))?;
         if response.status() == 404 {
             return Ok(None);
         }
         if !response.ok() {
-            return Err(response_error(response, url).await);
+            return Err(LoaderError::Status {
+                endpoint,
+                status: response.status(),
+            });
         }
         response
             .json()
             .await
             .map(Some)
-            .map_err(|error| format!("invalid JSON from {url}: {error}"))
-    })
-    .await
-}
-
-#[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
-async fn response_error(response: gloo_net::http::Response, url: &str) -> String {
-    send_wrapper::SendWrapper::new(async move {
-        let status = response.status();
-        let text = response.text().await.unwrap_or_default();
-        if text.is_empty() {
-            format!("{status} from {url}")
-        } else {
-            format!("{status} from {url}: {text}")
-        }
+            .map_err(|_| LoaderError::Invalid(endpoint))
     })
     .await
 }
@@ -63,12 +93,14 @@ pub async fn load_browse(raw_query: String) -> Result<Option<BrowsePage>, String
     #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
     {
         send_wrapper::SendWrapper::new(async move {
-            let Some(value) = super::fetch_json_optional(&crate::url::ui_browse_url(&raw_query)).await? else {
+            let Some(page) =
+                super::fetch_json_optional(&crate::url::ui_browse_url(&raw_query), super::LoaderEndpoint::Browse)
+                    .await
+                    .map_err(|error| error.to_string())?
+            else {
                 return Ok(None);
             };
-            serde_json::from_value(value)
-                .map(Some)
-                .map_err(|err| format!("invalid browse response: {err}"))
+            Ok(Some(page))
         })
         .await
     }

crates/peryx-web/src/data/login.rs

@@ -1,22 +1,45 @@
 use crate::model::UiLoginState;
 
+#[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
+use super::RequiredOption;
+
+#[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
+#[derive(serde::Deserialize)]
+struct SessionDocument {
+    user: RequiredOption<SessionUser>,
+    providers: Vec<String>,
+}
+
+#[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
+#[derive(serde::Deserialize)]
+struct SessionUser {
+    name: String,
+}
+
 /// The browser login state: who is signed in and which providers to offer.
-pub async fn load_login() -> UiLoginState {
+///
+/// # Errors
+///
+/// Returns a typed error when the session endpoint cannot provide a valid document.
+pub async fn load_login() -> Result<UiLoginState, super::LoaderError> {
     #[cfg(feature = "ssr")]
     {
-        crate::ssr::login_state().await
+        Ok(crate::ssr::login_state().await)
     }
     #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
     {
         send_wrapper::SendWrapper::new(async {
-            super::fetch_json("/_/session")
-                .await
-                .map_or_else(UiLoginState::default, |value| UiLoginState::from_session(&value))
+            let document: SessionDocument =
+                super::fetch_json_required("/_/session", super::LoaderEndpoint::Session).await?;
+            Ok(UiLoginState {
+                user: document.user.0.map(|user| user.name),
+                providers: document.providers,
+            })
         })
         .await
     }
     #[cfg(all(not(feature = "ssr"), not(feature = "hydrate")))]
     {
-        UiLoginState::default()
+        Ok(UiLoginState::default())
     }
 }

crates/peryx-web/src/data/mod.rs

@@ -13,8 +13,9 @@ mod topology;
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
 pub use browse::admin_request;
 pub use browse::load_browse;
+pub use browse::{LoaderEndpoint, LoaderError};
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
-use browse::{fetch_json, fetch_json_optional, fetch_json_required};
+use browse::{fetch_json_optional, fetch_json_required};
 pub use login::load_login;
 pub use operations::load_operations;
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
@@ -30,3 +31,8 @@ pub use status::{load_admin_snapshot, load_snapshot};
 pub use topology::load_topology;
 #[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
 pub use topology::{TopologyStream, subscribe_topology};
+
+#[cfg(all(not(feature = "ssr"), feature = "hydrate"))]
+#[derive(serde::Deserialize)]
+#[serde(transparent)]
+struct RequiredOption<T>(Option<T>);