refactor: Requests and API

Each request should now implement one of the http RequestWithBody
or RequestNoBody traits. This should transparently enable the use the
sync or async execution.

The API has also been refactored so that the http client is no longer a
part of the session object.

Author: LeanderBB

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "proton-api-rs"
 authors = ["Leander Beernaert <lbb-dev@pm.me>"]
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 license = "AGPL-3.0-only"
 description = "Unofficial implemention of proton REST API in rust"
@@ -16,23 +16,37 @@ categories = ["api-bindings"]
 [dependencies]
 go-srp = {path = "go-srp", version = "0.1.3"}
 thiserror = "1"
-serde = "1"
+serde = {version ="1", features=["derive"]}
 serde_repr = "0.1"
 serde_json = "1"
 base64 = "0.21"
 secrecy = "0.8"
 anyhow = "1.0"
 bytes = "1.4"
 log = "0.4"
+ureq = {version="2.6", optional=true}
+
+
+[features]
+default = []
+http-ureq = ["dep:ureq"]
+http-reqwest = ["dep:reqwest"]
+
 
 [dependencies.reqwest]
 version = "0.11"
 default-features = false
 features = ["json", "deflate", "stream", "cookies", "multipart", "rustls","rustls-tls", "socks"]
+optional = true
 
-[target.'cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))'.dependencies]
+[dev-dependencies]
+env_logger = "0.10"
 tokio = {version ="1", features = ["full"]}
 
-
 [[example]]
 name = "user_id"
+required-features = ["http-reqwest"]
+
+[[example]]
+name = "user_id_sync"
+required-features = ["http-ureq"]

examples/user_id.rs

@@ -1,4 +1,6 @@
-use proton_api_rs::{tokio, ClientBuilder, ClientLoginState};
+use proton_api_rs::{http, ping_async};
+use proton_api_rs::{Session, SessionType};
+pub use tokio;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
 
 #[tokio::main(worker_threads = 1)]
@@ -7,18 +9,24 @@ async fn main() {
     let user_password = std::env::var("PAPI_USER_PASSWORD").unwrap();
     let app_version = std::env::var("PAPI_APP_VERSION").unwrap();
 
-    let builder = ClientBuilder::new().app_version(&app_version);
+    let client = http::ClientBuilder::new()
+        .app_version(&app_version)
+        .build::<http::reqwest_client::ReqwestClient>()
+        .unwrap();
 
-    builder.ping().await.unwrap();
+    ping_async(&client).await.unwrap();
 
-    let client = match builder.login(&user_email, &user_password).await.unwrap() {
-        ClientLoginState::Authenticated(c) => c,
+    let session = match Session::login_async(&client, &user_email, &user_password)
+        .await
+        .unwrap()
+    {
+        SessionType::Authenticated(c) => c,
 
-        ClientLoginState::AwaitingTotp(mut t) => {
+        SessionType::AwaitingTotp(mut t) => {
             let mut stdout = tokio::io::stdout();
             let mut line_reader = tokio::io::BufReader::new(tokio::io::stdin()).lines();
-            let client = {
-                let mut client = None;
+            let session = {
+                let mut session = None;
                 for _ in 0..3 {
                     stdout
                         .write_all("Please Input TOTP:".as_bytes())
@@ -33,9 +41,9 @@ async fn main() {
 
                     let totp = line.trim_end_matches('\n');
 
-                    match t.submit_totp(totp).await {
+                    match t.submit_totp_async(&client, totp).await {
                         Ok(ac) => {
-                            client = Some(ac);
+                            session = Some(ac);
                             break;
                         }
                         Err((et, e)) => {
@@ -46,19 +54,19 @@ async fn main() {
                     }
                 }
 
-                client
+                session
             };
 
-            let Some(c) = client else {
+            let Some(c) = session else {
                 eprintln!("Failed to pass TOTP 2FA auth");
                 return;
             };
             c
         }
     };
 
-    let user = client.get_user().await.unwrap();
+    let user = session.get_user_async(&client).await.unwrap();
     println!("User ID is {}", user.id);
 
-    client.logout().await.unwrap();
+    session.logout_async(&client).await.unwrap();
 }

examples/user_id_sync.rs

@@ -0,0 +1,67 @@
+use proton_api_rs::clientv2::{ping, Session, SessionType};
+use proton_api_rs::http;
+use std::io::{BufRead, Write};
+
+fn main() {
+    env_logger::init();
+
+    let user_email = std::env::var("PAPI_USER_EMAIL").unwrap();
+    let user_password = std::env::var("PAPI_USER_PASSWORD").unwrap();
+    let app_version = std::env::var("PAPI_APP_VERSION").unwrap();
+
+    let client = http::ClientBuilder::new()
+        .app_version(&app_version)
+        .build::<http::ureq_client::UReqClient>()
+        .unwrap();
+
+    ping(&client).unwrap();
+
+    let session = match Session::login(&client, &user_email, &user_password).unwrap() {
+        SessionType::Authenticated(s) => s,
+        SessionType::AwaitingTotp(mut t) => {
+            let mut line_reader = std::io::BufReader::new(std::io::stdin());
+            let session = {
+                let mut session = None;
+                for _ in 0..3 {
+                    std::io::stdout()
+                        .write_all("Please Input TOTP:".as_bytes())
+                        .unwrap();
+                    std::io::stdout().flush().unwrap();
+
+                    let mut line = String::new();
+                    if let Err(e) = line_reader.read_line(&mut line) {
+                        eprintln!("Failed to read totp {e}");
+                        return;
+                    };
+
+                    let totp = line.trim_end_matches('\n');
+
+                    match t.submit_totp(&client, totp) {
+                        Ok(ac) => {
+                            session = Some(ac);
+                            break;
+                        }
+                        Err((et, e)) => {
+                            t = et;
+                            eprintln!("Failed to submit totp: {e}");
+                            continue;
+                        }
+                    }
+                }
+
+                session
+            };
+
+            let Some(c) = session else {
+                eprintln!("Failed to pass TOTP 2FA auth");
+                return;
+            };
+            c
+        }
+    };
+
+    let user = session.get_user(&client).unwrap();
+    println!("User ID is {}", user.id);
+
+    session.logout(&client).unwrap();
+}