Refactor client facade and action routing

Author: puemos

src/app/action.rs

@@ -24,6 +24,17 @@ pub enum LoadMoreRequest {
     Notifications { cursor: String },
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ActionDomain {
+    App,
+    Accounts,
+    Channels,
+    Messages,
+    Notifications,
+    Audit,
+    Feeds,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Action {
     CreateInvite,
@@ -193,3 +204,85 @@ pub enum Action {
     },
     LoadOlder,
 }
+
+impl Action {
+    pub(crate) fn domain(&self) -> ActionDomain {
+        match self {
+            Self::OpenAccount => ActionDomain::App,
+            Self::CreateInvite
+            | Self::CreateInviteWithOptions { .. }
+            | Self::CompleteOnboarding { .. }
+            | Self::ListUsers
+            | Self::SetUsername { .. }
+            | Self::SetProfile { .. }
+            | Self::SaveAccountSettings { .. }
+            | Self::SetUserDisabled { .. }
+            | Self::SetUserRole { .. }
+            | Self::ListKeys
+            | Self::ListMyKeys
+            | Self::AddKey { .. }
+            | Self::CreateDeviceLinkToken { .. }
+            | Self::LabelKey { .. }
+            | Self::RevokeKey { .. }
+            | Self::ListInvites
+            | Self::RevokeInvite { .. } => ActionDomain::Accounts,
+            Self::CreateChannel { .. }
+            | Self::JoinChannel { .. }
+            | Self::LeaveChannel { .. }
+            | Self::ListChannels
+            | Self::RenameChannel { .. }
+            | Self::SetChannelTopic { .. }
+            | Self::SetChannelArchived { .. }
+            | Self::ListChannelMembers { .. }
+            | Self::AddChannelMember { .. }
+            | Self::RemoveChannelMember { .. } => ActionDomain::Channels,
+            Self::CreateThread { .. }
+            | Self::AddComment { .. }
+            | Self::OpenDm { .. }
+            | Self::SendDm { .. }
+            | Self::MarkThreadRead
+            | Self::MarkThreadUnread
+            | Self::MarkDmRead
+            | Self::MarkDmUnread
+            | Self::NextUnread
+            | Self::RenameThread { .. }
+            | Self::DeleteThread
+            | Self::SetThreadArchived { .. }
+            | Self::SetThreadPinned { .. }
+            | Self::SetThreadMuted { .. }
+            | Self::EditComment { .. }
+            | Self::DeleteComment { .. }
+            | Self::EditDm { .. }
+            | Self::DeleteDm { .. }
+            | Self::SetDmMuted { .. }
+            | Self::SetMessageSaved { .. }
+            | Self::React { .. }
+            | Self::Unreact { .. } => ActionDomain::Messages,
+            Self::ListMentions
+            | Self::ListNotifications
+            | Self::OpenSourceTarget { .. }
+            | Self::MarkNotificationRead { .. }
+            | Self::ArchiveNotifications
+            | Self::SetTerminalNotifications { .. }
+            | Self::ShowTerminalNotificationsStatus => ActionDomain::Notifications,
+            Self::ListAudit => ActionDomain::Audit,
+            Self::Search { .. }
+            | Self::OpenLabel { .. }
+            | Self::ListSaved
+            | Self::LoadMore { .. }
+            | Self::LoadOlder => ActionDomain::Feeds,
+        }
+    }
+
+    pub(crate) fn refreshes_after(&self) -> bool {
+        !matches!(
+            self,
+            Self::LoadMore { .. }
+                | Self::Search { .. }
+                | Self::OpenLabel { .. }
+                | Self::OpenAccount
+                | Self::ListSaved
+                | Self::ListNotifications
+        )
+    }
+}

src/app/lifecycle.rs

@@ -42,7 +42,10 @@ pub(crate) async fn fetch_refresh(
             inputs.history_limit,
         )
         .await?;
-    let terminal_notifications_enabled = client.terminal_notifications_enabled(&account.id).await?;
+    let terminal_notifications_enabled = client
+        .notifications()
+        .terminal_notifications_enabled()
+        .await?;
     Ok(RefreshFetched {
         account,
         snapshot,

src/app/mod.rs

@@ -4,6 +4,7 @@ mod input;
 mod render;
 mod state;
 mod theme;
+pub(crate) use action::ActionDomain;
 pub use action::{Action, LoadMoreRequest, SourceFocus, SourceTarget};
 
 use std::{

src/client/accounts.rs

@@ -0,0 +1,141 @@
+use crate::features::{
+    accounts::model::{Account, AccountSummary, InviteSummary, Role, SshKeySummary},
+    channels::model::ChannelMemberSummary,
+};
+
+use super::ClientSession;
+
+pub struct AccountsClient<'a> {
+    session: &'a ClientSession,
+}
+
+impl ClientSession {
+    pub fn accounts(&self) -> AccountsClient<'_> {
+        AccountsClient { session: self }
+    }
+}
+
+impl AccountsClient<'_> {
+    fn actor_id(&self) -> &str {
+        self.session.actor_id()
+    }
+
+    pub async fn create_invite(&self) -> anyhow::Result<String> {
+        self.session
+            .state()
+            .create_invite(self.actor_id().to_string())
+            .await
+    }
+
+    pub async fn create_invite_with_options(
+        &self,
+        role: Role,
+        ttl_hours: Option<i64>,
+    ) -> anyhow::Result<String> {
+        self.session
+            .state()
+            .create_invite_with_options(self.actor_id(), role, ttl_hours)
+            .await
+    }
+
+    pub async fn complete_onboarding(&self, username: &str) -> anyhow::Result<Account> {
+        self.session
+            .state()
+            .complete_onboarding(self.actor_id(), username)
+            .await
+    }
+
+    pub async fn list_accounts(&self) -> anyhow::Result<Vec<AccountSummary>> {
+        self.session.state().list_accounts(self.actor_id()).await
+    }
+
+    pub async fn rename_self(&self, username: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .rename_user(self.actor_id(), self.actor_id(), username)
+            .await
+    }
+
+    pub async fn set_self_display_name(&self, display_name: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .set_display_name(self.actor_id(), self.actor_id(), display_name)
+            .await
+    }
+
+    pub async fn set_user_disabled(&self, username: &str, disabled: bool) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .set_user_disabled(self.actor_id(), username, disabled)
+            .await
+    }
+
+    pub async fn set_user_role(&self, username: &str, role: Role) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .set_user_role(self.actor_id(), username, role)
+            .await
+    }
+
+    pub async fn list_ssh_keys(&self) -> anyhow::Result<Vec<SshKeySummary>> {
+        self.session.state().list_ssh_keys(self.actor_id()).await
+    }
+
+    pub async fn list_my_ssh_keys(&self) -> anyhow::Result<Vec<SshKeySummary>> {
+        self.session.state().list_my_ssh_keys(self.actor_id()).await
+    }
+
+    pub async fn create_device_link_token(&self, label: Option<&str>) -> anyhow::Result<String> {
+        self.session
+            .state()
+            .create_device_link_token(self.actor_id(), label)
+            .await
+    }
+
+    pub async fn add_ssh_key(
+        &self,
+        username: Option<&str>,
+        public_key: &str,
+        label: Option<&str>,
+    ) -> anyhow::Result<SshKeySummary> {
+        self.session
+            .state()
+            .add_ssh_key(self.actor_id(), username, public_key, label)
+            .await
+    }
+
+    pub async fn label_ssh_key(&self, key: &str, label: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .label_ssh_key(self.actor_id(), key, label)
+            .await
+    }
+
+    pub async fn revoke_ssh_key(&self, key: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .revoke_ssh_key(self.actor_id(), key)
+            .await
+    }
+
+    pub async fn list_invites(&self) -> anyhow::Result<Vec<InviteSummary>> {
+        self.session.state().list_invites(self.actor_id()).await
+    }
+
+    pub async fn revoke_invite(&self, invite_id: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .revoke_invite(self.actor_id(), invite_id)
+            .await
+    }
+
+    pub async fn list_channel_members(
+        &self,
+        slug: &str,
+    ) -> anyhow::Result<Vec<ChannelMemberSummary>> {
+        self.session
+            .state()
+            .list_channel_members(self.actor_id(), slug)
+            .await
+    }
+}

