Merge pull request #200 from joshrotenberg/feat/user-provider-wait-flag

joshrotenberg · web-flow · commit d86dca4ec7b6 · 2025-09-07T08:36:14.000-07:00
feat(redisctl): add --wait flag support for Cloud user and provider account operations
diff --git a/crates/redisctl/src/cli.rs b/crates/redisctl/src/cli.rs
@@ -858,6 +858,9 @@ pub enum CloudProviderAccountCommands {
         /// For GCP, this should be the service account JSON file
         /// Use @filename to read from file
         file: String,
+        /// Async operation arguments
+        #[command(flatten)]
+        async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
     },
     /// Update a cloud provider account
     Update {
@@ -866,6 +869,9 @@ pub enum CloudProviderAccountCommands {
         /// JSON file containing updated cloud account configuration
         /// Use @filename to read from file
         file: String,
+        /// Async operation arguments
+        #[command(flatten)]
+        async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
     },
     /// Delete a cloud provider account
     Delete {
@@ -874,6 +880,9 @@ pub enum CloudProviderAccountCommands {
         /// Skip confirmation prompt
         #[arg(long)]
         force: bool,
+        /// Async operation arguments
+        #[command(flatten)]
+        async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
     },
 }
 
@@ -1321,6 +1330,9 @@ pub enum CloudUserCommands {
         /// Skip confirmation prompt
         #[arg(long)]
         force: bool,
+        /// Async operation arguments
+        #[command(flatten)]
+        async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
     },
 }
 
diff --git a/crates/redisctl/src/commands/cloud/cloud_account.rs b/crates/redisctl/src/commands/cloud/cloud_account.rs
@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
 use crate::cli::{CloudProviderAccountCommands, OutputFormat};
-use crate::commands::cloud::cloud_account_impl;
+use crate::commands::cloud::cloud_account_impl::{self, CloudAccountOperationParams};
 use crate::commands::cloud::utils::create_cloud_client_raw;
 use crate::connection::ConnectionManager;
 use crate::error::Result as CliResult;
