Merge branch 'feature/sigit-login-auth' into development

setoelkahfi · setoelkahfi · commit 5b32e4dff9c9 · 2025-09-26T12:43:45.000+02:00
diff --git a/crates/cli/src/account/lib.rs b/crates/cli/src/account/lib.rs
@@ -224,25 +224,29 @@ pub async fn save_token(env: Environment, response: &Response) -> Result<()> {
     match headers.get("Authorization") {
         Some(token) => {
             debug!("{}", token.to_str()?);
-            match home::home_dir() {
-                Some(path) => {
-                    debug!("{}", path.to_str().unwrap());
-                    create_dir_all(path.join(env.smb_dir()))?;
-                    let mut file = OpenOptions::new()
-                        .create(true)
-                        .truncate(true)
-                        .write(true)
-                        .open([path.to_str().unwrap(), "/", &env.smb_dir(), "/token"].join(""))?;
-                    file.write_all(token.to_str()?.as_bytes())?;
-                    Ok(())
-                }
-                None => Err(anyhow!("Failed to get home directory.")),
-            }
+            store_token(env, token.to_str()?.to_string()).await
         }
         None => Err(anyhow!("Failed to get token. Probably a backend issue.")),
     }
 }
 
+pub async fn store_token(env: Environment, token: String) -> Result<()> {
+    match home::home_dir() {
+        Some(path) => {
+            debug!("{}", path.to_str().unwrap());
+            create_dir_all(path.join(env.smb_dir()))?;
+            let mut file = OpenOptions::new()
+                .create(true)
+                .truncate(true)
+                .write(true)
+                .open([path.to_str().unwrap(), "/", &env.smb_dir(), "/token"].join(""))?;
+            file.write_all(token.as_bytes())?;
+            Ok(())
+        }
+        None => Err(anyhow!("Failed to get home directory.")),
+    }
+}
+
 pub fn is_logged_in(env: Environment) -> bool {
     // Check if token file exists
     smb_token_file_path(env).is_some()
diff --git a/crates/cli/src/account/login/process.rs b/crates/cli/src/account/login/process.rs
@@ -1,7 +1,7 @@
 use {
     crate::{
         account::{
-            lib::{authorize_github, save_token},
+            lib::{authorize_github, store_token},
             signup::{do_signup, signup_with_email, SignupMethod},
         },
         cli::CommandResult,
@@ -14,12 +14,16 @@ use {
     log::debug,
     reqwest::{Client, StatusCode},
     smbcloud_model::{
-        account::{ErrorCode, GithubInfo, SmbAuthorization, User},
+        account::{
+            ErrorCode as AccountErrorCode, ErrorCode::EmailNotFound, ErrorCode::EmailUnverified,
+            ErrorCode::GithubNotLinked, ErrorCode::PasswordNotSet, GithubInfo, SmbAuthorization,
+            User,
+        },
         forgot::{Param, UserUpdatePassword},
-        login::{LoginArgs, LoginParams, UserParam},
+        login::{AccountStatus, LoginArgs, LoginParams, UserParam},
         signup::{GithubEmail, Provider, SignupGithubParams, SignupUserGithub},
     },
-    smbcloud_network::environment::Environment,
+    smbcloud_network::{environment::Environment, network::request_login},
     smbcloud_networking::{
         constants::{
             PATH_LINK_GITHUB_ACCOUNT, PATH_RESEND_CONFIRMATION, PATH_RESET_PASSWORD_INSTRUCTIONS,
@@ -91,16 +95,14 @@ async fn process_authorization(env: Environment, auth: SmbAuthorization) -> Resu
     if let Some(error_code) = auth.error_code {
         debug!("{}", error_code);
         match error_code {
-            ErrorCode::EmailNotFound => {
-                return create_new_account(env, auth.user_email, auth.user_info).await
-            }
-            ErrorCode::EmailUnverified => return send_email_verification(env, auth.user).await,
-            ErrorCode::PasswordNotSet => {
+            EmailNotFound => return create_new_account(env, auth.user_email, auth.user_info).await,
+            EmailUnverified => return send_email_verification(env, auth.user).await,
+            PasswordNotSet => {
                 // Only for email and password login
                 let error = anyhow!("Password not set.");
                 return Err(error);
             }
-            ErrorCode::GithubNotLinked => return connect_github_account(env, auth).await,
+            GithubNotLinked => return connect_github_account(env, auth).await,
         }
     }
 
@@ -299,7 +301,7 @@ async fn login_with_email(env: Environment) -> Result<CommandResult> {
     match check_email(env, &username).await {
         Ok(auth) => {
             // Only continue with password input if email is found and confirmed.
-            if let Some(_) = auth.error_code {
+            if auth.error_code.is_some() {
                 // Check if email is in the database, unconfirmed. Only presents password input if email is found and confirmed.
                 let spinner = Spinner::new(
                     spinners::Spinners::SimpleDotsScrolling,
@@ -339,43 +341,28 @@ async fn do_process_login(env: Environment, args: LoginArgs) -> Result<CommandRe
         },
     };
 
-    let response = match Client::new()
+    let builder = Client::new()
         .post(build_smb_login_url(env))
-        .json(&login_params)
-        .send()
-        .await
-    {
+        .json(&login_params);
+
+    let account_status = match request_login(builder).await {
         Ok(response) => response,
         Err(_) => return Err(anyhow!(fail_message("Check your internet connection."))),
     };
 
-    match response.status() {
-        StatusCode::OK => {
-            // Login successful
-            save_token(env, &response).await?;
+    match account_status {
+        AccountStatus::Ready { access_token } => {
+            store_token(env, access_token).await?;
             Ok(CommandResult {
                 spinner,
                 symbol: succeed_symbol(),
                 msg: succeed_message("You are logged in!"),
             })
         }
-        StatusCode::NOT_FOUND => {
-            // Account not found and we show signup option
-            Ok(CommandResult {
-                spinner,
-                symbol: fail_symbol(),
-                msg: fail_message("Account not found. Please signup!"),
-            })
-        }
-        StatusCode::UNPROCESSABLE_ENTITY => {
-            // Account found but email not verified / password not set
-            let result: SmbAuthorization = response.json().await?;
-            // println!("Result: {:#?}", &result);
-            after_checking_email_step(&env, spinner, result, None).await
+        AccountStatus::NotFound => Err(anyhow!(fail_message("Check your internet connection."))),
+        AccountStatus::Incomplete { status } => {
+            action_on_account_status(&env, spinner, status, None, None).await
         }
-        _ => Err(anyhow!(fail_message(
-            "Login failed. Check your username and password."
-        ))),
     }
 }
 
@@ -389,7 +376,7 @@ async fn after_checking_email_step(
         Some(error_code) => {
             debug!("{}", error_code);
             match error_code {
-                ErrorCode::EmailNotFound => {
+                EmailNotFound => {
                     spinner.stop_and_persist(
                         &succeed_symbol(),
                         succeed_message(
@@ -398,14 +385,14 @@ async fn after_checking_email_step(
                     );
                     signup_with_email(env.to_owned(), username).await
                 }
-                ErrorCode::EmailUnverified => {
+                EmailUnverified => {
                     spinner.stop_and_persist(
                         &succeed_symbol(),
                         succeed_message("Email not verified. Please verify your email."),
                     );
                     send_email_verification(*env, result.user).await
                 }
-                ErrorCode::PasswordNotSet => {
+                PasswordNotSet => {
                     spinner.stop_and_persist(
                         &succeed_symbol(),
                         succeed_message("Password not set. Please reset your password."),
@@ -422,6 +409,42 @@ async fn after_checking_email_step(
     }
 }
 
+async fn action_on_account_status(
+    env: &Environment,
+    mut spinner: Spinner,
+    error_code: AccountErrorCode,
+    username: Option<String>,
+    user: Option<User>,
+) -> Result<CommandResult> {
+    match error_code {
+        EmailNotFound => {
+            spinner.stop_and_persist(
+                &succeed_symbol(),
+                succeed_message("Account not found. Please continue with setting up your account."),
+            );
+            signup_with_email(env.to_owned(), username).await
+        }
+        EmailUnverified => {
+            spinner.stop_and_persist(
+                &succeed_symbol(),
+                succeed_message("Email not verified. Please verify your email."),
+            );
+            send_email_verification(*env, user).await
+        }
+        PasswordNotSet => {
+            spinner.stop_and_persist(
+                &succeed_symbol(),
+                succeed_message("Password not set. Please reset your password."),
+            );
+            send_reset_password(*env, user).await
+        }
+        _ => {
+            spinner.stop_and_persist(&fail_symbol(), fail_message("An error occurred."));
+            Err(anyhow!("Idk what happened."))
+        }
+    }
+}
+
 async fn send_reset_password(env: Environment, user: Option<User>) -> Result<CommandResult> {
     // Return early if user is null
     if let Some(user) = user {
diff --git a/crates/smbcloud-model/src/account.rs b/crates/smbcloud-model/src/account.rs
@@ -32,7 +32,8 @@ pub struct Data {
     created_at: String,
 }
 
-// This is smb authorization model.
+/// This is smbCloud authorization model
+/// that is currently tightly coupled with GitHub OAuth model.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct SmbAuthorization {
     pub message: String,
diff --git a/crates/smbcloud-model/src/login.rs b/crates/smbcloud-model/src/login.rs
@@ -1,5 +1,7 @@
-use crate::account::{Data, Status};
-use serde::{Deserialize, Serialize};
+use {
+    crate::account::{Data, ErrorCode, Status},
+    serde::{Deserialize, Serialize},
+};
 
 #[derive(Debug, Serialize)]
 pub struct LoginArgs {
@@ -24,6 +26,14 @@ pub struct LoginResult {
     pub data: Data,
 }
 
+/// Login endpoint result.
+#[derive(Debug, Serialize, Deserialize)]
+pub enum AccountStatus {
+    NotFound,
+    Ready { access_token: String },
+    Incomplete { status: ErrorCode },
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/smbcloud-model/src/runner.rs b/crates/smbcloud-model/src/runner.rs
@@ -46,16 +46,7 @@ impl Runner {
         if repo_path.join("package.json").exists()
             && (next_config_exists(repo_path) || astro_config_exists(repo_path))
         {
-            if next_config_exists(repo_path) {
-                return Ok(Runner::NodeJs);
-            } else if astro_config_exists(repo_path) {
-                return Ok(Runner::NodeJs);
-            } else {
-                return Err(ErrorResponse::Error {
-                    error_code: UnsupportedRunner,
-                    message: UnsupportedRunner.message(None).to_string(),
-                });
-            };
+            return Ok(Runner::NodeJs);
         }
 
         if repo_path.join("Gemfile").exists() {
@@ -64,10 +55,10 @@ impl Runner {
         if repo_path.join("Package.swift").exists() {
             return Ok(Runner::Swift);
         }
-        return Err(ErrorResponse::Error {
+        Err(ErrorResponse::Error {
             error_code: UnsupportedRunner,
             message: UnsupportedRunner.message(None).to_string(),
-        });
+        })
     }
 
     pub fn git_host(&self) -> String {
diff --git a/crates/smbcloud-network/src/environment.rs b/crates/smbcloud-network/src/environment.rs
@@ -1,6 +1,9 @@
-use wasm_bindgen::prelude::wasm_bindgen;
+use {
+    serde::{Deserialize, Serialize},
+    wasm_bindgen::prelude::wasm_bindgen,
+};
 
-#[derive(clap::ValueEnum, Clone, Copy)]
+#[derive(clap::ValueEnum, Clone, Copy, Serialize, Deserialize)]
 #[wasm_bindgen]
 pub enum Environment {
     Dev,
diff --git a/crates/smbcloud-network/src/network.rs b/crates/smbcloud-network/src/network.rs
@@ -1,13 +1,17 @@
 use {
     log::{debug, error},
-    reqwest::{RequestBuilder, Response},
+    reqwest::{RequestBuilder, Response, StatusCode},
     serde::de::DeserializeOwned,
-    smbcloud_model::error_codes::{ErrorCode, ErrorResponse},
+    smbcloud_model::{
+        account::SmbAuthorization,
+        error_codes::{ErrorCode, ErrorResponse},
+        login::AccountStatus,
+    },
 };
 
 //use std::time::Duration;
 #[cfg(debug_assertions)]
-const LOG_RESPONSE_BODY: bool = true; // You know what to do here.
+const LOG_RESPONSE_BODY: bool = false; // You know what to do here.
 #[cfg(not(debug_assertions))]
 const LOG_RESPONSE_BODY: bool = false;
 
@@ -81,6 +85,66 @@ pub async fn parse_error_response<T: DeserializeOwned>(
     Err(e)
 }
 
+pub async fn request_login(builder: RequestBuilder) -> Result<AccountStatus, ErrorResponse> {
+    let response = builder.send().await;
+    let response = match response {
+        Ok(response) => response,
+        Err(e) => {
+            error!("Failed to get response: {:?}", e);
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::NetworkError,
+                message: ErrorCode::NetworkError.message(None).to_string(),
+            });
+        }
+    };
+    match (response.status(), response.headers().get("Authorization")) {
+        (StatusCode::OK, Some(token)) => {
+            // Login successful, let's get the access token for real.
+            let access_token = match token.to_str() {
+                Ok(token) => token.to_string(),
+                Err(_) => {
+                    return Err(ErrorResponse::Error {
+                        error_code: ErrorCode::NetworkError,
+                        message: ErrorCode::NetworkError.message(None).to_string(),
+                    });
+                }
+            };
+            Ok(AccountStatus::Ready { access_token })
+        }
+        (StatusCode::NOT_FOUND, _) => {
+            // Account not found
+            Ok(AccountStatus::NotFound)
+        }
+        (StatusCode::UNPROCESSABLE_ENTITY, _) => {
+            // Account found but email not verified / password not set.
+            let result: SmbAuthorization = match response.json().await {
+                Ok(res) => res,
+                Err(_) => {
+                    return Err(ErrorResponse::Error {
+                        error_code: ErrorCode::NetworkError,
+                        message: ErrorCode::NetworkError.message(None).to_string(),
+                    });
+                }
+            };
+            // println!("Result: {:#?}", &result);
+            let error_code = match result.error_code {
+                Some(code) => code,
+                None => {
+                    return Err(ErrorResponse::Error {
+                        error_code: ErrorCode::NetworkError,
+                        message: ErrorCode::NetworkError.message(None).to_string(),
+                    });
+                }
+            };
+            Ok(AccountStatus::Incomplete { status: error_code })
+        }
+        _ => Err(ErrorResponse::Error {
+            error_code: ErrorCode::NetworkError,
+            message: ErrorCode::NetworkError.message(None).to_string(),
+        }),
+    }
+}
+
 pub async fn request<R: DeserializeOwned>(builder: RequestBuilder) -> Result<R, ErrorResponse> {
     // Check internet connection before making the request
     if !check_internet_connection().await {
diff --git a/crates/smbcloud-networking-account/src/login.rs b/crates/smbcloud-networking-account/src/login.rs

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,8 @@ pub struct Data {`
`32`	`32`	`created_at: String,`
`33`	`33`	`}`
`34`	`34`
`35`		`-// This is smb authorization model.`
	`35`	`+/// This is smbCloud authorization model`
	`36`	`+/// that is currently tightly coupled with GitHub OAuth model.`
`36`	`37`	`#[derive(Debug, Serialize, Deserialize)]`
`37`	`38`	`pub struct SmbAuthorization {`
`38`	`39`	`pub message: String,`