Suspense boundaries/out of order streaming/anyhow like error handling (#2365)

* create static site generation helpers in the router crate * work on integrating static site generation into fullstack * move ssg into a separate crate * integrate ssg with the launch builder * simplify ssg example * fix static_routes for child routes * move CLI hot reloading websocket code into dioxus-hot-reload * fix some unused imports * use the same hot reloading websocket code for fullstack * fix fullstack hot reloading * move cli hot reloading logic into the hot reload crate * ssg example working with dx serve * add more examples * fix clippy * switch to a result for Element * fix formatting * fix hot reload doctest imports * fix axum imports * add show method to error context * implement retaining nodes during suspense * fix unterminated if statements * communicate between tasks and suspense boundaries * make suspense placeholders easier to use * implement IntoDynNode and IntoVNode for more wrappers * fix clippy examples * fix rsx tests * add streaming html utilities to the ssr package * unify hydration and non-hydration ssr cache * fix router with Result Element * don't run server doc tests * Fix hot reload websocket doc examples * simple apps working with fullstack streaming * fix preloading wasm * Report errors encountered while streaming * remove async from incremental renderer * document new VirtualDom suspense methods * make streaming work with incremental rendering * fix static site generation * document suspense structs * create closure type; allow async event handlers in props; allow shorthand event handlers * test forwarding event handlers with the shorthand syntax * fix clippy * fix imports in spawn async doctest * fix empty rsx * fix async result event handlers * fix mounting router in multiple places * Fix task dead cancel race condition * simplify diffing before adding suspense * fix binary size increase * fix attribute diffing * more diffing fixes * create minimal fullstack feature * smaller fullstack bundles * allow mounting nodes that are already created and creating nodes without mounting them * fix hot reload feature * fix replacing components * don't reclaim virtual nodes * client side suspense working! * fix CLI * slightly smaller fullstack builds * fix multiple suspended scopes * fix merge errors * yield back to tokio every few polls to fix suspending on many tasks at once * remove logs * document suspense boundary and update suspense example * fix ssg * make streaming optional * fix some router and core tests * fix suspense example * fix serialization with out of order server futures * add incremental streaming hackernews demo * fix hackernews demo * fix root hackernews redirect * fix formatting * add tests for suspense cases * slightly smaller binaries * slightly smaller * improve error handling docs * fix errors example link * fix doc tests * remove log file * fix ssr cache type inference * remove index.html * fix ssg render template * fix assigning ids on elements with dynamic attributes * add desktop feature to the workspace examples * remove router static generation example; ssg lives in the dioxus-static-generation package * add a test for effects during suspense * only run effects on mounted nodes * fix multiple suspense roots * fix node iterator * fix closures without arguments * fix dioxus-core readme doctest * remove suspense logs * fix scope stack * fix clippy * remove unused suspense boundary from hackernews * assert that launch never returns for better compiler errors * fix static generation launch function * fix web renderer * pass context providers into server functions * add an example for FromContext * clean up DioxusRouterExt * fix server function context * fix fullstack desktop example * forward CLI serve settings to fullstack * re-export serve config at the root of fullstack * forward env directly instead of using a guard * just set the port in the CLI for fullstack playwright tests * fix fullstack dioxus-cli-config feature * fix launch server merge conflicts * fix fullstack launch context * Merge branch 'main' into suspense-2.0 * fix fullstack html data * remove drop virtual dom feature * add a comment about only_write_templates binary size workaround * remove explicit dependencies from use_server_future * make ErrorContext and SuspenseContext more similar * Tweak: small tweaks to tomls to make diff smaller * only rerun components under suspense after the initial placeholders are sent to the client * add module docs for suspense * keep track of when suspense boundaries are resolved * start implementing JS out of order streaming * fix core tests * implement the server side of suspense with js * fix streaming ssr with nested suspense * move streaming ssr code into fullstack * revert minification changes * serialize server future data as the html streams * start loading scripts wasm immediately instead of defering the script * very basic nested suspense example working with minimal html updates * clean up some suspense/error docs * fix hydrating nested pending server futures * sort resolved boundaries by height * Fix disconnecting clients while streaming * fix static generation crate * don't insert extra divs when hydrating streamed chunks * wait to swap in the elements until they are hydrated * remove inline streaming script * hackernews partially working * fix spa mode * banish the open shadow dom * fix removing placeholder * set up streaming playwright test * run web playwright tests on 9999 to avoid port conflicts with other local servers * remove suspense nodes if the suspense boundary is replaced before the suspense resolves on the server * ignore hydration of removed suspense boundaries * use path based indexing to fix hydrating suspense after parent suspense with child is removed * re-export dioxus error * remove resolved suspense divs if the suspense boundary has been removed * Fix client side initialized server futures * ignore comment nodes while traversing nodes in core to avoid lists getting swapped out with suspense * Pass initial hydration data to the client * hide pre nodes * don't panic if reclaiming an element fails * fix scope stack when polling tasks * improve deserialization out of length message * Ok(VNode::placeholder()) -> VNode::empty() * fix typo in rsx usage * restore testing changes from suspense example * clean up some logs and comments * fix playwright tests * clean up more changes in core * clean up core tests * remove anymap dependency * clean up changes to hooks * clean up changes in the router, rsx, and web * revert changes to axum-hello-world * fix use_server_future * fix clippy in dioxus-core * check that the next or previous node exist before checking if we should ignore them * fix formatting * fix suspense playwright test * remove unused suspense code * add more suspense playwright tests * add more docs for error boundaries * fix suspense core tests * fix ErrorBoundary example * remove a bunch of debug logging in js * fix router failure_external_navigation * use absolute paths in the interpreter build.rs * strip '\r' while hashing ts files * add a wrapper with a default error boundary and suspense boundary * restore hot reloading * ignore non-ts files when hashing * sort ts files before hashing them * fix rsx tests * fix fullstack doc tests * fix core tests * fix axum auth example * update suspense hydration diagram * longer playwright build limit * tiny fixes - spelling, formatting * update diagram link * remove comment and template nodes for suspense placeholders * remove comment nodes as we hydrate text * simplify hackernews example * clean up hydrating text nodes * switch to a separate environment variable for the base path for smaller binaries * clean up file system html trait * fix form data * move streaming code into fullstack * implement serialize and deserialize for CapturedError * remove waits in the nested suspense playwright spec * force sequential fullstack builds for CI * longer nested suspense delay for CI * fix --force-sequential flag * wait to launch server until client build is done --------- Co-authored-by: Jonathan Kelley <jkelleyrtp@gmail.com>
2024-07-01 20:50:36 -07:00
1 parent ffa36a67c3
commit 022e4ad203
@@ -2,6 +2,22 @@ use dioxus::prelude::*;
 use std::future::poll_fn;
 use std::task::Poll;

+async fn poll_three_times() {
+    // Poll each task 3 times
+    let mut count = 0;
+    poll_fn(|cx| {
+        println!("polling... {}", count);
+        if count < 3 {
+            count += 1;
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        } else {
+            Poll::Ready(())
+        }
+    })
+    .await;
+}
+
 #[test]
 fn suspense_resolves() {
    // wait just a moment, not enough time for the boundary to resolve
@@ -15,8 +31,6 @@ fn suspense_resolves() {
            let out = dioxus_ssr::render(&dom);

            assert_eq!(out, "<div>Waiting for... child</div>");
-
-            dbg!(out);
        });
 }

