TS bindings for Tauri commands HEAD main

4 files changed, 90 insertions, 61 deletions

diff --git a/app/Cargo.toml b/app/Cargo.toml
index e0def75..accf7aa 100644
--- a/app/Cargo.toml
+++ b/app/Cargo.toml
@@ -22,5 +22,6 @@ tauri-plugin-deep-link = "2"
 tauri-plugin-single-instance = {version = "2", features = ["deep-link"] }
 tokio = "1.43.0"
 toml = "0.8.20"
+ts-rs = "10.1"
 url = "2.5.4"
 uuid = {version="1.13.1", features= ["v4"] }
diff --git a/app/src/commands/accounts.rs b/app/src/commands/accounts.rs
new file mode 100644
index 0000000..ef9c203
--- /dev/null
+++ b/app/src/commands/accounts.rs
@@ -0,0 +1,84 @@
+use tauri::{State, AppHandle};
+use crate::oauth::SigninResult;
+use crate::persistence::Account as PersistedAccount;
+use crate::AppState;
+use tauri_plugin_opener::OpenerExt;
+use ts_rs::TS;
+use serde::Serialize;
+
+#[derive(TS, Serialize)]
+#[ts(export)]
+pub struct Account {
+    username: String,
+    domain: String,
+}
+
+impl From<PersistedAccount> for Account {
+    fn from(value: PersistedAccount) -> Self {
+        Self {
+            username: value.username,
+            domain: value.server_domain,
+        }
+    }
+}
+
+#[tauri::command]
+pub async fn get_all_accounts(state: State<'_, AppState>) -> Result<Vec<Account>, String> {
+    Ok(state.persistence_controller.get_all_accounts().await.into_iter().map(|a| a.into()).collect())
+}
+
+#[tauri::command]
+pub async fn start_account_auth(app_handle: AppHandle, state: State<'_, AppState>, instance_domain: &str) -> Result<Vec<String>, ()> {
+    let add_result = state.oauth_controller.start_authorization(instance_domain).await;
+
+    let state_nonce = match add_result {
+        Ok(result) => {
+            let opener = app_handle.opener();
+            if let Err(_) = opener.open_url(result.auth_url, None::<&str>) {
+                println!("Could not open authentication page");
+                return Err(())
+            }
+
+            result.auth_state
+        }
+        Err(err) => {
+            println!("Error adding server: {err}");
+            return Err(())
+        }
+    };
+
+    let signin_result = state.oauth_controller.finish_authorization(state_nonce).await;
+    match signin_result {
+        Ok(SigninResult {server_domain, username}) => {
+            println!("Signed in successfully @{username}@{server_domain}");
+            Ok(vec!(server_domain, username))
+        }
+        Err(err) => {
+            println!("Error completing signin: {err}");
+            Err(())
+        }
+    }
+}
+
+#[tauri::command]
+pub 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 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());
+        }
+}
+
diff --git a/app/src/commands/mod.rs b/app/src/commands/mod.rs
new file mode 100644
index 0000000..9bb4894
--- /dev/null
+++ b/app/src/commands/mod.rs
@@ -0,0 +1 @@
+pub mod accounts;
diff --git a/app/src/lib.rs b/app/src/lib.rs
index 91071fa..879a4f3 100644
--- a/app/src/lib.rs
+++ b/app/src/lib.rs
@@ -4,8 +4,10 @@ use oauth::{OAuthController, SigninResult};
 mod persistence;
 
 use persistence::{Account, PersistenceController};
+
+pub mod commands;
+
 use tauri_plugin_deep_link::DeepLinkExt;
-use tauri_plugin_opener::OpenerExt;
 
 use tauri::{Manager, State, AppHandle};
 
@@ -41,67 +43,8 @@ pub fn run() {
             });
             Ok(())
         })
-        .invoke_handler(tauri::generate_handler![start_account_auth, get_self, get_all_accounts])
+        .invoke_handler(tauri::generate_handler![commands::accounts::start_account_auth, commands::accounts::get_self, commands::accounts::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.start_authorization(instance_domain).await;
-
-    let state_nonce = match add_result {
-        Ok(result) => {
-            let opener = app_handle.opener();
-            if let Err(_) = opener.open_url(result.auth_url, None::<&str>) {
-                println!("Could not open authentication page");
-                return Err(())
-            }
-
-            result.auth_state
-        }
-        Err(err) => {
-            println!("Error adding server: {err}");
-            return Err(())
-        }
-    };
-
-    let signin_result = state.oauth_controller.finish_authorization(state_nonce).await;
-    match signin_result {
-        Ok(SigninResult {server_domain, username}) => {
-            println!("Signed in successfully @{username}@{server_domain}");
-            Ok(vec!(server_domain, username))
-        }
-        Err(err) => {
-            println!("Error completing signin: {err}");
-            Err(())
-        }
-    }
-}
-
-#[tauri::command]
-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 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());
-        }
-}