Merge branch 'fix/unify-errors' into development

paydii · paydii · commit ba61d591f93f · 2025-06-09T20:20:43.000+02:00
* fix/unify-errors:
  add gems docs
  use exect version
  update message
  remove config error
  fix default projectname
  fix input name
diff --git a/crates/cli/src/deploy/config.rs b/crates/cli/src/deploy/config.rs
@@ -4,14 +4,17 @@ use crate::{
 };
 use git2::{Cred, CredentialType, Error};
 use serde::{Deserialize, Serialize};
-use smbcloud_model::{account::User, project::Project};
+use smbcloud_model::{
+    account::User,
+    error_codes::{ErrorCode, ErrorResponse},
+    project::Project,
+};
 use smbcloud_networking::environment::Environment;
 use smbcloud_networking_project::crud_project_read::get_project;
 use spinners::Spinner;
 use std::{fs, path::Path};
-use thiserror::Error;
 
-pub(crate) async fn check_config(env: Environment) -> Result<Config, ConfigError> {
+pub(crate) async fn check_config(env: Environment) -> Result<Config, ErrorResponse> {
     let mut spinner: Spinner = Spinner::new(
         spinners::Spinners::SimpleDotsScrolling,
         succeed_message("Checking config"),
@@ -31,7 +34,10 @@ pub(crate) async fn check_config(env: Environment) -> Result<Config, ConfigError
     }
 
     // Parse toml file
-    let config_content = fs::read_to_string(config_path).map_err(|_| ConfigError::MissingConfig)?;
+    let config_content = fs::read_to_string(config_path).map_err(|_| ErrorResponse::Error {
+        error_code: ErrorCode::MissingConfig,
+        message: ErrorCode::MissingConfig.message(None).to_string(),
+    })?;
 
     let config: Config = match toml::from_str(&config_content) {
         Ok(value) => value,
@@ -49,15 +55,15 @@ pub(crate) async fn check_config(env: Environment) -> Result<Config, ConfigError
     Ok(config)
 }
 
-fn handle_config_error() -> Result<Config, ConfigError> {
+fn handle_config_error() -> Result<Config, ErrorResponse> {
     todo!()
 }
 
 pub(crate) async fn check_project(
     env: Environment,
     access_token: &str,
     id: i32,
-) -> Result<(), ConfigError> {
+) -> Result<(), ErrorResponse> {
     let mut spinner: Spinner = Spinner::new(
         spinners::Spinners::Hamburger,
         succeed_message("Validate project"),
@@ -69,7 +75,10 @@ pub(crate) async fn check_project(
         }
         Err(_) => {
             spinner.stop_and_persist(&fail_symbol(), succeed_message("Project is unsynched"));
-            Err(ConfigError::ProjectNotFound)
+            Err(ErrorResponse::Error {
+                error_code: ErrorCode::ProjectNotFound,
+                message: ErrorCode::ProjectNotFound.message(None).to_string(),
+            })
         }
     }
 }
@@ -100,19 +109,3 @@ impl Config {
         key_path_str
     }
 }
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum ConfigError {
-    #[error("Missing token. Make sure you are logged in.")]
-    MissingToken,
-    #[error("Missing config file. Please regenerate with 'smb init'.")]
-    MissingConfig,
-    #[error("Missing id in repository. Please regenerate with 'smb init'.")]
-    MissingId,
-    #[error("Could not find project in your list. Make sure you have access to the project.")]
-    ProjectNotFound,
-    #[error("Cancel operation.")]
-    Cancel,
-    #[error("Input error.")]
-    InputError,
-}
diff --git a/crates/cli/src/deploy/mod.rs b/crates/cli/src/deploy/mod.rs
@@ -169,7 +169,7 @@ pub async fn process_deploy(env: Environment) -> Result<CommandResult> {
             )
             .await;
             match result {
-                Ok(_) => println!("Deployment status successfully updated to Done."),
+                Ok(_) => println!("App is running {}", succeed_symbol()),
                 Err(update_err) => {
                     eprintln!("Error updating deployment status to Done: {}", update_err)
                 }
diff --git a/crates/cli/src/deploy/setup.rs b/crates/cli/src/deploy/setup.rs
@@ -1,17 +1,17 @@
-use crate::{
-    deploy::config::{Config, ConfigError},
-    ui::highlight,
-};
+use crate::{deploy::config::Config, ui::highlight};
 use dialoguer::{theme::ColorfulTheme, Confirm, Input, Select};
 use regex::Regex;
-use smbcloud_model::project::{Project, ProjectCreate};
+use smbcloud_model::{
+    error_codes::{ErrorCode, ErrorResponse},
+    project::{Project, ProjectCreate},
+};
 use smbcloud_networking::{environment::Environment, get_smb_token};
 use smbcloud_networking_project::{
     crud_project_create::create_project, crud_project_read::get_projects,
 };
 use std::{env, fs, path::Path};
 
-pub async fn setup_project(env: Environment) -> Result<Config, ConfigError> {
+pub async fn setup_project(env: Environment) -> Result<Config, ErrorResponse> {
     let path = env::current_dir().ok();
     let path_str = path
         .as_ref()
@@ -21,20 +21,36 @@ pub async fn setup_project(env: Environment) -> Result<Config, ConfigError> {
     let confirm = Confirm::with_theme(&ColorfulTheme::default())
         .with_prompt(format!("Setup project in {}? y/n", highlight(&path_str)))
         .interact()
-        .map_err(|_| ConfigError::InputError)?;
+        .map_err(|_| ErrorResponse::Error {
+            error_code: ErrorCode::InputError,
+            message: ErrorCode::InputError.message(None).to_string(),
+        })?;
 
     if !confirm {
-        return Err(ConfigError::Cancel);
+        return Err(ErrorResponse::Error {
+            error_code: ErrorCode::Cancel,
+            message: ErrorCode::Cancel.message(None).to_string(),
+        });
     }
 
     let access_token = match get_smb_token(env).await {
         Ok(token) => token,
-        Err(_) => return Err(ConfigError::MissingToken),
+        Err(_) => {
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::Unauthorized,
+                message: ErrorCode::Unauthorized.message(None).to_string(),
+            })
+        }
     };
 
     let projects = match get_projects(env, access_token).await {
         Ok(x) => x,
-        Err(_) => return Err(ConfigError::InputError),
+        Err(_) => {
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::InputError,
+                message: ErrorCode::InputError.message(None).to_string(),
+            })
+        }
     };
 
     let project: Project = if !projects.is_empty() {
@@ -56,12 +72,21 @@ pub async fn setup_project(env: Environment) -> Result<Config, ConfigError> {
     // Ensure .smb directory exists
     let smb_dir = Path::new(".smb");
     if !smb_dir.exists() {
-        fs::create_dir(smb_dir).map_err(|_| ConfigError::MissingConfig)?;
+        fs::create_dir(smb_dir).map_err(|_| ErrorResponse::Error {
+            error_code: ErrorCode::MissingConfig,
+            message: ErrorCode::MissingConfig.message(None).to_string(),
+        })?;
     }
 
     // Write config to .smb/config.toml
-    let config_toml = toml::to_string(&config).map_err(|_| ConfigError::MissingConfig)?;
-    fs::write(".smb/config.toml", config_toml).map_err(|_| ConfigError::MissingConfig)?;
+    let config_toml = toml::to_string(&config).map_err(|_| ErrorResponse::Error {
+        error_code: ErrorCode::MissingConfig,
+        message: ErrorCode::MissingConfig.message(None).to_string(),
+    })?;
+    fs::write(".smb/config.toml", config_toml).map_err(|_| ErrorResponse::Error {
+        error_code: ErrorCode::MissingConfig,
+        message: ErrorCode::MissingConfig.message(None).to_string(),
+    })?;
 
     Ok(config)
 }
@@ -70,11 +95,14 @@ async fn select_project(
     env: Environment,
     projects: Vec<Project>,
     path: &str,
-) -> Result<Project, ConfigError> {
+) -> Result<Project, ErrorResponse> {
     let confirm = Confirm::with_theme(&ColorfulTheme::default())
         .with_prompt("Use existing project? y/n")
         .interact()
-        .map_err(|_| ConfigError::InputError)?;
+        .map_err(|_| ErrorResponse::Error {
+            error_code: ErrorCode::InputError,
+            message: ErrorCode::InputError.message(None).to_string(),
+        })?;
 
     if !confirm {
         return create_new_project(env, path).await;
@@ -83,18 +111,24 @@ async fn select_project(
         .items(&projects)
         .default(0)
         .interact()
-        .map_err(|_| ConfigError::InputError)?;
+        .map_err(|_| ErrorResponse::Error {
+            error_code: ErrorCode::InputError,
+            message: ErrorCode::InputError.message(None).to_string(),
+        })?;
 
     let project = projects[selection].clone();
 
     Ok(project)
 }
 
-async fn create_new_project(env: Environment, path: &str) -> Result<Project, ConfigError> {
+async fn create_new_project(env: Environment, path: &str) -> Result<Project, ErrorResponse> {
     let default_name = Path::new(path)
         .file_name()
         .and_then(|os_str| os_str.to_str())
-        .unwrap_or("project");
+        .unwrap_or("project")
+        .to_lowercase()
+        .replace([' ', '-'], "")
+        .replace('-', "");
 
     let name = match Input::<String>::with_theme(&ColorfulTheme::default())
         .with_prompt("Project name")
@@ -103,7 +137,10 @@ async fn create_new_project(env: Environment, path: &str) -> Result<Project, Con
     {
         Ok(project_name) => project_name,
         Err(_) => {
-            return Err(ConfigError::InputError);
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::InputError,
+                message: ErrorCode::InputError.message(None).to_string(),
+            });
         }
     };
 
@@ -123,7 +160,10 @@ async fn create_new_project(env: Environment, path: &str) -> Result<Project, Con
     {
         Ok(repo) => repo,
         Err(_) => {
-            return Err(ConfigError::InputError);
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::InputError,
+                message: ErrorCode::InputError.message(None).to_string(),
+            });
         }
     };
 
@@ -133,13 +173,21 @@ async fn create_new_project(env: Environment, path: &str) -> Result<Project, Con
     {
         Ok(description) => description,
         Err(_) => {
-            return Err(ConfigError::InputError);
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::InputError,
+                message: ErrorCode::InputError.message(None).to_string(),
+            });
         }
     };
 
     let access_token = match get_smb_token(env).await {
         Ok(token) => token,
-        Err(_) => return Err(ConfigError::MissingToken),
+        Err(_) => {
+            return Err(ErrorResponse::Error {
+                error_code: ErrorCode::Unauthorized,
+                message: ErrorCode::Unauthorized.message(None).to_string(),
+            })
+        }
     };
 
     match create_project(
@@ -154,6 +202,6 @@ async fn create_new_project(env: Environment, path: &str) -> Result<Project, Con
     .await
     {
         Ok(project) => Ok(project),
-        Err(_) => Err(ConfigError::MissingConfig),
+        Err(e) => Err(e),
     }
 }
diff --git a/crates/cli/src/project/crud_create.rs b/crates/cli/src/project/crud_create.rs
@@ -27,12 +27,12 @@ pub async fn process_project_init(env: Environment) -> Result<CommandResult> {
         }
     };
     let repository = match Input::<String>::with_theme(&ColorfulTheme::default())