@@ -24,7 +38,10 @@ fn app() -> Element {
    rsx!(
        div {
            "Waiting for... "
-            suspended_child {}
+            SuspenseBoundary {
+                fallback: |_| rsx! { "fallback" },
+                suspended_child {}
+            }
        }
    )
 }
@@ -43,20 +60,7 @@ fn suspended_child() -> Element {

    if val() < 3 {
        let task = spawn(async move {
-            // Poll each task 3 times
-            let mut count = 0;
-            poll_fn(|cx| {
-                println!("polling... {}", count);
-                if count < 3 {
-                    count += 1;
-                    cx.waker().wake_by_ref();
-                    Poll::Pending
-                } else {
-                    Poll::Ready(())
-                }
-            })
-            .await;
-
+            poll_three_times().await;
            println!("waiting... {}", val);
            val += 1;
        });
@@ -65,3 +69,306 @@ fn suspended_child() -> Element {

    rsx!("child")
 }
+
+/// When switching from a suspense fallback to the real child, the state of that component must be kept
+#[test]
+fn suspense_keeps_state() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let mut dom = VirtualDom::new(app);
+            dom.rebuild(&mut dioxus_core::NoOpMutations);
+            dom.render_suspense_immediate().await;
+
+            let out = dioxus_ssr::render(&dom);
+
+            assert_eq!(out, "fallback");
+
+            dom.wait_for_suspense().await;
+            let out = dioxus_ssr::render(&dom);
+
+            assert_eq!(out, "<div>child with future resolved</div>");
+        });
+
+    fn app() -> Element {
+        rsx! {
+            SuspenseBoundary {
+                fallback: |_| rsx! { "fallback" },
+                Child {}
+            }
+        }
+    }
+
+    #[component]
+    fn Child() -> Element {
+        let mut future_resolved = use_signal(|| false);
+
+        let task = use_hook(|| {
+            spawn(async move {
+                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                future_resolved.set(true);
+            })
+        });
+        if !future_resolved() {
+            suspend(task)?;
+        }
+
+        println!("future resolved: {future_resolved:?}");
+
+        if future_resolved() {
+            rsx! {
+                div { "child with future resolved" }
+            }
+        } else {
+            rsx! {
+                div { "this should never be rendered" }
+            }
+        }
+    }
+}
+
+/// spawn doesn't run in suspense
+#[test]
+fn suspense_does_not_poll_spawn() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let mut dom = VirtualDom::new(app);
+            dom.rebuild(&mut dioxus_core::NoOpMutations);
+
+            dom.wait_for_suspense().await;
+            let out = dioxus_ssr::render(&dom);
+
+            assert_eq!(out, "<div>child with future resolved</div>");
+        });
+
+    fn app() -> Element {
+        rsx! {
+            SuspenseBoundary {
+                fallback: |_| rsx! { "fallback" },
+                Child {}
+            }
+        }
+    }
+
+    #[component]
+    fn Child() -> Element {
+        let mut future_resolved = use_signal(|| false);
+
+        // futures that are spawned, but not suspended should never be polled
+        use_hook(|| {
+            spawn(async move {
+                panic!("Non-suspended task was polled");
+            });
+        });
+
+        let task = use_hook(|| {
+            spawn(async move {
+                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                future_resolved.set(true);
+            })
+        });
+        if !future_resolved() {
+            suspend(task)?;
+        }
+
+        rsx! {
+            div { "child with future resolved" }
+        }
+    }
+}
+
+/// suspended nodes are not mounted, so they should not run effects
+#[test]
+fn suspended_nodes_dont_trigger_effects() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let mut dom = VirtualDom::new(app);
+            dom.rebuild(&mut dioxus_core::NoOpMutations);
+
+            let work = async move {
+                loop {
+                    dom.wait_for_work().await;
+                    dom.render_immediate(&mut dioxus_core::NoOpMutations);
+                }
+            };
+            tokio::select! {
+                _ = work => {},
+                _ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {}
+            }
+        });
+
+    fn app() -> Element {
+        rsx! {
+            SuspenseBoundary {
+                fallback: |_| rsx! { "fallback" },
+                Child {}
+            }
+        }
+    }
+
+    #[component]
+    fn RerendersFrequently() -> Element {
+        let mut count = use_signal(|| 0);
+
+        use_future(move || async move {
+            for _ in 0..100 {
+                tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+                count.set(count() + 1);
+            }
+        });
+
+        rsx! {
+            div { "rerenders frequently" }
+        }
+    }
+
+    #[component]
+    fn Child() -> Element {
+        let mut future_resolved = use_signal(|| false);
+
+        use_effect(|| panic!("effects should not run during suspense"));
+
+        let task = use_hook(|| {
+            spawn(async move {
+                tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+                future_resolved.set(true);
+            })
+        });
+        if !future_resolved() {
+            suspend(task)?;
+        }
+
+        rsx! {
+            div { "child with future resolved" }
+        }
+    }
+}
+
+/// Make sure we keep any state of components when we switch from a resolved future to a suspended future
+#[test]
+fn resolved_to_suspended() {
+    tracing_subscriber::fmt::SubscriberBuilder::default()
+        .with_max_level(tracing::Level::INFO)
+        .init();
+
+    static SUSPENDED: GlobalSignal<bool> = Signal::global(|| false);
+
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let mut dom = VirtualDom::new(app);
+            dom.rebuild(&mut dioxus_core::NoOpMutations);
+
+            let out = dioxus_ssr::render(&dom);
+
+            assert_eq!(out, "rendered 1 times");
+
+            dom.in_runtime(|| ScopeId::APP.in_runtime(|| *SUSPENDED.write() = true));
+
+            dom.render_suspense_immediate().await;
+            let out = dioxus_ssr::render(&dom);
+
+            assert_eq!(out, "fallback");
+
+            dom.wait_for_suspense().await;
+            let out = dioxus_ssr::render(&dom);
+
+            assert_eq!(out, "rendered 3 times");
+        });
+
+    fn app() -> Element {
+        rsx! {
+            SuspenseBoundary {
+                fallback: |_| rsx! { "fallback" },
+                Child {}
+            }
+        }
+    }
+
+    #[component]
+    fn Child() -> Element {
+        let mut render_count = use_signal(|| 0);
+        render_count += 1;
+
+        let mut task = use_hook(|| CopyValue::new(None));
+
+        tracing::info!("render_count: {}", render_count.peek());
+
+        if SUSPENDED() {
+            if task().is_none() {
+                task.set(Some(spawn(async move {
+                    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                    tracing::info!("task finished");
+                    *SUSPENDED.write() = false;
+                })));
+            }
+            suspend(task().unwrap())?;
+        }
+
+        rsx! {
+            "rendered {render_count.peek()} times"
+        }
+    }
+}
+
+/// Make sure suspense tells the renderer that a suspense boundary was resolved
+#[test]
+fn suspense_tracks_resolved() {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+        .block_on(async {
+            let mut dom = VirtualDom::new(app);
+            dom.rebuild(&mut dioxus_core::NoOpMutations);
+
+            dom.render_suspense_immediate().await;
+            dom.wait_for_suspense_work().await;
+            assert_eq!(
+                dom.render_suspense_immediate().await,
+                vec![ScopeId(ScopeId::APP.0 + 1)]
+            );
+        });
+
+    fn app() -> Element {
+        rsx! {
+            SuspenseBoundary {
+                fallback: |_| rsx! { "fallback" },
+                Child {}
+            }
+        }
+    }
+
+    #[component]
+    fn Child() -> Element {
+        let mut resolved = use_signal(|| false);
+        let task = use_hook(|| {
+            spawn(async move {
+                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                tracing::info!("task finished");
+                resolved.set(true);
+            })
+        });
+
+        if resolved() {
+            println!("suspense is resolved");
+        } else {
+            println!("suspense is not resolved");
+            suspend(task)?;
+        }
+
+        rsx! {
+            "child"
+        }
+    }
+}