refactor(seam): single-source notification store; drop premature native dep

Two robustness fixes to the Phase-1 backend seam, replacing scaffolding that
would not survive into later phases.

Single source of truth for notifications
- The topbar badge read a global Signal<Vec<Notification>> while the popover
  independently re-fetched the same feed via its own use_resource, so
  mark-all-read updated the badge but NOT the open popover list (and vice-versa)
  — a divergence that worsens as more views touch notifications.
- The context store is now one Signal<AsyncState<Vec<Notification>>>, seeded
  once at the seam in app.rs and shared by the badge and the popover. User
  actions (mark-all-read / per-item read) mutate that one store, so the two
  cannot disagree. The popover projects the store through capability filtering
  via AsyncState::project (Loading/Empty/Error stay correct) and reloads on
  Retry through the shared Resource handle.
- New reusable AsyncState methods (project, loaded_mut) and pure notification
  mutation helpers (mark_all_read, mark_read) are unit-tested.

Drop the premature `native` feature
- Enabling nodedb-client's `native` feature dragged a TLS + C-toolchain build
  tree (tokio-rustls, aws-lc-rs, aws-lc-sys, cmake) into every build — solely to
  hold an Option<NativeClient> field that was #[allow(dead_code)] and never read.
- The feature and the field are removed until the phase that first constructs a
  client. NodeDbConnectionService stays as the test-covered Phase-2 seam impl;
  its object-safety/instantiability are proven by tests, not a throwaway runtime
  binding in app.rs.

fmt + clippy -D warnings + nextest all green (37 tests, was 31).

Author: farhan-syah

Cargo.lock

@@ -13,8 +13,11 @@ repository = "https://github.com/NodeDB-Lab/nodedb-studio"
 homepage = "https://nodedb.dev"
 
 [workspace.dependencies]
-# Internal NodeDB crates.
-nodedb-client = { version = "0.3.0", features = ["native"] }
+# Internal NodeDB crates. The `native` feature (real client transport) is
+# enabled in the phase that first constructs a NativeClient — it drags in a
+# TLS + C-toolchain build tree (tokio-rustls, aws-lc-rs, cmake), so it is not
+# carried while the seam impl is an inert stub.
+nodedb-client = "0.3.0"
 nodedb-types = "0.3.0"
 # Async
 async-trait = "0.1"

Cargo.toml

@@ -14,8 +14,8 @@ use dioxus::prelude::*;
 
 use crate::modals::ModalHost;
 use crate::models::notification::Notification;
+use crate::services::async_state::AsyncState;
 use crate::services::connection_service::{ConnectionService, MockConnectionService};
-use crate::services::nodedb_service::NodeDbConnectionService;
 use crate::state::connection::ActiveConnection;
 use crate::state::connections_registry::SavedConnection;
 use crate::state::preferences::Preferences;