-        .with_prompt("Project name")
+        .with_prompt("Repository name")
         .interact()
     {
         Ok(project_name) => project_name,
         Err(_) => {
-            return Err(anyhow!(fail_message("Invalid project name.")));
+            return Err(anyhow!(fail_message("Invalid repository name.")));
         }
     };
     let description = match Input::<String>::with_theme(&ColorfulTheme::default())
@@ -91,6 +91,7 @@ description = "{description}"
 [project]
 id = 1
 name = "{repository_name}"
+repository = "{repository_name}"
 description = "{description}"
 created_at = "{now}"
 updated_at = "{now}" 
diff --git a/crates/smbcloud-model/src/error_codes.rs b/crates/smbcloud-model/src/error_codes.rs
@@ -24,12 +24,21 @@ impl Display for ErrorResponse {
 #[derive(Error, Serialize_repr, Deserialize_repr, Debug, EnumIter, IntoStaticStr)]
 #[repr(i32)]
 pub enum ErrorCode {
+    // Generic errors
     #[error("Unknown error.")]
     Unknown = 0,
     #[error("Parse error.")]
     ParseError = 1,
     #[error("Network error.")]
     NetworkError = 2,
+    #[error("Input error")]
+    InputError = 3,
+    #[error("Missing config file. Please regenerate with 'smb init'.")]
+    MissingConfig = 4,
+    // #[error("Missing id in repository. Please regenerate with 'smb init'.")]
+    // MissingId,
+    #[error("Cancel operation.")]
+    Cancel = 5,
     // Account
     #[error("Unauthorized access.")]
     Unauthorized = 100,
@@ -47,9 +56,13 @@ impl ErrorCode {
             100 => ErrorCode::Unauthorized,
             // Projects
             1000 => ErrorCode::ProjectNotFound,
-            // Fallback
+            // Generic errors
+            5 => ErrorCode::Cancel,
+            4 => ErrorCode::MissingConfig,
+            3 => ErrorCode::InputError,
             2 => ErrorCode::ParseError,
             1 => ErrorCode::NetworkError,
+            // Fallback
             _ => ErrorCode::Unknown,
         }
     }
@@ -63,6 +76,9 @@ impl ErrorCode {
             ErrorCode::ParseError => "Parse error.",
             ErrorCode::NetworkError => "Network error.",
             ErrorCode::Unauthorized => "Unauthorized access.",
+            ErrorCode::InputError => "Input error.",
+            ErrorCode::MissingConfig => "Missing config.",
+            ErrorCode::Cancel => "Cancelled operation.",
         }
     }
 
