ssr options for stuff

crates/weaver-app/.env-example

···
-WEAVER_APP_ENV="dev"
-WEAVER_APP_HOST="http://localhost"
-WEAVER_APP_DOMAIN=""
-WEAVER_PORT=8080
-WEAVER_APP_SCOPES="atproto transition:generic"
-WEAVER_CLIENT_NAME="Weaver"
-
-WEAVER_LOGO_URI=""
-WEAVER_TOS_URI=""
-WEAVER_PRIVACY_POLICY_URI=""

crates/weaver-app/.env-prod

···
+WEAVER_APP_ENV="prod"
+WEAVER_APP_HOST="https://alpha.weaver.sh"
+WEAVER_APP_DOMAIN="https://alpha.weaver.sh"
+WEAVER_PORT=8080
+WEAVER_APP_SCOPES="atproto transition:generic"
+WEAVER_CLIENT_NAME="Weaver"
+
+WEAVER_LOGO_URI=""
+WEAVER_TOS_URI=""
+WEAVER_PRIVACY_POLICY_URI=""

crates/weaver-app/src/components/css.rs

···
 #[allow(unused_imports)]
 use crate::fetch;
 #[allow(unused_imports)]
-use dioxus::{prelude::*, CapturedError};
+use dioxus::{CapturedError, prelude::*};
 
 #[cfg(feature = "fullstack-server")]
 use dioxus::fullstack::response::Response;
···
     use dioxus::fullstack::get_server_url;
     rsx! {
         document::Stylesheet {
-            href: "{get_server_url()}/{ident}/{notebook}/css"
+            href: "{get_server_url()}/css/{ident}/{notebook}"
         }
     }
 }
···
 pub fn NotebookCss(ident: SmolStr, notebook: SmolStr) -> Element {
     use jacquard::client::AgentSessionExt;
     use jacquard::types::ident::AtIdentifier;
-    use jacquard::{from_data, CowStr};
+    use jacquard::{CowStr, from_data};
     use weaver_api::sh_weaver::notebook::book::Book;
     use weaver_renderer::css::{generate_base_css, generate_syntax_css};
     use weaver_renderer::theme::{default_resolved_theme, resolve_theme};
···
 }
 
 #[cfg(feature = "fullstack-server")]