@@ -31,15 +31,17 @@ pub fn App() -> Element {
     // The single seam to the outside world. Provided as a trait object so a
     // real client can replace the mock without touching consumers.
     let service: Rc<dyn ConnectionService> = Rc::new(MockConnectionService);
-
-    // Compile-time check: the real-client stub must be instantiable and
-    // object-safe behind the seam trait. Not the active impl yet — the mock is.
-    let _real: Rc<dyn ConnectionService> = Rc::new(NodeDbConnectionService::default());
+    // The real-client stub's instantiability + object-safety behind the seam is
+    // proven by `nodedb_service::tests::stub_is_object_safe_behind_rc`, so it is
+    // not constructed here on every render.
 
     use_context_provider(|| service.clone());
     use_context_provider(|| Signal::new(None::<ActiveConnection>));
     let mut registry = use_context_provider(|| Signal::new(Vec::<SavedConnection>::new()));
-    let mut notifications = use_context_provider(|| Signal::new(Vec::<Notification>::new()));
+    // Single source of truth for notifications: the bell badge AND the popover
+    // read this one store; user actions (mark-all-read / click) mutate it.
+    let mut notifications =
+        use_context_provider(|| Signal::new(AsyncState::<Vec<Notification>>::Loading));
     use_context_provider(|| Signal::new(Preferences::default()));
     // Modal state is provided here (not in Studio) because Preferences is
     // reachable while disconnected and via Cmd+, in either state.
@@ -49,20 +51,26 @@ pub fn App() -> Element {
     // mock resolves instantly; the real client awaits the network. The guard
     // rule: clone the Rc before the async block and `.set()` the signals only
     // AFTER the await resolves — never hold a read/write guard across `.await`.
-    {
+    // The Resource handle is shared via context so a view (the notification
+    // popover's Retry) can reload the feed.
+    let reload_feed = {
         let svc = service.clone();
         use_resource(move || {
             let svc = svc.clone();
             async move {
+                // Reset to Loading at the start of each (re)load so a Retry shows
+                // the spinner. `.set()` holds no guard across the awaits below.
+                notifications.set(AsyncState::Loading);
                 if let Ok(conns) = svc.list_connections().await {
                     registry.set(conns);
                 }
-                if let Ok(notifs) = svc.notifications().await {
-                    notifications.set(notifs);
-                }
+                // Map the seam result straight into the store: Ok(empty)->Empty,
+                // Ok(data)->Loaded, Err->Error.
+                notifications.set(AsyncState::from_value(Some(svc.notifications().await)));
             }
-        });
-    }
+        })
+    };
+    use_context_provider(|| reload_feed);
 
     let active = use_context::<Signal<Option<ActiveConnection>>>();
 

nodedb-studio/src/app.rs

@@ -1,29 +1,23 @@
 //! Notification popover: capability-filtered, grouped list with a bell badge,
 //! mark-all-read, and click-to-navigate.
 //!
-//! The rendered list is fetched through the async `ConnectionService` seam via
-//! `use_resource`, then mapped to `AsyncState` and rendered through the shared
-//! `AsyncView` — the canonical async-UI pattern. Capability filtering is applied
-//! to the `Ok` payload *before* `AsyncState::from_value`, so `Empty` reflects
-//! what THIS connection can see (not the raw feed). The Error state offers a
-//! Retry gated on `StudioError::is_retriable()`, wired to `Resource::restart()`.
-//!
-//! The topbar bell badge derives from a separate global `Signal<Vec<Notification>>`
-//! seeded in `app.rs`; mark-all-read / per-item clicks mutate that signal so the
-//! badge stays in sync. Converging the badge and this list onto one source is
-//! deferred to a later phase.
-
-use std::rc::Rc;
+//! Single source of truth: both this popover and the topbar bell badge read the
+//! one shared `Signal<AsyncState<Vec<Notification>>>` store (seeded once at the
+//! seam in `app.rs`). The popover `project`s that store through capability
+//! filtering — so `Empty` reflects what THIS connection sees — then renders the
+//! `Loading`/`Empty`/`Error` states through the shared `AsyncView` and the loaded
+//! list itself. Mark-all-read / per-item clicks MUTATE the store, so the badge
+//! and the list never diverge. The Error-state Retry reloads the feed via the
+//! shared `Resource` handle, gated on `StudioError::is_retriable()`.
 
 use dioxus::prelude::*;
 
 use crate::components::async_view::AsyncView;
 use crate::models::notification::{Notification, NotificationTarget};
 use crate::routes::Route;
 use crate::services::async_state::AsyncState;
-use crate::services::connection_service::ConnectionService;
 use crate::state::connection::{ActiveConnection, Capabilities};
-use crate::state::notifications::visible;
+use crate::state::notifications::{mark_all_read, mark_read, visible};
 use crate::state::ui::Popover;
 
 /// Where a notification navigates when clicked.