diff --git a/docs/gems.md b/docs/gems.md
@@ -0,0 +1,11 @@
+# Publish gem
+
+To publish the gem with native extension, there are multiple steps to do.
+
+## Build the gem
+
+- Make sure to publish the cli first since it will publish the `smbcloud-model` crate as well, which the gem depends on.
+- Update the Cargo dependency in `gems/model/ext/model/Cargo.toml`.
+- Build the gem: `bundle exec rake compile`.
+- Update the gem version in the `gem/model/lib/model/version.rb`. Just use the same version as the `smbcloud-model` crate.
+- Then publish the gem.
diff --git a/gems/model/Cargo.lock b/gems/model/Cargo.lock
diff --git a/gems/model/ext/model/Cargo.toml b/gems/model/ext/model/Cargo.toml
@@ -12,5 +12,5 @@ crate-type = ["cdylib"]
 magnus = { version = "0.7.1" }
 strum = "0.27"
 # Local crates
-smbcloud-model = "0.3"
+smbcloud-model = "0.3.17"
 #smbcloud-model = { path = "./../../../../crates/smbcloud-model"}

Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ pub async fn process_deploy(env: Environment) -> Result<CommandResult> {`
`169`	`169`	`)`
`170`	`170`	`.await;`
`171`	`171`	`match result {`
`172`		`- Ok(_) => println!("Deployment status successfully updated to Done."),`
	`172`	`+ Ok(_) => println!("App is running {}", succeed_symbol()),`
`173`	`173`	`Err(update_err) => {`
`174`	`174`	`eprintln!("Error updating deployment status to Done: {}", update_err)`
`175`	`175`	`}`