From 0e902e1f0a56e2f59cb91065a0ad8600631a1e49 Mon Sep 17 00:00:00 2001 From: cel 🌸 Date: Sat, 26 Apr 2025 14:57:41 +0100 Subject: before removing leptos-query --- src/lib.rs | 265 +++++++++++++++++++++++++++++++++++++++++++++++++++++++----- src/main.rs | 3 + 2 files changed, 247 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/lib.rs b/src/lib.rs index 8e4f407..b6e7cea 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,12 +1,18 @@ use std::{ops::{Deref, DerefMut}, str::FromStr, sync::Arc, thread::sleep, time::{self, Duration}}; -use filamento::{db::Db, files::FilesMem, UpdateMessage}; +use filamento::{chat::{Chat, Message}, db::Db, error::{CommandError, ConnectionError, DatabaseError}, files::FilesMem, user::User, UpdateMessage}; +use indexmap::IndexMap; use jid::JID; -use leptos::{logging::debug_warn, prelude::*, task::spawn_local}; +use leptos::{prelude::*, task::spawn_local}; +use futures::stream::StreamExt; use leptos_meta::Stylesheet; +use leptos_query::{create_query, provide_query_client, provide_query_client_with_options, DefaultQueryOptions, QueryOptions, QueryResult, QueryScope}; +use leptos_reactive::{SignalGetUntracked, SignalStream}; use stylance::import_style; use thiserror::Error; use tokio::{sync::mpsc::Receiver}; +use tracing::debug; +use uuid::Uuid; pub enum AppState { LoggedOut, @@ -44,7 +50,6 @@ pub fn App() -> impl IntoView { AppState::LoggedOut => view! { }.into_any(), AppState::LoggedIn => { if let Some((client, updates)) = client.write_untracked().take() { - debug_warn!("opening app"); view! { }.into_any() } else { set_app.set(AppState::LoggedOut); @@ -63,6 +68,8 @@ pub enum LoginError { MissingJID, #[error("Invalid JID: {0}")] InvalidJID(#[from] jid::ParseError), + #[error("Connection Error: {0}")] + ConnectionError(#[from] CommandError), } #[component] @@ -71,8 +78,8 @@ fn LoginPage(set_app: WriteSignal, set_client: RwSignal); + let (error, set_error) = signal_local(None::); let error_message = move || { error.with(|error| { if let Some(error) = error { @@ -85,7 +92,7 @@ fn LoginPage(set_app: WriteSignal, set_client: RwSignal, set_client: RwSignal {}, + Err(e) => { + set_error.set(Some(e.into())); + set_login_pending.set(false); + return + }, + } + } // debug!("before setting app state"); set_client.set(Some((client, updates))); - debug_warn!("going"); set_app.set(AppState::LoggedIn); - debug_warn!("gone"); } }); @@ -196,27 +211,235 @@ fn Macaw( client: Client, mut updates: Receiver, ) -> impl IntoView { + // TODO: is there some kind of context_local? let client = RwSignal::new_local(client); provide_context(client); - debug_warn!("ajsdlkfjalsf"); + + let (new_messages, set_new_messages) = signal(None::<(JID, MacawMessage)>); + provide_context(new_messages); + + provide_query_client_with_options(DefaultQueryOptions { + resource_option: leptos_query::ResourceOption::Local, + ..Default::default() + }); let updates_routine = OnceResource::new(async move { - debug_warn!("started"); while let Some(update) = updates.recv().await { match update { - UpdateMessage::Online(online, items) => todo!(), - UpdateMessage::Offline(offline) => todo!(), - UpdateMessage::RosterUpdate(contact, user) => todo!(), - UpdateMessage::RosterDelete(jid) => todo!(), - UpdateMessage::Presence { from, presence } => todo!(), - UpdateMessage::Message { to, from, message } => todo!(), - UpdateMessage::MessageDelivery { id, chat, delivery } => todo!(), - UpdateMessage::SubscriptionRequest(jid) => todo!(), - UpdateMessage::NickChanged { jid, nick } => todo!(), - UpdateMessage::AvatarChanged { jid, id } => todo!(), + UpdateMessage::Online(online, items) => {}, + UpdateMessage::Offline(offline) => {}, + UpdateMessage::RosterUpdate(contact, user) => {}, + UpdateMessage::RosterDelete(jid) => {}, + UpdateMessage::Presence { from, presence } => {}, + UpdateMessage::Message { to, from, message } => { + let new_message = MacawMessage::got_message_and_user(message, from); + set_new_messages.set(Some((to, new_message))); + }, + UpdateMessage::MessageDelivery { id, chat, delivery } => {}, + UpdateMessage::SubscriptionRequest(jid) => {}, + UpdateMessage::NickChanged { jid, nick } => {}, + UpdateMessage::AvatarChanged { jid, id } => {}, + } + } + }); + + view! { + "logged in" + + } +} + +fn chat_query() -> QueryScope> { + create_query(get_chat, QueryOptions::default()) +} + +async fn get_chat(jid: JID) -> Result { + let client: Client = use_context::>().unwrap().read_untracked().clone(); + client.get_chat(jid).await.map_err(|e| e.to_string()) +} + +fn user_query() -> QueryScope> { + create_query(get_user, QueryOptions::default()) +} + +async fn get_user(jid: JID) -> Result { + let client: Client = use_context::>().unwrap().read_untracked().clone(); + client.get_user(jid).await.map_err(|e| e.to_string()) +} + +fn message_query() -> QueryScope> { + create_query(get_message, QueryOptions::default()) +} + +async fn get_message(id: Uuid) -> Result { + let client: Client = use_context::>().unwrap().read_untracked().clone(); + client.get_message(id).await.map_err(|e| e.to_string()) +} + +// fn got_chat(chat: Chat) -> QueryScope { +// let fetcher = move |_| { +// let chat = (&chat).clone(); +// async { +// MacawChat { +// chat +// } +// }}; +// create_query(fetcher, QueryOptions::default()) +// } + +#[derive(Clone)] +struct MacawChat { + chat: ReadSignal>>>, + user: ReadSignal>>>, +} + +impl MacawChat { + fn got_chat_and_user(chat: Chat, user: User) -> Self { + let correspondent = chat.correspondent.clone(); + let chat_query = chat_query(); + chat_query.set_query_data(correspondent.clone(), Ok(chat)); + let chat = chat_query.use_query(move || correspondent.clone()); + let jid = user.jid.clone(); + let user_query = user_query(); + user_query.set_query_data(jid.clone(), Ok(user)); + let user = user_query.use_query(move || jid.clone()); + Self { + chat: ReadSignal::from_stream_unsync(chat.data.to_stream()), + user: ReadSignal::from_stream_unsync(user.data.to_stream()), + } + } + + fn get(jid: JID) -> Self { + let jid1 = jid.clone(); + let chat = chat_query().use_query(move || (&jid1).clone()); + let user = user_query().use_query(move || (&jid).clone()); + Self { + chat: ReadSignal::from_stream_unsync(chat.data.to_stream()), + user: ReadSignal::from_stream_unsync(user.data.to_stream()), + } + } +} + +impl Deref for MacawChat { + type Target = ReadSignal>>>; + + fn deref(&self) -> &Self::Target { + &self.chat + } +} + +impl DerefMut for MacawChat { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.chat + } +} + +#[derive(Clone)] +struct MacawMessage { + message: ReadSignal>>>, + user: ReadSignal>>>, +} + +impl MacawMessage { + fn got_message_and_user(message: Message, user: User) -> Self { + debug!("executing the got message"); + let message_id = message.id; + let message_query = message_query(); + message_query.set_query_data(message.id, Ok(message)); + let message = message_query.use_query(move || message_id); + let jid = user.jid.clone(); + let user_query = user_query(); + user_query.set_query_data(jid.clone(), Ok(user)); + let user = user_query.use_query(move || jid.clone()); + Self { + message: ReadSignal::from_stream_unsync(message.data.to_stream()), + user: ReadSignal::from_stream_unsync(user.data.to_stream()), + } + } +} + +impl Deref for MacawMessage { + type Target = ReadSignal>>>; + + fn deref(&self) -> &Self::Target { + &self.message + } +} + +impl DerefMut for MacawMessage { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.message + } +} + +fn ChatsList() -> impl IntoView { + let chats: LocalResource, LocalStorage>, WriteSignal, LocalStorage>), String>> = LocalResource::new(move || async move || -> Result<_, _> { + let client: Client = use_context::>().unwrap().read().clone(); + let chats = client.get_chats_ordered_with_latest_messages_and_users().await.map_err(|e| e.to_string())?; + let chats = chats.into_iter().map(|((chat, chat_user), (message, message_user))| { + (chat.correspondent.clone(), (MacawChat::got_chat_and_user(chat, chat_user), MacawMessage::got_message_and_user(message, message_user))) + + }).collect::>(); + let (chats, set_chats) = signal_local(chats); + Ok((chats, set_chats)) + }()); + + // TODO: filter new messages signal + let new_messages_signal: ReadSignal> = use_context().unwrap(); + OnceResource::new(async move { + let mut new_message = new_messages_signal.to_stream(); + match chats.await { + Ok((c, set_c)) => { + while let Some(new_message) = new_message.next().await { + debug!("got new message in let"); + if let Some((to, new_message)) = new_message { + if let Some((chat, _latest_message)) = set_c.write().shift_remove(&to) { + debug!("chat existed"); + set_c.write().insert_before(0, to, (chat, new_message)); + debug!("done setting"); + } else { + debug!("the chat didn't exist"); + let chat = MacawChat::get(to.clone()); + set_c.write().insert_before(0, to, (chat, new_message)); + debug!("done setting"); + } + } + } + debug!("set the new message"); } + Err(_) => {}, } }); - view! { "logged in" } + view! { +
+

Chats

+
+ {move || { + if let Some(chats) = &*chats.read() { + match &**chats { + Ok((chats, _)) => { + let chats = chats.clone(); + view! { + +

{chat.0.to_string()}

+ + } + .into_any() + } + Err(e) => { + view! {
{format!("{}", e)}
}.into_any() + } + } + } else { + None::.into_any() + } + }} +
+
+ } } diff --git a/src/main.rs b/src/main.rs index 8b89d4d..fd4a1de 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,5 +2,8 @@ use leptos::prelude::*; use macaw_web::App; fn main() { + tracing_wasm::set_as_global_default(); + console_error_panic_hook::set_once(); + leptos::mount::mount_to_body(App) } -- cgit