@@ -23,15 +23,46 @@ pub async fn handle_cloud_account_command(
         CloudProviderAccountCommands::Get { account_id } => {
             cloud_account_impl::handle_get(&client, *account_id, output_format, query).await
         }
-        CloudProviderAccountCommands::Create { file } => {
-            cloud_account_impl::handle_create(&client, file, output_format, query).await
+        CloudProviderAccountCommands::Create { file, async_ops } => {
+            let params = CloudAccountOperationParams {
+                conn_mgr,
+                profile_name,
+                client: &client,
+                async_ops,
+                output_format,
+                query,
+            };
+            cloud_account_impl::handle_create(&params, file).await
         }
-        CloudProviderAccountCommands::Update { account_id, file } => {
-            cloud_account_impl::handle_update(&client, *account_id, file, output_format, query)
-                .await
+        CloudProviderAccountCommands::Update {
+            account_id,
+            file,
+            async_ops,
+        } => {
+            let params = CloudAccountOperationParams {
+                conn_mgr,
+                profile_name,
+                client: &client,
+                async_ops,
+                output_format,
+                query,
+            };
+            cloud_account_impl::handle_update(&params, *account_id, file).await
         }
-        CloudProviderAccountCommands::Delete { account_id, force } => {
-            cloud_account_impl::handle_delete(&client, *account_id, *force).await
+        CloudProviderAccountCommands::Delete {
+            account_id,
+            force,
+            async_ops,
+        } => {
+            let params = CloudAccountOperationParams {
+                conn_mgr,
+                profile_name,
+                client: &client,
+                async_ops,
+                output_format,
+                query,
+            };
+            cloud_account_impl::handle_delete(&params, *account_id, *force).await
         }
     }
 }
diff --git a/crates/redisctl/src/commands/cloud/cloud_account_impl.rs b/crates/redisctl/src/commands/cloud/cloud_account_impl.rs
@@ -1,16 +1,28 @@
 #![allow(dead_code)]
 
 use crate::cli::OutputFormat;
+use crate::commands::cloud::async_utils::{AsyncOperationArgs, handle_async_response};
 use crate::commands::cloud::utils::{
     confirm_action, handle_output, print_formatted_output, read_file_input,
 };
+use crate::connection::ConnectionManager;
 use crate::error::Result as CliResult;
 
 use anyhow::Context;
 use comfy_table::{Cell, Color, Table};
 use redis_cloud::CloudClient;
 use serde_json::{Value, json};
 
+/// Parameters for cloud account operations that support async operations
+pub struct CloudAccountOperationParams<'a> {
+    pub conn_mgr: &'a ConnectionManager,
+    pub profile_name: Option<&'a str>,
+    pub client: &'a CloudClient,
+    pub async_ops: &'a AsyncOperationArgs,
+    pub output_format: OutputFormat,
+    pub query: Option<&'a str>,
+}
+
 pub async fn handle_list(
     client: &CloudClient,
     output_format: OutputFormat,
@@ -107,12 +119,7 @@ pub async fn handle_get(
     Ok(())
 }
 
-pub async fn handle_create(
-    client: &CloudClient,
-    file: &str,
-    output_format: OutputFormat,
-    query: Option<&str>,
-) -> CliResult<()> {
+pub async fn handle_create(params: &CloudAccountOperationParams<'_>, file: &str) -> CliResult<()> {
     let content = read_file_input(file)?;
     let mut payload: Value =
         serde_json::from_str(&content).context("Failed to parse JSON from file")?;
@@ -175,38 +182,56 @@ pub async fn handle_create(
         }
     }
 
-    let result = client
+    let response = params
+        .client
         .post_raw("/cloud-accounts", payload)
         .await
         .context("Failed to create cloud account")?;
 
-    let data = handle_output(result, output_format, query)?;
-    print_formatted_output(data, output_format)?;
-    Ok(())
+    handle_async_response(
+        params.conn_mgr,
+        params.profile_name,
+        response,
+        params.async_ops,
+        params.output_format,
+        params.query,
+        "cloud account creation",
+    )
+    .await
 }
 
 pub async fn handle_update(
-    client: &CloudClient,
+    params: &CloudAccountOperationParams<'_>,
     account_id: i32,
     file: &str,
-    output_format: OutputFormat,
-    query: Option<&str>,
 ) -> CliResult<()> {
     let content = read_file_input(file)?;
     let payload: Value =
         serde_json::from_str(&content).context("Failed to parse JSON from file")?;
 
-    let result = client
+    let response = params
+        .client
         .put_raw(&format!("/cloud-accounts/{}", account_id), payload)
         .await
         .context("Failed to update cloud account")?;
 
-    let data = handle_output(result, output_format, query)?;
-    print_formatted_output(data, output_format)?;
-    Ok(())
+    handle_async_response(
+        params.conn_mgr,
+        params.profile_name,
+        response,
+        params.async_ops,
+        params.output_format,
+        params.query,
+        "cloud account update",
+    )
+    .await
 }
 
-pub async fn handle_delete(client: &CloudClient, account_id: i32, force: bool) -> CliResult<()> {
+pub async fn handle_delete(
+    params: &CloudAccountOperationParams<'_>,
+    account_id: i32,
+    force: bool,
+) -> CliResult<()> {
     if !force {
         let confirmed = confirm_action(&format!("delete cloud account {}", account_id))?;
         if !confirmed {
@@ -215,11 +240,20 @@ pub async fn handle_delete(client: &CloudClient, account_id: i32, force: bool) -
         }
     }
 
-    client
+    let response = params
+        .client
         .delete_raw(&format!("/cloud-accounts/{}", account_id))
         .await
         .context("Failed to delete cloud account")?;
 
-    println!("Cloud account {} deleted successfully", account_id);
-    Ok(())
+    handle_async_response(
+        params.conn_mgr,
+        params.profile_name,
+        response,
+        params.async_ops,
+        params.output_format,
+        params.query,
+        "cloud account deletion",
+    )
+    .await
 }
diff --git a/crates/redisctl/src/commands/cloud/user.rs b/crates/redisctl/src/commands/cloud/user.rs
@@ -2,6 +2,7 @@
 
 #![allow(dead_code)] // Used by binary target
 
+use super::async_utils::{AsyncOperationArgs, handle_async_response};
 use super::utils::DetailRow;
 use super::utils::*;
 use crate::cli::{CloudUserCommands, OutputFormat};
@@ -46,8 +47,21 @@ pub async fn handle_user_command(
             )
             .await
         }
-        CloudUserCommands::Delete { id, force } => {
-            delete_user(conn_mgr, profile_name, *id, *force, output_format, query).await
+        CloudUserCommands::Delete {
+            id,
+            force,
+            async_ops,
+        } => {
+            delete_user(
+                conn_mgr,
+                profile_name,
+                *id,
+                *force,
+                async_ops,
+                output_format,
+                query,
+            )
+            .await
         }
     }
 }
@@ -537,8 +551,9 @@ async fn delete_user(
     profile_name: Option<&str>,
     user_id: u32,
     force: bool,
-    _output_format: OutputFormat,
-    _query: Option<&str>,
+    async_ops: &AsyncOperationArgs,
+    output_format: OutputFormat,
+    query: Option<&str>,
 ) -> CliResult<()> {
     // Confirm deletion unless forced
     if !force {
@@ -557,11 +572,19 @@ async fn delete_user(
     let client = conn_mgr.create_cloud_client(profile_name).await?;
 
     // Send delete request
-    client
+    let response = client
         .delete_raw(&format!("/users/{}", user_id))
         .await
         .context("Failed to delete user")?;
 
-    println!("User {} deleted successfully", user_id);
-    Ok(())
+    handle_async_response(
+        conn_mgr,
+        profile_name,
+        response,
+        async_ops,
+        output_format,
+        query,
+        "user deletion",
+    )
+    .await
 }