@@ -45,11 +39,12 @@ fn target_route(target: NotificationTarget) -> Route {
 
 #[component]
 pub fn NotificationPopover() -> Element {
-    // Global signal kept for mark-all-read + per-item read + topbar badge sync.
-    let mut notifs = use_context::<Signal<Vec<Notification>>>();
+    // The one shared store (mutated here for mark-all-read + per-item read) and
+    // the shared reload handle backing the Error-state Retry.
+    let mut store = use_context::<Signal<AsyncState<Vec<Notification>>>>();
+    let mut reload = use_context::<Resource<()>>();
     let mut popover = use_context::<Signal<Option<Popover>>>();
     let active = use_context::<Signal<Option<ActiveConnection>>>();
-    let service = use_context::<Rc<dyn ConnectionService>>();
     let nav = use_navigator();
 
     // Capability gate (unchanged): no connection -> render nothing.
@@ -58,30 +53,18 @@ pub fn NotificationPopover() -> Element {
         None => return rsx! {},
     };
 
-    // Fetch the feed through the async seam. Clone the Rc BEFORE the async block;
-    // never hold a signal/Resource guard across `.await`.
-    let mut feed = use_resource(move || {
-        let service = service.clone();
-        async move { service.notifications().await } // Result<Vec<Notification>, StudioError>
-    });
-
-    // Clone the resource value out of its guard (StudioError is Clone), mapping
-    // the Ok payload to the capability-filtered list so `Empty` reflects what THIS
-    // connection sees — then derive every UI state from one `AsyncState`. This is
-    // the same `from_value` mapping the unit tests exercise; the render path and
-    // the tests share one code path.
-    let state: AsyncState<Vec<Notification>> = {
-        let mapped = feed
-            .read()
-            .clone()
-            .map(|res| res.map(|list| visible(&list[..], &caps).cloned().collect::<Vec<_>>()));
-        AsyncState::from_value(mapped)
-    }; // guard dropped here — nothing held across the render below
+    // Project the shared store through capability filtering into an owned view
+    // state: `Empty` re-derives from the filtered list, so it reflects what THIS
+    // connection sees. The read guard is dropped at the end of this statement —
+    // nothing is held across the render below.
+    let view: AsyncState<Vec<Notification>> = store
+        .read()
+        .project(|raw| visible(raw, &caps).cloned().collect());
 
     // Build the grouped list ONLY for the Loaded case (preserves first-seen order).
     let mut groups: Vec<(String, Vec<Notification>)> = Vec::new();
     let mut unread = 0usize;
-    if let Some(items) = state.loaded() {
+    if let Some(items) = view.loaded() {
         unread = items.iter().filter(|n| n.unread).count();
         for n in items {
             match groups.iter_mut().find(|(g, _)| g == &n.group) {
@@ -103,21 +86,23 @@ pub fn NotificationPopover() -> Element {
                 h4 { "Notifications " span { class: "count", "{count_label}" } }
                 button {
                     onclick: move |_| {
-                        // Mark-all-read mutates the GLOBAL signal so the topbar badge updates.
-                        for n in notifs.write().iter_mut() { n.unread = false; }
+                        // Mutate the shared store; the badge re-derives from it.
+                        if let Some(items) = store.write().loaded_mut() {
+                            mark_all_read(items);
+                        }
                     },
                     "Mark all read"
                 }
             }
             div { class: "notif-list",
                 // Loading / Empty / Error -> shared AsyncView, driven by AsyncState.
                 AsyncView {
-                    loading: state.is_loading(),
-                    empty: state.is_empty(),
-                    error: state.error_message(),
-                    retriable: state.is_retriable(),
+                    loading: view.is_loading(),
+                    empty: view.is_empty(),
+                    error: view.error_message(),
+                    retriable: view.is_retriable(),
                     empty_message: "No notifications for this connection".to_string(),
-                    on_retry: move |_| feed.restart(),
+                    on_retry: move |_| reload.restart(),
                 }
                 // Loaded -> the existing grouped list markup.
                 if !groups.is_empty() {
@@ -133,8 +118,8 @@ pub fn NotificationPopover() -> Element {
                                         key: "{id}",
                                         class: "{item_class}",
                                         onclick: move |_| {
-                                            for x in notifs.write().iter_mut() {
-                                                if x.id == id { x.unread = false; }
+                                            if let Some(items) = store.write().loaded_mut() {
+                                                mark_read(items, &id);
                                             }
                                             popover.set(None);
                                             nav.push(route.clone());