Merge pull request #145 from rambit-systems/push-tpkluuntmztl

Incremental UI Push #26

Author: johnbchron

crates/grid/src/handlers.rs

@@ -59,6 +59,7 @@ pub fn context_provider(
   move || {
     provide_context(app_state.prime_domain.clone());
     provide_context(app_state.auth_domain.clone());
+    provide_context(auth_session.clone());
     if let Some(auth_user) = auth_session.user.clone() {
       provide_context(auth_user);
     }

crates/site-app/src/hooks.rs

@@ -1,10 +1,14 @@
 //! Hooks are reusable pieces of reactive logic extracted from render contexts.
 
 mod cache_hook;
+mod create_cache_hook;
 mod entry_hook;
 mod login_hook;
 mod org_hook;
 mod signup_hook;
 
 // pub use self::cache_hook::*;
-pub use self::{entry_hook::*, login_hook::*, org_hook::*, signup_hook::*};
+pub use self::{
+  create_cache_hook::*, entry_hook::*, login_hook::*, org_hook::*,
+  signup_hook::*,
+};

crates/site-app/src/hooks/create_cache_hook.rs

@@ -0,0 +1,181 @@
+use leptos::{ev::Event, prelude::*};
+use leptos_fetch::QueryClient;
+use models::{
+  dvf::{EntityName, RecordId, StrictSlug, Visibility},
+  Cache, Org,
+};
+
+use super::OrgHook;
+use crate::{
+  components::InputIcon, navigation::navigate_to,
+  reactive_utils::touched_input_bindings,
+};
+
+pub struct CreateCacheHook {
+  org_hook:              OrgHook,
+  name_signal:           RwSignal<String>,
+  visibility_signal:     RwSignal<Visibility>,
+  sanitized_name_memo:   Memo<Option<EntityName>>,
+  name_after_icon_memo:  Memo<Option<InputIcon>>,
+  is_available_resource: LocalResource<Option<Result<bool, ServerFnError>>>,
+  action:                ServerAction<CreateCache>,
+}
+
+impl CreateCacheHook {
+  pub fn new() -> Self {
+    let org_hook = OrgHook::new_requested();
+
+    let name_signal = RwSignal::new(String::new());
+    let sanitized_name_memo = Memo::new(move |_| {
+      Some(EntityName::new(StrictSlug::new(name_signal())))
+        .filter(|n| !n.to_string().is_empty())
+    });
+    let visibility_signal = RwSignal::new(Visibility::Private);
+
+    let query_client = expect_context::<QueryClient>();
+    let is_available_key_fn =
+      move || sanitized_name_memo().map(|n| n.to_string());
+    let is_available_query_scope =
+      crate::resources::cache::cache_name_is_available_query_scope();
+    let is_available_resource = expect_context::<QueryClient>()
+      .local_resource(is_available_query_scope.clone(), is_available_key_fn);
+    let is_available_fetching = query_client
+      .subscribe_is_fetching(is_available_query_scope, is_available_key_fn);
+
+    let name_after_icon_memo = Memo::new(move |_| {
+      match (is_available_fetching(), is_available_resource.get()) {
+        (true, _) => Some(InputIcon::Loading),
+        (_, Some(Some(Ok(true)))) => Some(InputIcon::Check),
+        (_, Some(Some(Ok(false)))) => Some(InputIcon::XMark),
+        _ => None,
+      }
+    });
+
+    let action = ServerAction::<CreateCache>::new();
+
+    Self {
+      org_hook,
+      name_signal,
+      visibility_signal,
+      sanitized_name_memo,
+      name_after_icon_memo,
+      is_available_resource,
+      action,
+    }
+  }
+
+  pub fn name_after_icon(&self) -> Memo<Option<InputIcon>> {
+    self.name_after_icon_memo
+  }
+
+  pub fn name_warn_hint(&self) -> Signal<Option<String>> {
+    let (name_signal, sanitized_name_memo) =
+      (self.name_signal, self.sanitized_name_memo);
+    Signal::derive(move || {
+      let (name, Some(sanitized_name)) =
+        (name_signal.get(), sanitized_name_memo())
+      else {
+        return None;
+      };
+      if name != sanitized_name.clone().to_string() {
+        return Some(format!(
+          "This name will be converted to \"{sanitized_name}\"."
+        ));
+      }
+      None
+    })
+  }
+
+  pub fn name_error_hint(&self) -> Signal<Option<String>> {
+    let (is_available_resource, sanitized_name_memo) =
+      (self.is_available_resource, self.sanitized_name_memo);
+    Signal::derive(move || {
+      match (is_available_resource.get(), sanitized_name_memo()) {
+        (Some(Some(Ok(false))), Some(sanitized_name)) => {
+          Some(format!("The name \"{sanitized_name}\" is unavailable."))
+        }
+        (Some(Some(Err(_))), _) => {
+          Some("Sorry, something went wrong.".to_owned())
+        }
+        _ => None,
+      }
+    })
+  }
+
+  pub fn name_bindings(&self) -> (Callback<(), String>, Callback<Event>) {
+    touched_input_bindings(self.name_signal)
+  }
+
+  pub fn visibility_signal(&self) -> RwSignal<Visibility> {
+    self.visibility_signal
+  }
+
+  pub fn show_spinner(&self) -> Signal<bool> {
+    let (pending, value) = (self.action.pending(), self.action.value());
+    // show if the action is loading or completed successfully
+    Signal::derive(move || pending() || matches!(value.get(), Some(Ok(_))))
+  }
+
+  pub fn action_trigger(&self) -> Callback<()> {
+    let (
+      org,
+      visibility_signal,
+      sanitized_name_memo,
+      is_available_resource,
+      action,
+    ) = (
+      self.org_hook.key(),
+      self.visibility_signal,
+      self.sanitized_name_memo,
+      self.is_available_resource,
+      self.action,
+    );
+    Callback::new(move |()| {
+      // the name has been checked and is available
+      if sanitized_name_memo().is_some()
+        && matches!(is_available_resource.get(), Some(Some(Ok(true))))
+      {
+        action.dispatch_local(CreateCache {
+          org:        org(),
+          name:       sanitized_name_memo().unwrap().to_string(),
+          visibility: visibility_signal(),
+        });
+      }
+    })
+  }
+
+  pub fn create_redirect_effect(&self) -> Effect<LocalStorage> {
+    let (dashboard_url, action) = (self.org_hook.dashboard_url(), self.action);
+    Effect::new(move || {
+      if matches!(action.value().get(), Some(Ok(_))) {
+        navigate_to(&dashboard_url());
+      }
+    })
+  }
+}
+
+#[server(prefix = "/api/sfn")]
+pub async fn create_cache(
+  org: RecordId<Org>,
+  name: String,
+  visibility: Visibility,
+) -> Result<RecordId<Cache>, ServerFnError> {
+  use prime_domain::PrimeDomainService;
+
+  crate::resources::authorize_for_org(org)?;
+
+  let prime_domain_service: PrimeDomainService = expect_context();
+
+  let sanitized_name = EntityName::new(StrictSlug::new(name.clone()));
+  if name != sanitized_name.clone().to_string() {
+    return Err(ServerFnError::new("name is unsanitized"));
+  }
+
+  prime_domain_service
+    .create_cache(org, sanitized_name, visibility)
+    .await
+    .map_err(|e| {
+      tracing::error!("failed to create cache: {e}");
+      ServerFnError::new("internal error")
+    })
+}

crates/site-app/src/hooks/login_hook.rs

@@ -64,10 +64,10 @@ impl LoginHook {
     touched_input_bindings(self.password_signal)
   }
 
-  pub fn email_error_hint(&self) -> impl Fn() -> Option<String> {
+  pub fn email_error_hint(&self) -> Signal<Option<String>> {
     let (email_signal, submit_touched_signal) =
       (self.email_signal, self.submit_touched_signal);
-    move || {
+    Signal::derive(move || {
       let email = email_signal.get();
       if !submit_touched_signal() {
         return None;
@@ -84,13 +84,13 @@ impl LoginHook {
           Some("That email address doesn't look right.".into())
         }
       }
-    }
+    })
   }
 
-  pub fn password_error_hint(&self) -> impl Fn() -> Option<String> {
+  pub fn password_error_hint(&self) -> Signal<Option<String>> {
     let (password_signal, submit_touched_signal) =
       (self.password_signal, self.submit_touched_signal);
-    move || {
+    Signal::derive(move || {
       let password = password_signal.get();
       if !submit_touched_signal() {
         return None;
@@ -99,42 +99,42 @@ impl LoginHook {
         return Some("Password required.".into());
       }
       None
-    }
+    })
   }
 
-  pub fn show_spinner(&self) -> impl Fn() -> bool {
+  pub fn show_spinner(&self) -> Signal<bool> {
     let (pending, value) = (self.action.pending(), self.action.value());
     // show if the action is loading or completed successfully
-    move || pending() || matches!(value.get(), Some(Ok(true)))
+    Signal::derive(move || pending() || matches!(value.get(), Some(Ok(true))))
   }
 
-  pub fn button_text(&self) -> impl Fn() -> &'static str {
+  pub fn button_text(&self) -> Signal<&'static str> {
     let (pending, value) = (self.action.pending(), self.action.value());
-    move || match (value.get(), pending()) {
+    Signal::derive(move || match (value.get(), pending()) {
       // if the action is loading at all
       (_, true) => "Loading...",
       // if it's completed successfully
       (Some(Ok(true)), _) => "Redirecting...",
       // any other state
       _ => "Log In",
-    }
+    })
   }
 
-  pub fn action_trigger(&self) -> impl Fn() {
+  pub fn action_trigger(&self) -> Callback<()> {
     let submit_touched_signal = self.submit_touched_signal;
     let email_error_hint = self.email_error_hint();
     let password_error_hint = self.password_error_hint();
     let action = self.action;
 
-    move || {
+    Callback::new(move |()| {
       submit_touched_signal.set(true);
 
       if email_error_hint().is_some() || password_error_hint().is_some() {
         return;
       }
 
       action.dispatch_local(());
-    }
+    })
   }
 
   pub fn create_redirect_effect(&self) -> Effect<LocalStorage> {