wip

crates/ascend/src/app.rs

@@ -1,3 +1,4 @@
+use crate::codec::ron::Ron;
 use crate::pages;
 use leptos::prelude::*;
 use leptos_router::components::*;
@@ -55,29 +56,34 @@ pub fn Home() -> impl leptos::IntoView {
 
     tracing::debug!("Rendering home component");
 
-    let action = Action::new(|()| async move {
+    // dbg!(leptos::prelude::Owner::current().map(|o| o.ancestry()));
-        tracing::debug!("running action");
-        let walls = crate::server_functions::get_walls()
-            .await
-            .inspect_err(|e| {
-                dbg!(e);
-            })
-            .expect("failed to get walls")
-            .into_inner();
-        let wall = walls.first();
 
-        if let Some(wall) = wall {
+    let wall_uid = OnceResource::<_, Ron>::new_with_options(
+        async move {
+            // dbg!(leptos::prelude::Owner::current().map(|o| o.ancestry()));
+            let walls = crate::server_functions::get_walls()
+                .await
+                .inspect_err(|e| {
+                    dbg!(e);
+                })
+                .expect("failed to get walls")
+                .into_inner();
+            walls.first().map(|wall| wall.uid)
+        },
+        false,
+    );
+
+    Effect::new(move || {
+        tracing::debug!("running effect");
+
+        if let Some(wall_uid) = wall_uid.get().flatten() {
+            tracing::debug!("navigating");
             let navigate = leptos_router::hooks::use_navigate();
-            let url = format!("/wall/{}", wall.uid);
+            let url = format!("/wall/{}", wall_uid);
             navigate(&url, Default::default());
+            tracing::debug!("navigated");
         }
     });
 
-    tracing::debug!("dispatching action...");
-
-    action.dispatch(());
-
-    tracing::debug!("dispatched action");
-
     leptos::view! {}
 }

crates/ascend/src/components/header.rs

@@ -1,11 +1,13 @@
 use leptos::prelude::*;
 
+#[derive(Debug, Clone)]
 pub struct HeaderItems {
     pub left: Vec<HeaderItem>,
     pub middle: Vec<HeaderItem>,
     pub right: Vec<HeaderItem>,
 }
 
+#[derive(Debug, Clone)]
 pub struct HeaderItem {
     pub text: String,
     pub link: Option<String>,
@@ -13,7 +15,7 @@ pub struct HeaderItem {
 
 /// Header with background color etc.
 #[component]
-pub fn StyledHeader(items: HeaderItems) -> impl IntoView {
+pub fn StyledHeader(#[prop(into)] items: Signal<HeaderItems>) -> impl IntoView {
     view! {
         <div class="bg-orange-300 text-black border-b-2 border-b-orange-400">
             // <div class="container mx-auto" >
@@ -25,32 +27,34 @@ pub fn StyledHeader(items: HeaderItems) -> impl IntoView {
 
 /// Function header without styling
 #[component]
-pub fn Header(items: HeaderItems) -> impl IntoView {
+pub fn Header(#[prop(into)] items: Signal<HeaderItems>) -> impl IntoView {
-    let HeaderItems { left, middle, right } = items;
+    let left = move || items.read().left.clone();
+    let middle = move || items.read().middle.clone();
+    let right = move || items.read().right.clone();
 
     view! {
         <div class="grid grid-cols-[1fr_3fr_1fr] text-xl font-semibold p-4">
             // Left side of header
             <div class="justify-self-start">
-                <Items items=left />
+                <Items items=Signal::derive(left) />
             </div>
 
             // Expanding space in the middle
             <div class="justify-self-center font-semibold">
-                <Items items=middle />
+                <Items items=Signal::derive(middle) />
             </div>
 
             // Right side of header
             <div class="justify-self-end">
-                <Items items=right />
+                <Items items=Signal::derive(right) />
             </div>
         </div>
     }
 }
 
 #[component]
-fn Items(items: Vec<HeaderItem>) -> impl IntoView {
+fn Items(#[prop(into)] items: Signal<Vec<HeaderItem>>) -> impl IntoView {
-    let items = items.into_iter().map(|item| view! { <Item item /> }).collect_view();
+    let items = move || items.get().into_iter().map(|item| view! { <Item item /> }).collect_view();
     view! { <div class="flex gap-4">{items}</div> }
 }
 

crates/ascend/src/pages/wall.rs

@@ -58,7 +58,7 @@ pub fn Wall() -> impl leptos::IntoView {
 
     leptos::view! {
         <div class="min-w-screen min-h-screen bg-slate-900">
-            <StyledHeader items=header_items() />
+            <StyledHeader items=Signal::derive(header_items) />
 
             <div class="m-2">
                 <Suspense fallback=move || {

crates/ascend/src/server.rs

@@ -63,6 +63,7 @@ async fn serve(cli: Cli) -> Result<(), Error> {
     let leptos_options = leptos_conf_file.leptos_options;
     let addr = leptos_options.site_addr;
     let routes = generate_route_list(App);
+    dbg!(&routes);
 
     let config = load_config(cli)?;
 

crates/ascend/src/server_functions.rs

@@ -4,19 +4,20 @@ use crate::models;
 use leptos::prelude::expect_context;
 use leptos::server;
 use server_fn::ServerFnError;
-use server_fn::error::ServerFnErrorErr;
 
 #[server(
     input = Ron,
     output = Ron,
     custom = RonEncoded
 )]
-#[tracing::instrument(skip_all, err(Debug))]
+// #[tracing::instrument(skip_all, err(Debug))]
-pub(crate) async fn get_walls() -> Result<RonEncoded<Vec<models::Wall>>, ServerFnError> {
+pub async fn get_walls() -> Result<RonEncoded<Vec<models::Wall>>, ServerFnError> {
     use crate::server::db::Database;
     use redb::ReadableTable;
     tracing::debug!("Enter");
 
+    // dbg!(leptos::prelude::Owner::current().map(|o| o.ancestry()));
+
     let db = expect_context::<Database>();
 
     let walls = db
@@ -27,6 +28,8 @@ pub(crate) async fn get_walls() -> Result<RonEncoded<Vec<models::Wall>>, ServerF
         })
         .await?;
 
+    tracing::debug!("Exit");
+
     Ok(RonEncoded::new(walls))
 }