Incredibly messy persistence refactor

Stores account information in the app data folder, and account credentials in the OS keychain

1 files changed, 34 insertions, 30 deletions

diff --git a/app/src/lib.rs b/app/src/lib.rs
index 98ada19..91071fa 100644
--- a/app/src/lib.rs
+++ b/app/src/lib.rs
@@ -1,17 +1,19 @@
 mod oauth;
-use oauth::OAuthController;
+use oauth::{OAuthController, SigninResult};
 
+mod persistence;
+
+use persistence::{Account, PersistenceController};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_opener::OpenerExt;
 
 use tauri::{Manager, State, AppHandle};
-use url::Host;
-use uuid::Uuid;
 
 pub const OAUTH_CLIENT_NAME: &'static str = "foxfleet_test";
 
 struct AppState {
-    oauth_controller: OAuthController
+    oauth_controller: OAuthController,
+    persistence_controller: PersistenceController,
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -23,9 +25,11 @@ pub fn run() {
         .plugin(tauri_plugin_deep_link::init())
         .plugin(tauri_plugin_opener::init())
         .setup(|app| {
-            let oauth_controller = OAuthController::new(tauri::async_runtime::handle());
+            let persistence_controller = PersistenceController::new(tauri::async_runtime::handle());
+            let oauth_controller = OAuthController::new(tauri::async_runtime::handle(), persistence_controller.clone());
             app.manage(AppState {
-                oauth_controller: oauth_controller.clone() 
+                oauth_controller: oauth_controller.clone(),
+                persistence_controller,
             });
 
             #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
@@ -37,15 +41,19 @@ pub fn run() {
             });
             Ok(())
         })
-        .invoke_handler(tauri::generate_handler![start_account_auth, get_self])
+        .invoke_handler(tauri::generate_handler![start_account_auth, get_self, get_all_accounts])
         .run(tauri::generate_context!())
         .expect("Error starting")
 }
 
+#[tauri::command]
+async fn get_all_accounts(state: State<'_, AppState>) -> Result<Vec<Account>, String> {
+    Ok(state.persistence_controller.get_all_accounts().await)
+}
 
 #[tauri::command]
 async fn start_account_auth(app_handle: AppHandle, state: State<'_, AppState>, instance_domain: &str) -> Result<Vec<String>, ()> {
-    let add_result = state.oauth_controller.add_server(instance_domain).await;
+    let add_result = state.oauth_controller.start_authorization(instance_domain).await;
 
     let state_nonce = match add_result {
         Ok(result) => {
@@ -63,10 +71,10 @@ async fn start_account_auth(app_handle: AppHandle, state: State<'_, AppState>, i
         }
     };
 
-    let signin_result = state.oauth_controller.finish_signin(state_nonce).await;
+    let signin_result = state.oauth_controller.finish_authorization(state_nonce).await;
     match signin_result {
-        Ok((server_domain, username)) => {
-            println!("Signed in successfully");
+        Ok(SigninResult {server_domain, username}) => {
+            println!("Signed in successfully @{username}@{server_domain}");
             Ok(vec!(server_domain, username))
         }
         Err(err) => {
@@ -80,24 +88,20 @@ async fn start_account_auth(app_handle: AppHandle, state: State<'_, AppState>, i
 async fn get_self(state: State<'_, AppState>, server_domain: String, username: String) -> Result<String, String> {
     let client = reqwest::Client::builder().user_agent("Foxfleet v0.0.1").build().expect("Could not construct client");
 
-    let api_key = state.oauth_controller.get_api_token(server_domain, username).await;
-    match api_key {
-        Err(err) => {
-            println!("Error getting API token: {err}");
-            return Err(err)
-        }
-        Ok(api_key) => {
-            if let Ok(result) = client.get("https://social.tempest.dev/api/v1/accounts/verify_credentials")
-                .bearer_auth(api_key)
-                .send().await {
-                    if let Ok(result) = result.text().await {
-                        return Ok(result)
-                    } else {
-                        return Err("Error decoding response".to_string());
-                    }
-                } else {
-                    return Err("Error fetching account".to_string());
-                }
+    let account = state.persistence_controller.get_account(&username, &server_domain).await
+        .ok_or(format!("No account for @{username}@{server_domain}"))?;
+
+    let api_key = state.persistence_controller.get_credential(account.api_credential_id).await?;
+        
+    if let Ok(result) = client.get("https://social.tempest.dev/api/v1/accounts/verify_credentials")
+        .bearer_auth(api_key)
+        .send().await {
+            if let Ok(result) = result.text().await {
+                return Ok(result)
+            } else {
+                return Err("Error decoding response".to_string());
+            }
+        } else {
+            return Err("Error fetching account".to_string());
         }
-    }
 }