Auth bindings (#58)

* basic framework. still has errors

* added functionality for main endpoints + some structuring

* formatting

* unused code

* mimicked CLI function with wait_for process

* added basic auth bindings

* made PR changes, added playground

* cargo fmt

* removed missed println

* misc tests fixes

* cargo fmt

* added windows support

* cargo fmt

* all OS use dunce

* restructured profile slightly; fixed mac bug

* profile changes, new main.rs

* fixed requested pr + canonicaliation bug

* fixed regressed bug in ui

* fixed regressed bugs

* fixed git error

* typo

* ran prettier

* clippy

* playground clippy

* ported profile loading fix

* profile change for real, url println and clippy

* PR changes

* auth bindings + semisynch flow

* fixed dropping task error

* prettier, eslint, clippy

* removed debugging modifications

* removed unused function that eslinter missed :(

* fixed settings not being released

---------

Co-authored-by: Wyatt <wyatt@modrinth.com>

theseus/src/api/auth.rs

@@ -5,6 +5,28 @@ use tokio::sync::oneshot;
 
 pub use inner::Credentials;
 
+/// Authenticate a user with Hydra - part 1
+/// This begins the authentication flow quasi-synchronously, returning a URL
+/// This can be used in conjunction with 'authenticate_await_complete_flow'
+/// to call authenticate and call the flow from the frontend.
+/// Visit the URL in a browser, then call and await 'authenticate_await_complete_flow'.
+pub async fn authenticate_begin_flow() -> crate::Result<url::Url> {
+    let st = State::get().await?.clone();
+    let url = st.auth_flow.write().await.begin_auth().await?;
+    Ok(url)
+}
+
+/// Authenticate a user with Hydra - part 2
+/// This completes the authentication flow quasi-synchronously, returning the credentials
+/// This can be used in conjunction with 'authenticate_begin_flow'
+/// to call authenticate and call the flow from the frontend.
+pub async fn authenticate_await_complete_flow() -> crate::Result<Credentials> {
+    let st = State::get().await?.clone();
+    let credentials =
+        st.auth_flow.write().await.await_auth_completion().await?;
+    Ok(credentials)
+}
+
 /// Authenticate a user with Hydra
 /// To run this, you need to first spawn this function as a task, then
 /// open a browser to the given URL and finally wait on the spawned future
@@ -36,6 +58,7 @@ pub async fn authenticate(
 }
 
 /// Refresh some credentials using Hydra, if needed
+/// This is the primary desired way to get credentials, as it will also refresh them.
 #[tracing::instrument]
 pub async fn refresh(
     user: uuid::Uuid,
@@ -98,3 +121,18 @@ pub async fn users() -> crate::Result<Box<[Credentials]>> {
     let users = state.users.read().await;
     users.iter().collect()
 }
+
+/// Get a specific user by user ID
+/// Prefer to use 'refresh' instead of this function
+#[tracing::instrument]
+pub async fn get_user(user: uuid::Uuid) -> crate::Result<Credentials> {
+    let state = State::get().await?;
+    let users = state.users.read().await;
+    let user = users.get(user)?.ok_or_else(|| {
+        crate::ErrorKind::OtherError(format!(
+            "Tried to get nonexistent user with ID {user}"
+        ))
+        .as_error()
+    })?;
+    Ok(user)
+}