8676a71 · smbcloud/cli · siGit Code & Deploy

Cargo.lock

+1

@@ -2142,6 +2142,7 @@ version = "0.3.25"

2142 dependencies = [

2143 "serde-wasm-bindgen",

2144 "smbcloud-network",

2145 + "smbcloud-networking",

2146 "smbcloud-networking-account",

2147 "wasm-bindgen",

2148 "wasm-bindgen-futures",

crates/cli/src/account/forgot/mod.rs

+4 -2

@@ -7,7 +7,9 @@ use dialoguer::{theme::ColorfulTheme, Input, Password};

7 use reqwest::{Client, StatusCode};

8 use smbcloud_model::forgot::{Args, Email, Param, UserUpdatePassword};

9 use smbcloud_network::environment::Environment;

10 -use smbcloud_networking::{constants::PATH_USERS_PASSWORD, smb_base_url_builder};

10 +use smbcloud_networking::{

11 + constants::PATH_USERS_PASSWORD, smb_base_url_builder, smb_client::SmbClient,

12 +};

13 use smbcloud_utils::email_validation;

14 use spinners::Spinner;

15

@@ -115,7 +117,7 @@ async fn input_code(env: Environment) -> Result<CommandResult> {

117 }

118

119 fn build_smb_forgot_url(env: Environment) -> String {

118 - let mut url_builder = smb_base_url_builder(env);

120 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

121 url_builder.add_route(PATH_USERS_PASSWORD);

122 url_builder.build()

123 }

crates/cli/src/account/lib.rs

+2 -1

@@ -12,6 +12,7 @@ use {

12 GH_OAUTH_CLIENT_ID, GH_OAUTH_REDIRECT_HOST, GH_OAUTH_REDIRECT_PORT, PATH_AUTHORIZE,

13 },

14 smb_base_url_builder,

15 + smb_client::SmbClient,

16 },

17 spinners::Spinner,

18 std::{

@@ -192,7 +193,7 @@ pub async fn process_connect_github(env: Environment, code: String) -> Result<Sm

193 }

194

195 fn build_authorize_smb_url(env: Environment) -> String {

195 - let mut url_builder = smb_base_url_builder(env);

196 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

197 url_builder.add_route(PATH_AUTHORIZE);

198 url_builder.build()

199 }

crates/cli/src/account/login/process.rs

+7 -6

@@ -32,6 +32,7 @@ use {

32 PATH_USERS_PASSWORD,

33 },

34 smb_base_url_builder,

35 + smb_client::SmbClient,

36 },

37 smbcloud_networking_account::{check_email::check_email, login::login},

38 smbcloud_utils::email_validation,

@@ -301,7 +302,7 @@ async fn login_with_email(env: Environment) -> Result<CommandResult> {

302 }

303 };

304