src/client/audit.rs

@@ -0,0 +1,22 @@
+use crate::features::audit::model::AuditEntry;
+
+use super::ClientSession;
+
+pub struct AuditClient<'a> {
+    session: &'a ClientSession,
+}
+
+impl ClientSession {
+    pub fn audit(&self) -> AuditClient<'_> {
+        AuditClient { session: self }
+    }
+}
+
+impl AuditClient<'_> {
+    pub async fn list_audit(&self, limit: i64) -> anyhow::Result<Vec<AuditEntry>> {
+        self.session
+            .state()
+            .list_audit(self.session.actor_id(), limit)
+            .await
+    }
+}

src/client/channels.rs

@@ -0,0 +1,95 @@
+use crate::features::channels::model::{ChannelDirectoryItem, ChannelMemberSummary};
+
+use super::ClientSession;
+
+pub struct ChannelsClient<'a> {
+    session: &'a ClientSession,
+}
+
+impl ClientSession {
+    pub fn channels(&self) -> ChannelsClient<'_> {
+        ChannelsClient { session: self }
+    }
+}
+
+impl ChannelsClient<'_> {
+    fn actor_id(&self) -> &str {
+        self.session.actor_id()
+    }
+
+    pub async fn create_channel(&self, name: String, private: bool) -> anyhow::Result<String> {
+        self.session
+            .state()
+            .create_channel(self.actor_id().to_string(), name, private)
+            .await
+    }
+
+    pub async fn join_channel(&self, slug: String) -> anyhow::Result<String> {
+        self.session
+            .state()
+            .join_channel(self.actor_id().to_string(), slug)
+            .await
+    }
+
+    pub async fn leave_channel(&self, slug: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .leave_channel(self.actor_id(), slug)
+            .await
+    }
+
+    pub async fn list_channels(
+        &self,
+        include_archived: bool,
+    ) -> anyhow::Result<Vec<ChannelDirectoryItem>> {
+        self.session
+            .state()
+            .list_channels(self.actor_id(), include_archived)
+            .await
+    }
+
+    pub async fn rename_channel(&self, slug: &str, name: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .rename_channel(self.actor_id(), slug, name)
+            .await
+    }
+
+    pub async fn set_channel_topic(&self, slug: &str, topic: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .set_channel_topic(self.actor_id(), slug, topic)
+            .await
+    }
+
+    pub async fn set_channel_archived(&self, slug: &str, archived: bool) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .set_channel_archived(self.actor_id(), slug, archived)
+            .await
+    }
+
+    pub async fn list_channel_members(
+        &self,
+        slug: &str,
+    ) -> anyhow::Result<Vec<ChannelMemberSummary>> {
+        self.session
+            .state()
+            .list_channel_members(self.actor_id(), slug)
+            .await
+    }
+
+    pub async fn add_channel_member(&self, slug: &str, username: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .add_channel_member(self.actor_id(), slug, username)
+            .await
+    }
+
+    pub async fn remove_channel_member(&self, slug: &str, username: &str) -> anyhow::Result<()> {
+        self.session
+            .state()
+            .remove_channel_member(self.actor_id(), slug, username)
+            .await
+    }
+}