-#[get("/{ident}/{notebook}/css", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
+#[get("/css/{ident}/{notebook}", fetcher: Extension<Arc<fetch::CachedFetcher>>)]
 pub async fn css(ident: SmolStr, notebook: SmolStr) -> Result<Response> {
     use dioxus::fullstack::http::header::CONTENT_TYPE;
     use jacquard::client::AgentSessionExt;
     use jacquard::types::ident::AtIdentifier;
-    use jacquard::{from_data, CowStr};
+    use jacquard::{CowStr, from_data};
 
     use weaver_api::sh_weaver::notebook::book::Book;
     use weaver_renderer::css::{generate_base_css, generate_syntax_css};

crates/weaver-app/src/components/identity.rs

···
-use crate::{Route, fetch};
+use crate::{Route, data, fetch};
 use dioxus::prelude::*;
 use jacquard::{smol_str::SmolStr, types::ident::AtIdentifier};
 use weaver_api::com_atproto::repo::strong_ref::StrongRef;
···
 pub fn RepositoryIndex(ident: ReadSignal<AtIdentifier<'static>>) -> Element {
     use crate::components::ProfileDisplay;
 
-    let fetcher = use_context::<fetch::CachedFetcher>();
-
-    // Fetch notebooks for this specific DID
-    let notebooks = use_resource(move || {
-        let fetcher = fetcher.clone();
-        async move { fetcher.fetch_notebooks_for_did(&ident()).await }
-    });
+    // Fetch notebooks for this specific DID with SSR support
+    let notebooks = data::use_notebooks_for_did(ident()).ok();
 
     rsx! {
         document::Stylesheet { href: NOTEBOOK_CARD_CSS }
···
             // Main content area
             main { class: "repository-main",
                 div { class: "notebooks-list",
-                    match notebooks() {
-                        Some(Ok(notebook_list)) => rsx! {
-                            for notebook in notebook_list.iter() {
-                                {
-                                    let view = &notebook.0;
-                                    let entries = &notebook.1;
-                                    rsx! {
-                                        div {
-                                            key: "{view.cid}",
-                                            NotebookCard {
-                                                notebook: view.clone(),
-                                                entry_refs: entries.clone()
+                    if let Some(notebooks_memo) = &notebooks {
+                        match &*notebooks_memo.read_unchecked() {
+                            Some(notebook_list) => rsx! {
+                                for notebook in notebook_list.iter() {
+                                    {
+                                        let view = &notebook.0;
+                                        let entries = &notebook.1;
+                                        rsx! {
+                                            div {
+                                                key: "{view.cid}",
+                                                NotebookCard {
+                                                    notebook: view.clone(),
+                                                    entry_refs: entries.clone()
+                                                }
                                             }
                                         }
                                     }
                                 }
+                            },
+                            None => rsx! {
+                                div { "Loading notebooks..." }
                             }
-                        },
-                        Some(Err(_)) => rsx! {
-                            div { "Error loading notebooks" }
-                        },
-                        None => rsx! {
-                            div { "Loading notebooks..." }
                         }
+                    } else {
+                        div { "Loading notebooks..." }
                     }
                 }
             }

crates/weaver-app/src/data.rs

···
 };
 #[allow(unused_imports)]
 use std::sync::Arc;
-use weaver_api::sh_weaver::notebook::{BookEntryView, entry::Entry};
+use weaver_api::sh_weaver::notebook::{BookEntryView, NotebookView, entry::Entry};
 // ============================================================================
 // Wrapper Hooks (feature-gated)
 // ============================================================================
···
                 .await
                 .ok()
                 .map(|notebooks| notebooks.iter().map(|arc| (*arc).clone()).collect())
+        }
+    }));
+    Ok(use_memo(move || {
+        r.read_unchecked().as_ref().and_then(|v| v.clone())
+    }))
+}
+
+/// Fetches notebooks from UFOS with SSR support in fullstack mode
+#[cfg(feature = "fullstack-server")]
+pub fn use_notebooks_from_ufos() -> Result<
+    Memo<Option<Vec<(NotebookView<'static>, Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>>,
+    RenderError,
+> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let res = use_server_future(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_notebooks_from_ufos()
+                .await
+                .ok()
+                .map(|notebooks| {
+                    notebooks
+                        .iter()
+                        .map(|arc| serde_json::to_value(arc.as_ref()).ok())
+                        .collect::<Option<Vec<_>>>()
+                })
+                .flatten()
+        }
+    })?;
+    Ok(use_memo(move || {
+        if let Some(Some(values)) = &*res.read_unchecked() {
+            values
+                .iter()
+                .map(|v| {
+                    jacquard::from_json_value::<(
+                        NotebookView,
+                        Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef>,
+                    )>(v.clone())
+                    .ok()
+                })
+                .collect::<Option<Vec<_>>>()
+        } else {
+            None
+        }
+    }))
+}
+
+/// Fetches notebooks from UFOS client-side only (no SSR)
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_notebooks_from_ufos() -> Result<
+    Memo<Option<Vec<(NotebookView<'static>, Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>>,
+    RenderError,
+> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let r = use_resource(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .fetch_notebooks_from_ufos()
+                .await
+                .ok()
+                .map(|notebooks| notebooks.iter().map(|arc| (*arc).clone()).collect())
+        }
+    });
+    Ok(use_memo(move || {
+        r.read_unchecked().as_ref().and_then(|v| v.clone())
+    }))
+}
+
+/// Fetches notebook metadata with SSR support in fullstack mode
+#[cfg(feature = "fullstack-server")]
+pub fn use_notebook(
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+) -> Result<
+    Memo<Option<(NotebookView<'static>, Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>,
+    RenderError,
+> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let ident = use_signal(|| ident);
+    let book_title = use_signal(|| book_title);
+    let res = use_server_future(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .get_notebook(ident(), book_title())
+                .await
+                .ok()
+                .flatten()
+                .map(|arc| serde_json::to_value(arc.as_ref()).ok())
+                .flatten()
+        }
+    })?;
+    Ok(use_memo(move || {
+        if let Some(Some(value)) = &*res.read_unchecked() {
+            jacquard::from_json_value::<(
+                NotebookView,
+                Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef>,
+            )>(value.clone())
+            .ok()
+        } else {
+            None
+        }
+    }))
+}
+
+/// Fetches notebook metadata client-side only (no SSR)
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_notebook(
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+) -> Result<
+    Memo<Option<(NotebookView<'static>, Vec<weaver_api::com_atproto::repo::strong_ref::StrongRef<'static>>)>>,
+    RenderError,
+> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let r = use_resource(use_reactive!(|(ident, book_title)| {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .get_notebook(ident, book_title)
+                .await
+                .ok()
+                .flatten()
+                .map(|arc| (*arc).clone())
+        }
+    }));
+    Ok(use_memo(move || {
+        r.read_unchecked().as_ref().and_then(|v| v.clone())
+    }))
+}
+
+/// Fetches notebook entries with SSR support in fullstack mode
+#[cfg(feature = "fullstack-server")]
+pub fn use_notebook_entries(
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+) -> Result<Memo<Option<Vec<BookEntryView<'static>>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let ident = use_signal(|| ident);
+    let book_title = use_signal(|| book_title);
+    let res = use_server_future(move || {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .list_notebook_entries(ident(), book_title())
+                .await
+                .ok()
+                .flatten()
+                .map(|entries| {
+                    entries
+                        .iter()
+                        .map(|e| serde_json::to_value(e).ok())
+                        .collect::<Option<Vec<_>>>()
+                })
+                .flatten()
+        }
+    })?;
+    Ok(use_memo(move || {
+        if let Some(Some(values)) = &*res.read_unchecked() {
+            values
+                .iter()
+                .map(|v| jacquard::from_json_value::<BookEntryView>(v.clone()).ok())
+                .collect::<Option<Vec<_>>>()
+        } else {
+            None
+        }
+    }))
+}
+
+/// Fetches notebook entries client-side only (no SSR)
+#[cfg(not(feature = "fullstack-server"))]
+pub fn use_notebook_entries(
+    ident: AtIdentifier<'static>,
+    book_title: SmolStr,
+) -> Result<Memo<Option<Vec<BookEntryView<'static>>>>, RenderError> {
+    let fetcher = use_context::<crate::fetch::CachedFetcher>();
+    let r = use_resource(use_reactive!(|(ident, book_title)| {
+        let fetcher = fetcher.clone();
+        async move {
+            fetcher
+                .list_notebook_entries(ident, book_title)
+                .await
+                .ok()
+                .flatten()
         }
     }));
     Ok(use_memo(move || {

crates/weaver-app/src/env.rs

···
 // This file is automatically generated by build.rs
 
 #[allow(unused)]
-pub const WEAVER_APP_ENV: &'static str = "prod";
+pub const WEAVER_APP_ENV: &'static str = "dev";
 #[allow(unused)]
-pub const WEAVER_APP_HOST: &'static str = "https://alpha.weaver.sh";
+pub const WEAVER_APP_HOST: &'static str = "http://localhost";
 #[allow(unused)]
-pub const WEAVER_APP_DOMAIN: &'static str = "https://alpha.weaver.sh";
+pub const WEAVER_APP_DOMAIN: &'static str = "";
 #[allow(unused)]
 pub const WEAVER_PORT: &'static str = "8080";
 #[allow(unused)]

crates/weaver-app/src/main.rs

···
                         // Enable incremental rendering
                         .incremental(
                             dioxus::server::IncrementalRendererConfig::new()
-                                .static_dir(
-                                    std::env::current_exe()
-                                        .unwrap()
-                                        .parent()
-                                        .unwrap()
-                                        .join("public"),
-                                )
+                                .pre_render(true)
                                 .clear_cache(false),
                         )
                         .enable_out_of_order_streaming(),
···
     }
 }
 
-#[server(endpoint = "static_routes", output = server_fn::codec::Json)]
-async fn static_routes() -> Result<Vec<String>, ServerFnError> {
-    // The `Routable` trait has a `static_routes` method that returns all static routes in the enum
-    Ok(Route::static_routes()
-        .iter()
-        .map(ToString::to_string)
-        .collect())
-}
+// #[server(endpoint = "static_routes", output = server_fn::codec::Json)]
+// async fn static_routes() -> Result<Vec<String>, ServerFnError> {
+//     // The `Routable` trait has a `static_routes` method that returns all static routes in the enum
+//     Ok(Route::static_routes()
+//         .iter()
+//         .map(ToString::to_string)
+//         .collect())
+// }

crates/weaver-app/src/views/home.rs

···
-use crate::{Route, components::identity::NotebookCard, fetch};
+use crate::{Route, components::identity::NotebookCard, data};
 use dioxus::prelude::*;
 use jacquard::types::aturi::AtUri;
 
···
 /// The Home page component that will be rendered when the current route is `[Route::Home]`
 #[component]
 pub fn Home() -> Element {
-    let fetcher = use_context::<fetch::CachedFetcher>();
-
-    // Fetch notebooks from UFOS
-    let notebooks = use_resource(move || {
-        let fetcher = fetcher.clone();
-        async move { fetcher.fetch_notebooks_from_ufos().await }
-    });
+    // Fetch notebooks from UFOS with SSR support
+    let notebooks = data::use_notebooks_from_ufos().ok();
     let navigator = use_navigator();
     let mut uri_input = use_signal(|| String::new());
 
···
                 }
             }
             div { class: "notebooks-list",
-                match notebooks() {
-                    Some(Ok(notebook_list)) => rsx! {
-                        for notebook in notebook_list.iter() {
-                            {
-                                let view = &notebook.0;
-                                let entries = &notebook.1;
-                                rsx! {
-                                    div {
-                                        key: "{view.cid}",
-                                        NotebookCard {
-                                            notebook: view.clone(),
-                                            entry_refs: entries.clone()
+                if let Some(notebooks_memo) = &notebooks {
+                    match &*notebooks_memo.read_unchecked() {
+                        Some(notebook_list) => rsx! {
+                            for notebook in notebook_list.iter() {
+                                {
+                                    let view = &notebook.0;
+                                    let entries = &notebook.1;
+                                    rsx! {
+                                        div {
+                                            key: "{view.cid}",
+                                            NotebookCard {
+                                                notebook: view.clone(),
+                                                entry_refs: entries.clone()
+                                            }
                                         }
                                     }
                                 }
                             }
+                        },
+                        None => rsx! {
+                            div { "Loading notebooks..." }
                         }
-                    },
-                    Some(Err(_)) => rsx! {
-                        div { "Error loading notebooks" }
-                    },
-                    None => rsx! {
-                        div { "Loading notebooks..." }
                     }
+                } else {
+                    div { "Loading notebooks..." }
                 }
             }
         }

crates/weaver-app/src/views/notebook.rs

···
 use crate::{
     Route,
     components::{EntryCard, NotebookCover, NotebookCss},
-    fetch,
+    data,
 };
 use dioxus::prelude::*;
 use jacquard::{
···
     ident: ReadSignal<AtIdentifier<'static>>,
     book_title: ReadSignal<SmolStr>,
 ) -> Element {
-    let fetcher = use_context::<fetch::CachedFetcher>();
-    // Fetch full notebook to get author count
-    let data_fetcher = fetcher.clone();
-    let notebook_data = use_resource(move || {
-        let fetcher = data_fetcher.clone();
-        async move {
-            fetcher
-                .get_notebook(ident(), book_title())
-                .await
-                .ok()
-                .flatten()
-        }
-    });
+    // Fetch full notebook metadata with SSR support
+    let notebook_data = data::use_notebook(ident(), book_title()).ok();
 
-    // Also fetch entries
-    let entry_fetcher = fetcher.clone();
-    let entries_resource = use_resource(move || {
-        let fetcher = entry_fetcher.clone();
-        async move {
-            fetcher
-                .list_notebook_entries(ident(), book_title())
-                .await
-                .ok()
-                .flatten()
-        }
-    });
+    // Fetch entries with SSR support
+    let entries_resource = data::use_notebook_entries(ident(), book_title()).ok();
 
     rsx! {
         document::Link { rel: "stylesheet", href: ENTRY_CARD_CSS }
 
-        match (&*notebook_data.read_unchecked(), &*entries_resource.read_unchecked()) {
-            (Some(Some(data)), Some(Some(entries))) => {
-                let (notebook_view, _) = data.as_ref();
-                let author_count = notebook_view.authors.len();
+        if let (Some(notebook_memo), Some(entries_memo)) = (&notebook_data, &entries_resource) {
+            match (&*notebook_memo.read_unchecked(), &*entries_memo.read_unchecked()) {
+                (Some(data), Some(entries)) => {
+                    let (notebook_view, _) = data;
+                    let author_count = notebook_view.authors.len();
 
-                rsx! {
-                    div { class: "notebook-layout",
-                        aside { class: "notebook-sidebar",
-                            NotebookCover {
-                                notebook: notebook_view.clone(),
-                                title: book_title().to_string()
+                    rsx! {
+                        div { class: "notebook-layout",
+                            aside { class: "notebook-sidebar",
+                                NotebookCover {
+                                    notebook: notebook_view.clone(),
+                                    title: book_title().to_string()
+                                }
                             }
-                        }
 
-                        main { class: "notebook-main",
-                            div { class: "entries-list",
-                                for entry in entries {
-                                    EntryCard {
-                                        entry: entry.clone(),
-                                        book_title: book_title(),
-                                        author_count
+                            main { class: "notebook-main",
+                                div { class: "entries-list",
+                                    for entry in entries {
+                                        EntryCard {
+                                            entry: entry.clone(),
+                                            book_title: book_title(),
+                                            author_count
+                                        }
                                     }
                                 }
                             }
                         }
                     }
-                }
-            },
-            (Some(None), _) | (_, Some(None)) => rsx! { div { class: "error", "Notebook or entries not found" } },
-            _ => rsx! { div { class: "loading", "Loading..." } }
+                },
+                _ => rsx! { div { class: "loading", "Loading..." } }
+            }
+        } else {
+            div { class: "loading", "Loading..." }
         }
     }
 }