304 - match check_email(env, &username).await {

305 + match check_email(env, SmbClient::Cli, &username).await {

306 Ok(auth) => {

307 // Only continue with password input if email is found and confirmed.

308 if auth.error_code.is_some() {

@@ -336,7 +337,7 @@ async fn do_process_login(env: Environment, args: LoginArgs) -> Result<CommandRe

337 spinners::Spinners::SimpleDotsScrolling,

338 succeed_message("Loading"),

339 );

339 - let account_status = match login(env, args.username, args.password).await {

340 + let account_status = match login(env, SmbClient::Cli, args.username, args.password).await {

341 Ok(response) => response,

342 Err(_) => return Err(anyhow!(fail_message("Check your internet connection."))),

343 };

@@ -554,25 +555,25 @@ async fn input_reset_password_token(env: Environment) -> Result<CommandResult> {

555 }

556

557 fn build_smb_resend_email_verification_url(env: Environment) -> String {

557 - let mut url_builder = smb_base_url_builder(env);

558 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

559 url_builder.add_route(PATH_RESEND_CONFIRMATION);

560 url_builder.build()

561 }

562

563 fn build_smb_resend_reset_password_instructions_url(env: Environment) -> String {

563 - let mut url_builder = smb_base_url_builder(env);

564 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

565 url_builder.add_route(PATH_RESET_PASSWORD_INSTRUCTIONS);

566 url_builder.build()

567 }

568

569 fn build_smb_reset_password_url(env: Environment) -> String {

569 - let mut url_builder = smb_base_url_builder(env);

570 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

571 url_builder.add_route(PATH_USERS_PASSWORD);

572 url_builder.build()

573 }

574

575 fn build_smb_connect_github_url(env: Environment) -> String {

575 - let mut url_builder = smb_base_url_builder(env);

576 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

577 url_builder.add_route(PATH_LINK_GITHUB_ACCOUNT);

578 url_builder.build()

579 }

crates/cli/src/account/logout/mod.rs

+2 -1

@@ -7,6 +7,7 @@ use {

7 anyhow::{anyhow, Result},

8 dialoguer::{theme::ColorfulTheme, Confirm},

9 smbcloud_network::environment::Environment,

10 + smbcloud_networking::smb_client::SmbClient,

11 smbcloud_networking_account::logout::logout,

12 spinners::Spinner,

13 std::fs,

@@ -67,7 +68,7 @@ pub async fn process_logout(env: Environment) -> Result<CommandResult> {

68

69 async fn do_process_logout(env: Environment) -> Result<()> {

70 let token = get_smb_token(env)?;

70 - match logout(env, token).await {

71 + match logout(env, SmbClient::Cli, token).await {

72 Ok(_) => Ok(()),

73 Err(e) => Err(anyhow!("{e}")),

74 }

crates/cli/src/account/me/mod.rs

+2 -1

@@ -7,6 +7,7 @@ use crate::{

7 use anyhow::Result;

8 use smbcloud_model::account::User;

9 use smbcloud_network::environment::Environment;

10 +use smbcloud_networking::smb_client::SmbClient;

11 use smbcloud_networking_account::me::me;

12 use spinners::Spinner;

13 use tabled::{Table, Tabled};

@@ -50,7 +51,7 @@ pub async fn process_me(env: Environment) -> Result<CommandResult> {

51 succeed_message("Loading"),

52 );

53 let token = get_smb_token(env)?;

53 - match me(env, &token).await {

54 + match me(env, SmbClient::Cli, &token).await {

55 Ok(user) => {

56 spinner.stop_and_persist(&succeed_symbol(), succeed_message("Loaded."));

57 show_user(&user);

crates/cli/src/account/signup/process.rs

+1 -1

@@ -171,7 +171,7 @@ pub async fn do_signup_email(

171 }

172

173 fn build_smb_signup_url(env: Environment) -> String {

174 - let mut url_builder = smb_base_url_builder(env);

174 + let mut url_builder = smb_base_url_builder(env, &SmbClient::Cli);

175 url_builder.add_route(PATH_USERS);

176 url_builder.build()

177 }

crates/cli/src/deploy/config.rs

+9 -1

@@ -9,6 +9,7 @@ use {

9 error_codes::{ErrorCode, ErrorResponse},

10 },

11 smbcloud_network::environment::Environment,

12 + smbcloud_networking::smb_client::SmbClient,

13 smbcloud_networking_project::crud_project_read::get_project,

14 smbcloud_utils::config::Config,

15 spinners::Spinner,

@@ -74,7 +75,14 @@ pub(crate) async fn check_project(

75 spinners::Spinners::Hamburger,

76 succeed_message("Validate project"),

77 );

77 - match get_project(env, access_token.to_string(), id.to_string()).await {

78 + match get_project(

79 + env,

80 + SmbClient::Cli,

81 + access_token.to_string(),

82 + id.to_string(),

83 + )

84 + .await

85 + {

86 Ok(_) => {

87 spinner.stop_and_persist(&succeed_symbol(), succeed_message("Valid project"));

88 Ok(())

crates/cli/src/deploy/process_deploy.rs

+12 -3

@@ -15,6 +15,7 @@ use {

15 git2::{PushOptions, RemoteCallbacks, Repository},

16 smbcloud_model::project::{DeploymentPayload, DeploymentStatus},

17 smbcloud_network::environment::Environment,

18 + smbcloud_networking::smb_client::SmbClient,

19 smbcloud_networking_account::me::me,

20 smbcloud_networking_project::{

21 crud_project_deployment_create::create_deployment, crud_project_deployment_update::update,

@@ -103,9 +104,15 @@ pub async fn process_deploy(env: Environment) -> Result<CommandResult> {

104 status: DeploymentStatus::Started,

105 };

106

106 - let created_deployment =

107 - create_deployment(env, &access_token, config.project.id, payload).await?;

108 - let user = me(env, &access_token).await?;

107 + let created_deployment = create_deployment(

108 + env,

109 + SmbClient::Cli,

110 + &access_token,

111 + config.project.id,

112 + payload,

113 + )

114 + .await?;

115 + let user = me(env, SmbClient::Cli, &access_token).await?;

116

117 let mut push_opts = PushOptions::new();

118 let mut callbacks = RemoteCallbacks::new();

@@ -158,6 +165,7 @@ pub async fn process_deploy(env: Environment) -> Result<CommandResult> {

165 let result = handle.block_on(async {

166 update(

167 update_env, // Env is Copy

168 + SmbClient::Cli,

169 access_token_for_update_cb.clone(),

170 project_id_for_update_cb,

171 deployment_id_for_update_cb,

@@ -193,6 +201,7 @@ pub async fn process_deploy(env: Environment) -> Result<CommandResult> {

201 };

202 let result = update(

203 env,

204 + SmbClient::Cli,

205 access_token.clone(),

206 config.project.id,

207 created_deployment.id,

crates/cli/src/deploy/setup_create_new_project.rs

+2

@@ -8,6 +8,7 @@ use {

8 runner::Runner,

9 },

10 smbcloud_network::environment::Environment,

11 + smbcloud_networking::smb_client::SmbClient,

12 smbcloud_networking_project::crud_project_create::create_project,

13 std::path::Path,

14 };

@@ -94,6 +95,7 @@ pub(crate) async fn create_new_project(

95

96 match create_project(

97 env,

98 + SmbClient::Cli,

99 access_token,

100 ProjectCreate {

101 name,

crates/cli/src/deploy/setup_project.rs

+2 -1

@@ -12,6 +12,7 @@ use {

12 project::Project,

13 },

14 smbcloud_network::environment::Environment,

15 + smbcloud_networking::smb_client::SmbClient,

16 smbcloud_networking_project::crud_project_read::get_projects,

17 smbcloud_utils::config::Config,

18 std::{env, fs, path::Path},

@@ -55,7 +56,7 @@ pub(crate) async fn setup_project(

56 },

57 };

58

58 - let projects = get_projects(env, access_token.to_string()).await?;

59 + let projects = get_projects(env, SmbClient::Cli, access_token.to_string()).await?;

60

61 let project: Project = if !projects.is_empty() {

62 select_project(env, projects, &path_str).await?

crates/cli/src/project/crud_create.rs

+2

@@ -13,6 +13,7 @@ use dialoguer::{theme::ColorfulTheme, Input};

13 use smbcloud_model::project::ProjectCreate;

14 use smbcloud_model::runner::Runner;

15 use smbcloud_network::environment::Environment;

16 +use smbcloud_networking::smb_client::SmbClient;

17 use smbcloud_networking_project::crud_project_create::create_project;

18 use spinners::Spinner;

19

@@ -74,6 +75,7 @@ pub async fn process_project_init(

75 let access_token = get_smb_token(env)?;

76 match create_project(

77 env,

78 + SmbClient::Cli,

79 access_token,

80 ProjectCreate {

81 name: project_name.clone(),

crates/cli/src/project/crud_delete.rs

+2 -1

@@ -7,6 +7,7 @@ use crate::{

7 use anyhow::{anyhow, Result};

8 use dialoguer::{theme::ColorfulTheme, Input};

9 use smbcloud_network::environment::Environment;

10 +use smbcloud_networking::smb_client::SmbClient;

11 use smbcloud_networking_project::crud_project_delete::delete_project;

12 use spinners::Spinner;

13

@@ -33,7 +34,7 @@ pub async fn process_project_delete(env: Environment, id: String) -> Result<Comm

34 });

35 }

36 let access_token = get_smb_token(env)?;

36 - match delete_project(env, access_token, id).await {

37 + match delete_project(env, SmbClient::Cli, access_token, id).await {

38 Ok(_) => Ok(CommandResult {

39 spinner,

40 symbol: succeed_symbol(),

crates/cli/src/project/crud_read.rs

+4 -3

@@ -9,6 +9,7 @@ use anyhow::{anyhow, Result};

9 use log::debug;

10 use smbcloud_model::project::{Config, Project};

11 use smbcloud_network::environment::Environment;

12 +use smbcloud_networking::smb_client::SmbClient;

13 use smbcloud_networking_project::crud_project_read::{get_project, get_projects};

14 use spinners::Spinner;

15 use tabled::{Table, Tabled};

@@ -49,7 +50,7 @@ pub async fn process_project_list(env: Environment) -> Result<CommandResult> {

50 succeed_message("Loading"),

51 );

52 let token = get_smb_token(env)?;

52 - match get_projects(env, token).await {

53 + match get_projects(env, SmbClient::Cli, token).await {

54 Ok(projects) => {

55 spinner.stop_and_persist(&succeed_symbol(), succeed_message("Loaded."));

56 let msg = if projects.is_empty() {

@@ -84,7 +85,7 @@ pub async fn process_project_show(env: Environment, id: String) -> Result<Comman

85 succeed_message("Loading"),

86 );

87 let access_token = get_smb_token(env)?;

87 - match get_project(env, access_token, id).await {

88 + match get_project(env, SmbClient::Cli, access_token, id).await {

89 Ok(project) => {

90 spinner.stop_and_persist(&succeed_symbol(), succeed_message("Loaded."));

91 let message = succeed_message(&format!("Showing project {}.", &project.name));

@@ -138,7 +139,7 @@ pub(crate) fn show_project_detail(project: &Project) {

139

140 pub(crate) async fn process_project_use(env: Environment, id: String) -> Result<CommandResult> {

141 let access_token = get_smb_token(env)?;

141 - let project = get_project(env, access_token, id).await?;

142 + let project = get_project(env, SmbClient::Cli, access_token, id).await?;

143

144 let config = Config {

145 current_project: Some(project),

crates/cli/src/project/crud_update.rs

+17 -2

@@ -3,6 +3,7 @@ use anyhow::{anyhow, Result};

3 use dialoguer::{console::Term, theme::ColorfulTheme, Input, Select};

4 use smbcloud_model::runner::Runner;

5 use smbcloud_network::environment::Environment;

6 +use smbcloud_networking::smb_client::SmbClient;

7 use smbcloud_networking_project::{

8 crud_project_read::get_project, crud_project_update::update_project,

9 };

@@ -22,7 +23,13 @@ pub async fn process_project_update(env: Environment, project_id: String) -> Res

23 }

24

25 let access_token = get_smb_token(env)?;

25 - let project = get_project(env, access_token.clone(), project_id.clone()).await?;

26 + let project = get_project(

27 + env,

28 + SmbClient::Cli,

29 + access_token.clone(),

30 + project_id.clone(),

31 + )

32 + .await?;

33

34 if let Some(project_description) = project.description {

35 println!("Description: {}", description(&project_description));

@@ -50,7 +57,15 @@ pub async fn process_project_update(env: Environment, project_id: String) -> Res

57 spinners::Spinners::SimpleDotsScrolling,

58 succeed_message("Loading"),

59 );

53 - update_project(env, access_token, project_id, &new_description, runner).await?;

60 + update_project(

61 + env,

62 + SmbClient::Cli,

63 + access_token,

64 + project_id,

65 + &new_description,

66 + runner,

67 + )

68 + .await?;

69 Ok(CommandResult {

70 spinner,

71 symbol: succeed_symbol(),

crates/cli/src/project/deployment.rs

+11 -3

@@ -7,6 +7,7 @@ use crate::{

7 use anyhow::Result;

8 use smbcloud_model::project::Deployment;

9 use smbcloud_network::environment::Environment;

10 +use smbcloud_networking::smb_client::SmbClient;

11 use smbcloud_networking_project::crud_project_deployment_read::{get_deployment, get_deployments};

12 use spinners::Spinner;

13 use tabled::{Table, Tabled};

@@ -27,14 +28,21 @@ pub(crate) async fn process_deployment(

28 if let Some(deployment_id) = id {

29 // Show detail for a specific deployment

30 let deployment_id: i32 = deployment_id.parse()?;

30 - let deployment =

31 - get_deployment(env, access_token, config.project.id, deployment_id).await?;

31 + let deployment = get_deployment(

32 + env,

33 + SmbClient::Cli,

34 + access_token,

35 + config.project.id,

36 + deployment_id,

37 + )

38 + .await?;

39 spinner.stop_and_persist(&succeed_symbol(), succeed_message("Loaded"));

40 show_deployment_detail(&deployment);

41 } else {

42 // List all deployments for the project

43 let access_token = get_smb_token(env)?;

37 - let deployments = get_deployments(env, access_token, config.project.id).await?;

44 + let deployments =

45 + get_deployments(env, SmbClient::Cli, access_token, config.project.id).await?;

46 spinner.stop_and_persist(&succeed_symbol(), succeed_message("Load all deployments"));

47 show_project_deployments(&deployments);

48 };

crates/cli/src/token/is_logged_in.rs

+3 -3

@@ -1,7 +1,7 @@

1 use {

2 crate::token::get_smb_token::get_smb_token, smbcloud_model::error_codes::ErrorResponse,

3 - smbcloud_network::environment::Environment, smbcloud_networking_account::me::me,

4 - tracing::debug,

3 + smbcloud_network::environment::Environment, smbcloud_networking::smb_client::SmbClient,

4 + smbcloud_networking_account::me::me, tracing::debug,

5 };

6

7 pub async fn is_logged_in(env: Environment) -> Result<bool, ErrorResponse> {

@@ -10,7 +10,7 @@ pub async fn is_logged_in(env: Environment) -> Result<bool, ErrorResponse> {

10 Ok(token) => token,

11 Err(_) => return Ok(false),

12 };

13 - match me(env, &access_token).await {

13 + match me(env, SmbClient::Cli, &access_token).await {

14 Ok(user) => {

15 debug!("Authorized as: {:?}", user.id);

16 Ok(true)

crates/smbcloud-networking-account-wasm/Cargo.toml

+1

@@ -23,6 +23,7 @@ crate-type = ["cdylib", "rlib"]

23 [dependencies]

24 serde-wasm-bindgen = "=0.6.5"

25 smbcloud-network = { workspace = true }

26 +smbcloud-networking = { workspace = true }

27 smbcloud-networking-account = { workspace = true }

28 wasm-bindgen = { workspace = true }

29 wasm-bindgen-futures = "0.4.50"

crates/smbcloud-networking-account-wasm/src/login.rs

+2 -1

@@ -1,4 +1,5 @@

1 use smbcloud_network::environment::Environment;

2 +use smbcloud_networking::smb_client::SmbClient;

3 use wasm_bindgen::JsValue;

4 use wasm_bindgen::prelude::wasm_bindgen;

5

@@ -8,7 +9,7 @@ pub async fn login(

9 username: String,

10 password: String,

11 ) -> Result<JsValue, JsValue> {

11 - match smbcloud_networking_account::login::login(env, username, password).await {

12 + match smbcloud_networking_account::login::login(env, SmbClient::Cli, username, password).await {

13 Ok(response) => Ok(serde_wasm_bindgen::to_value(&response)?),

14 Err(error) => Err(serde_wasm_bindgen::to_value(&error)?),

15 }

crates/smbcloud-networking-account-wasm/src/me.rs

+2 -1

@@ -1,10 +1,11 @@

1 use smbcloud_network::environment::Environment;

2 +use smbcloud_networking::smb_client::SmbClient;

3 use wasm_bindgen::JsValue;

4 use wasm_bindgen::prelude::wasm_bindgen;

5

6 #[wasm_bindgen]

7 pub async fn me(env: Environment, access_token: String) -> Result<JsValue, JsValue> {

7 - match smbcloud_networking_account::me::me(env, &access_token).await {

8 + match smbcloud_networking_account::me::me(env, SmbClient::Cli, &access_token).await {

9 Ok(response) => Ok(serde_wasm_bindgen::to_value(&response)?),

10 Err(error) => Err(serde_wasm_bindgen::to_value(&error)?),

11 }

crates/smbcloud-networking-account/src/remove.rs

+5 -4

@@ -2,23 +2,24 @@ use {

2 reqwest::Client,

3 smbcloud_model::error_codes::ErrorResponse,

4 smbcloud_network::{environment::Environment, network::request},

5 - smbcloud_networking::{constants::PATH_USERS, smb_base_url_builder},

5 + smbcloud_networking::{constants::PATH_USERS, smb_base_url_builder, smb_client::SmbClient},

6 };

7

8 pub async fn remove(

9 env: Environment,

10 + client: SmbClient,

11 user_agent: String,

12 access_token: &str,

13 ) -> Result<(), ErrorResponse> {

14 let builder = Client::new()

14 - .delete(build_smb_signup_url(env))

15 + .delete(build_smb_signup_url(env, client))

16 .header("Authorization", access_token)

17 .header("User-agent", user_agent);

18 request(builder).await

19 }

20

20 -fn build_smb_signup_url(env: Environment) -> String {

21 - let mut url_builder = smb_base_url_builder(env);

21 +fn build_smb_signup_url(env: Environment, client: SmbClient) -> String {

22 + let mut url_builder = smb_base_url_builder(env, &client);

23 url_builder.add_route(PATH_USERS);

24 url_builder.build()

25 }

add SmbClient enum