feat(web): refresh token every hour, small refactor

web/src/app.rs

@@ -1,6 +1,5 @@
 use leptos::*;
 use leptos_router::*;
-use reqwest::Method;
 use crate::prelude::*;
 
 use leptos_use::{storage::use_local_storage, use_cookie, utils::{FromToStringCodec, JsonCodec}};
@@ -36,36 +35,21 @@ pub fn App() -> impl IntoView {
 
 	let title_target = move || if auth.present() { "/web/home" } else { "/web/server" };
 
-	if let Some(tok) = token.get_untracked() {
+	local_tl.more(auth); // public outbox never contains private posts
-		spawn_local(async move {
+	spawn_local(async move {
-			// refresh token first, or verify that we're still authed
+		// refresh token first, or verify that we're still authed
-			match reqwest::Client::new()
+		if Auth::refresh(auth.token, set_token, set_userid).await {
-				.request(Method::PATCH, format!("{URL_BASE}/auth"))
+			home_tl.more(auth); // home inbox requires auth to be read
-				.json(&serde_json::json!({"token": tok}))
+		}
-				.send()
+		server_tl.more(auth); // server inbox may contain private posts
-				.await
+	});
-			{
-				Err(e) => tracing::error!("could not refresh token: {e}"),
-				Ok(res) => match res.error_for_status() {
-					Err(e) => tracing::error!("server rejected refresh: {e}"),
-					Ok(doc) => match doc.json::<AuthResponse>().await {
-						Err(e) => tracing::error!("failed parsing auth response: {e}"),
-						Ok(auth) => {
-							set_token.set(Some(auth.token));
-							set_userid.set(Some(auth.user));
-						},
-					}
-				}
-			}
 
-			server_tl.more(auth);
+
-			local_tl.more(auth);
+	// refresh token every hour
-			if auth.token.get_untracked().is_some() { home_tl.more(auth) };
+	set_interval(
-		})
+		move || spawn_local(async move { Auth::refresh(auth.token, set_token, set_userid).await; }),
-	} else {
+		std::time::Duration::from_secs(3600)
-		server_tl.more(auth);
+	);
-		local_tl.more(auth);
-	}
 
 	view! {
 		<nav class="w-100 mt-1 mb-1 pb-s">

web/src/auth.rs

@@ -1,13 +1,6 @@
 use leptos::*;
-use crate::URL_BASE;
+use reqwest::Method;
-
+use crate::{components::AuthResponse, URL_BASE};
-pub trait AuthToken {
-	fn present(&self) -> bool;
-	fn token(&self) -> String;
-	fn user_id(&self) -> String;
-	fn username(&self) -> String;
-	fn outbox(&self) -> String;
-}
 
 #[derive(Debug, Clone, Copy)]
 pub struct Auth {
@@ -15,16 +8,16 @@ pub struct Auth {
 	pub userid: Signal<Option<String>>,
 }
 
-impl AuthToken for Auth {
+impl Auth {
-	fn token(&self) -> String {
+	pub fn token(&self) -> String {
 		self.token.get().unwrap_or_default()
 	}
 
-	fn user_id(&self) -> String {
+	pub fn user_id(&self) -> String {
 		self.userid.get().unwrap_or_default()
 	}
 	
-	fn username(&self) -> String {
+	pub fn username(&self) -> String {
 		// TODO maybe cache this?? how often do i need it?
 		self.userid.get()
 			.unwrap_or_default()
@@ -34,11 +27,40 @@ impl AuthToken for Auth {
 			.to_string()
 	}
 
-	fn present(&self) -> bool {
+	pub fn present(&self) -> bool {
 		self.token.get().map_or(false, |x| !x.is_empty())
 	}
 
-	fn outbox(&self) -> String {
+	pub fn outbox(&self) -> String {
 		format!("{URL_BASE}/actors/{}/outbox", self.username())
 	}
+
+	pub async fn refresh(
+		token: Signal<Option<String>>,
+		set_token: WriteSignal<Option<String>>,
+		set_userid: WriteSignal<Option<String>>
+	) -> bool {
+		if let Some(tok) = token.get_untracked() {
+			match reqwest::Client::new()
+				.request(Method::PATCH, format!("{URL_BASE}/auth"))
+				.json(&serde_json::json!({"token": tok}))
+				.send()
+				.await
+			{
+				Err(e) => tracing::error!("could not refresh token: {e}"),
+				Ok(res) => match res.error_for_status() {
+					Err(e) => tracing::error!("server rejected refresh: {e}"),
+					Ok(doc) => match doc.json::<AuthResponse>().await {
+						Err(e) => tracing::error!("failed parsing auth response: {e}"),
+						Ok(auth) => {
+							set_token.set(Some(auth.token));
+							set_userid.set(Some(auth.user));
+							return true;
+						},
+					}
+				}
+			}
+		}
+		false
+	}
 }

web/src/components/timeline.rs

@@ -83,21 +83,23 @@ pub fn TimelineRepliesRecursive(tl: Timeline, root: String) -> impl IntoView {
 	let root_values = move || tl.feed
 		.get()
 		.into_iter()
-		.filter_map(|x| CACHE.get(&x))
 		.filter_map(|x| {
-			let oid = match x.object_type().ok()? {
+			let document = CACHE.get(&x)?;
+			let (oid, reply) = match document.object_type().ok()? {
 				// if it's a create, get and check created object: does it reply to root?
-				apb::ObjectType::Activity(apb::ActivityType::Create) =>
+				apb::ObjectType::Activity(apb::ActivityType::Create) => {
-					CACHE.get(x.object().id().ok()?)?.in_reply_to().id().str()?,
+					let object = CACHE.get(document.object().id().ok()?)?;
+					(object.id().str()?, object.in_reply_to().id().str()?)
+				},
 
 				// if it's a raw note, directly check if it replies to root
-				apb::ObjectType::Note => x.in_reply_to().id().str()?,
+				apb::ObjectType::Note => (document.id().str()?, document.in_reply_to().id().str()?),
 
 				// if it's anything else, check if it relates to root, maybe like or announce?
-				_ => x.object().id().str()?,
+				_ => (document.id().str()?, document.object().id().str()?),
 			};
-			if oid == root {
+			if reply == root {
-				Some((oid, x))
+				Some((oid, document))
 			} else {
 				None
 			}
@@ -108,7 +110,7 @@ pub fn TimelineRepliesRecursive(tl: Timeline, root: String) -> impl IntoView {
 		<For
 			each=root_values
 			key=|(id, _obj)| id.clone()
-			children=move |(id, obj)| {
+			children=move |(id, obj)|
 				view! {
 					<div class="context depth-r">
 						<Item item=obj replies=true />
@@ -117,7 +119,6 @@ pub fn TimelineRepliesRecursive(tl: Timeline, root: String) -> impl IntoView {
 						</div>
 					</div>
 				}
-			}
 		/ >
 	}
 }

web/src/page/object.rs

@@ -10,8 +10,6 @@ use apb::{Base, Object};
 pub fn ObjectPage(tl: Timeline) -> impl IntoView {
 	let params = use_params_map();
 	let auth = use_context::<Auth>().expect("missing auth context");
-	let id = params.get().get("id").cloned().unwrap_or_default();
-	let uid =  uriproxy::uri(URL_BASE, uriproxy::UriClass::Object, &id);
 	let object = create_local_resource(
 		move || params.get().get("id").cloned().unwrap_or_default(),
 		move |oid| async move {
@@ -38,7 +36,7 @@ pub fn ObjectPage(tl: Timeline) -> impl IntoView {
 			};
 			if let Ok(ctx) = obj.context().id() {
 				let tl_url = format!("{}/context/page", Uri::api(U::Object, ctx, false));
-				if !tl.next.get().starts_with(&tl_url) {
+				if !tl.next.get_untracked().starts_with(&tl_url) {
 					tl.reset(tl_url);
 				}
 			}
@@ -64,7 +62,8 @@ pub fn ObjectPage(tl: Timeline) -> impl IntoView {
 				{move || match object.get() {
 					None => view! { <p class="center"> loading ... </p> }.into_view(),
 					Some(None) => {
-						let uid = uid.clone();
+						let raw_id = params.get().get("id").cloned().unwrap_or_default();
+						let uid =  uriproxy::uri(URL_BASE, uriproxy::UriClass::Object, &raw_id);
 						view! { <p class="center"><code>loading failed</code><sup><small><a class="clean" href={uid} target="_blank">"↗"</a></small></sup></p> }.into_view()
 					},
 					Some(Some(o)) => {

web/src/page/user.rs

@@ -33,7 +33,7 @@ pub fn UserPage(tl: Timeline) -> impl IntoView {
 		move |id| {
 			async move {
 				let tl_url = format!("{}/outbox/page", Uri::api(U::Actor, &id, false));
-				if !tl.next.get().starts_with(&tl_url) {
+				if !tl.next.get_untracked().starts_with(&tl_url) {
 					tl.reset(tl_url);
 				}
 				match CACHE.get(&Uri::full(U::Actor, &id)) {