feat: add first-class parameters to major create commands (#449)

* feat(cloud): add first-class parameters to database create command

Implement comprehensive CLI parameter support for cloud database create command,
significantly improving user experience by eliminating the need for JSON data strings
for common operations.

Changes:
- Add 11 first-class CLI parameters: name, memory, dataset-size, protocol,
  replication, data-persistence, eviction-policy, redis-version, oss-cluster, port
- CLI flags override --data JSON values when both provided
- Maintain backwards compatibility with --data for advanced configurations
- Add comprehensive help text with practical examples
- Implement smart defaults (protocol: redis, eviction-policy: volatile-lru)
- Add parameter validation (memory XOR dataset-size requirement)

This establishes the pattern for systematically enhancing all create/update commands
with first-class parameters while preserving advanced --data fallback for complex
configurations.

* feat(cloud): add first-class parameters to subscription create command

Implement CLI parameter support for cloud subscription create command,
improving user experience for common subscription configuration options
while preserving --data for complex nested structures.

Changes:
- Add 7 first-class CLI parameters: name, dry-run, deployment-type,
  payment-method, payment-method-id, memory-storage, persistent-storage-encryption
- CLI flags override --data JSON values when both provided
- Maintain backwards compatibility with --data for required nested structures
  (cloudProviders and databases arrays)
- Add comprehensive help text with practical examples and usage notes
- Implement smart defaults (payment-method: credit-card, memory-storage: ram,
  persistent-storage-encryption: cloud-provider-managed-key)
- Add validation: payment-method-id required for credit-card payment method
- Validate presence of required nested structures (cloudProviders, databases)

Note: Subscription creation inherently requires complex nested structures for
cloud providers, regions, and database specifications. The --data parameter
remains required but first-class parameters simplify common configuration overrides.

* feat(enterprise): add first-class parameters to database create command

Implement comprehensive CLI parameter support for enterprise database create command,
providing a cleaner interface for common database configurations while maintaining
backwards compatibility with --data for advanced options.

Changes:
- Add 11 first-class CLI parameters: name, memory, port, replication, persistence,
  eviction-policy, sharding, shards-count, proxy-policy, crdb, redis-password
- CLI flags override --data JSON values when both provided
- Maintain backwards compatibility with --data for complex configurations
- Add comprehensive help text with practical examples and memory size references
- Implement parameter validation (shards-count requires sharding enabled)
- Add sensible boolean defaults (replication, sharding, crdb default to false)
- Map CLI parameter names to API field names (memory -> memory_size,
  redis-password -> authentication_redis_pass, crdb -> crdt)

This completes the pattern established for Cloud commands, systematically enhancing
all major create commands with first-class parameters across both Cloud and Enterprise.

Author: joshrotenberg

crates/redisctl/src/cli.rs

@@ -1478,10 +1478,65 @@ pub enum CloudSubscriptionCommands {
     },
 
     /// Create a new subscription
+    #[command(after_help = "EXAMPLES:
+    # Simple subscription - just name, provider, and region via --data
+    redisctl cloud subscription create --name prod-subscription \\
+      --data '{\"cloudProviders\":[{\"regions\":[{\"region\":\"us-east-1\"}]}],\"databases\":[{\"name\":\"db1\",\"memoryLimitInGb\":1}]}'
+
+    # With payment method
+    redisctl cloud subscription create --name dev-subscription \\
+      --payment-method marketplace \\
+      --data '{\"cloudProviders\":[{\"regions\":[{\"region\":\"us-west-2\"}]}],\"databases\":[{\"name\":\"db1\",\"memoryLimitInGb\":1}]}'
+
+    # With auto-tiering (RAM+Flash)
+    redisctl cloud subscription create --name large-subscription \\
+      --memory-storage ram-and-flash \\
+      --data '{\"cloudProviders\":[{\"provider\":\"AWS\",\"regions\":[{\"region\":\"eu-west-1\"}]}],\"databases\":[{\"name\":\"db1\",\"memoryLimitInGb\":10}]}'
+
+    # Complete configuration from file
+    redisctl cloud subscription create --data @subscription.json
+
+    # Dry run to preview deployment
+    redisctl cloud subscription create --dry-run --data @subscription.json
+
+NOTE: Subscription creation requires complex nested structures for cloud providers,
+      regions, and databases. Use --data for the required cloudProviders and databases
+      arrays. First-class parameters (--name, --payment-method, etc.) override values
+      in --data when both are provided.")]
     Create {
-        /// Subscription configuration as JSON string or @file.json
+        /// Subscription name
         #[arg(long)]
-        data: String,
+        name: Option<String>,
+
+        /// Dry run - create deployment plan without provisioning resources
+        #[arg(long)]
+        dry_run: bool,
+
+        /// Deployment type: single-region or active-active
+        #[arg(long, value_parser = ["single-region", "active-active"])]
+        deployment_type: Option<String>,
+
+        /// Payment method: credit-card or marketplace
+        #[arg(long, value_parser = ["credit-card", "marketplace"], default_value = "credit-card")]
+        payment_method: String,
+
+        /// Payment method ID (required if payment-method is credit-card)
+        #[arg(long)]
+        payment_method_id: Option<i32>,
+
+        /// Memory storage: ram or ram-and-flash (Auto Tiering)
+        #[arg(long, value_parser = ["ram", "ram-and-flash"], default_value = "ram")]
+        memory_storage: String,
+
+        /// Persistent storage encryption: cloud-provider-managed-key or customer-managed-key
+        #[arg(long, value_parser = ["cloud-provider-managed-key", "customer-managed-key"], default_value = "cloud-provider-managed-key")]
+        persistent_storage_encryption: String,
+
+        /// Advanced: Full subscription configuration as JSON string or @file.json
+        /// REQUIRED: Must include cloudProviders array with regions and databases array
+        #[arg(long)]
+        data: Option<String>,
+
         /// Async operation options
         #[command(flatten)]
         async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
@@ -1598,13 +1653,83 @@ pub enum CloudDatabaseCommands {
     },
 
     /// Create a new database
+    #[command(after_help = "EXAMPLES:
+    # Simple database - just name and size
+    redisctl cloud database create --subscription 123 --name mydb --memory 1
+
+    # Production database with high availability
+    redisctl cloud database create \\
+      --subscription 123 \\
+      --name prod-cache \\
+      --memory 10 \\
+      --replication \\
+      --data-persistence aof-every-1-second
+
+    # Advanced: Mix flags with JSON for rare options
+    redisctl cloud database create \\
+      --subscription 123 \\
+      --name mydb \\
+      --memory 5 \\
+      --data '{\"modules\": [{\"name\": \"RedisJSON\"}]}'
+")]
     Create {
         /// Subscription ID
         #[arg(long)]
         subscription: u32,
-        /// Database configuration as JSON string or @file.json
+
+        /// Database name (required unless using --data)
+        /// Limited to 40 characters: letters, digits, hyphens
+        /// Must start with letter, end with letter or digit
         #[arg(long)]
-        data: String,
+        name: Option<String>,
+
+        /// Memory limit in GB (e.g., 1, 5, 10, 50)
+        /// Alternative to --dataset-size
+        #[arg(long, conflicts_with = "dataset_size")]
+        memory: Option<f64>,
+
+        /// Dataset size in GB (alternative to --memory)
+        /// If replication enabled, total memory will be 2x this value
+        #[arg(long, conflicts_with = "memory")]
+        dataset_size: Option<f64>,
+
+        /// Database protocol
+        #[arg(long, value_parser = ["redis", "memcached"], default_value = "redis")]
+        protocol: String,
+
+        /// Enable replication for high availability
+        #[arg(long)]
+        replication: bool,
+
+        /// Data persistence policy
+        /// Options: none, aof-every-1-second, aof-every-write, snapshot-every-1-hour,
+        ///          snapshot-every-6-hours, snapshot-every-12-hours
+        #[arg(long)]
+        data_persistence: Option<String>,
+
+        /// Data eviction policy when memory limit reached
+        /// Options: volatile-lru, volatile-ttl, volatile-random, allkeys-lru,
+        ///          allkeys-lfu, allkeys-random, noeviction, volatile-lfu
+        #[arg(long, default_value = "volatile-lru")]
+        eviction_policy: String,
+
+        /// Redis version (e.g., "7.2", "7.0", "6.2")
+        #[arg(long)]
+        redis_version: Option<String>,
+
+        /// Enable OSS Cluster API support
+        #[arg(long)]
+        oss_cluster: bool,
+
+        /// TCP port (10000-19999, auto-assigned if not specified)
+        #[arg(long)]
+        port: Option<i32>,
+
+        /// Advanced: Full database configuration as JSON string or @file.json
+        /// CLI flags take precedence over values in JSON
+        #[arg(long)]
+        data: Option<String>,
+
         /// Async operation options
         #[command(flatten)]
         async_ops: crate::commands::cloud::async_utils::AsyncOperationArgs,
@@ -2097,10 +2222,84 @@ pub enum EnterpriseDatabaseCommands {
     },
 
     /// Create a new database
+    #[command(after_help = "EXAMPLES:
+    # Simple database - just name and size
+    redisctl enterprise database create --name mydb --memory 1073741824
+
+    # With replication for high availability
+    redisctl enterprise database create --name prod-db --memory 2147483648 --replication
+
+    # With persistence and eviction policy
+    redisctl enterprise database create --name cache-db --memory 536870912 \\
+      --persistence aof --eviction-policy volatile-lru
+
+    # With sharding for horizontal scaling
+    redisctl enterprise database create --name large-db --memory 10737418240 \\
+      --sharding --shards-count 4
+
+    # With specific port
+    redisctl enterprise database create --name service-db --memory 1073741824 --port 12000
+
+    # Complete configuration from file
+    redisctl enterprise database create --data @database.json
+
+    # Dry run to preview without creating
+    redisctl enterprise database create --name test-db --memory 1073741824 --dry-run
+
+NOTE: Memory size is in bytes. Common values:
+      - 1 GB = 1073741824 bytes
+      - 2 GB = 2147483648 bytes
+      - 5 GB = 5368709120 bytes
+      First-class parameters override values in --data when both are provided.")]
     Create {
-        /// Database configuration as JSON string or @file.json
+        /// Database name (required unless using --data)
         #[arg(long)]
-        data: String,
+        name: Option<String>,
+
+        /// Memory size in bytes (e.g., 1073741824 for 1GB)
+        #[arg(long)]
+        memory: Option<u64>,
+
+        /// TCP port (10000-19999, auto-assigned if not specified)
+        #[arg(long)]
+        port: Option<u16>,
+
+        /// Enable replication for high availability
+        #[arg(long)]
+        replication: bool,
+
+        /// Data persistence: aof, snapshot, or aof-and-snapshot
+        #[arg(long)]
+        persistence: Option<String>,
+
+        /// Data eviction policy when memory limit reached
+        #[arg(long)]
+        eviction_policy: Option<String>,
+
+        /// Enable sharding for horizontal scaling
+        #[arg(long)]
+        sharding: bool,
+
+        /// Number of shards (requires --sharding)
+        #[arg(long)]
+        shards_count: Option<u32>,
+
+        /// Proxy policy: single, all-master-shards, or all-nodes
+        #[arg(long)]
+        proxy_policy: Option<String>,
+
+        /// Enable CRDB (Active-Active)
+        #[arg(long)]
+        crdb: bool,
+
+        /// Redis password for authentication
+        #[arg(long)]
+        redis_password: Option<String>,
+
+        /// Advanced: Full database configuration as JSON string or @file.json
+        #[arg(long)]
+        data: Option<String>,
+
         /// Perform a dry run without creating the database
         #[arg(long)]
         dry_run: bool,

crates/redisctl/src/commands/cloud/database.rs

@@ -50,14 +50,34 @@ pub async fn handle_database_command(
         }
         CloudDatabaseCommands::Create {
             subscription,
+            name,
+            memory,
+            dataset_size,
+            protocol,
+            replication,
+            data_persistence,
+            eviction_policy,
+            redis_version,
+            oss_cluster,
+            port,
             data,
             async_ops,
         } => {
             super::database_impl::create_database(
                 conn_mgr,
                 profile_name,
                 *subscription,
-                data,
+                name.as_deref(),
+                *memory,
+                *dataset_size,
+                protocol,
+                *replication,
+                data_persistence.as_deref(),
+                eviction_policy,
+                redis_version.as_deref(),
+                *oss_cluster,
+                *port,
+                data.as_deref(),
                 async_ops,
                 output_format,
                 query,

crates/redisctl/src/commands/cloud/database_impl.rs

@@ -64,18 +64,98 @@ fn read_json_data(data: &str) -> CliResult<Value> {
     })
 }
 
-/// Create a new database
+/// Create a new database with first-class parameters
+#[allow(clippy::too_many_arguments)]
 pub async fn create_database(
     conn_mgr: &ConnectionManager,
     profile_name: Option<&str>,
     subscription_id: u32,
-    data: &str,
+    name: Option<&str>,
+    memory: Option<f64>,
+    dataset_size: Option<f64>,
+    protocol: &str,
+    replication: bool,
+    data_persistence: Option<&str>,
+    eviction_policy: &str,
+    redis_version: Option<&str>,
+    oss_cluster: bool,
+    port: Option<i32>,
+    data: Option<&str>,
     async_ops: &AsyncOperationArgs,
     output_format: OutputFormat,
     query: Option<&str>,
 ) -> CliResult<()> {
     let client = conn_mgr.create_cloud_client(profile_name).await?;
-    let request = read_json_data(data)?;
+
+    // Start with JSON from --data if provided, otherwise empty object
+    let mut request = if let Some(data_str) = data {
+        read_json_data(data_str)?
+    } else {
+        json!({})
+    };
+
+    // Ensure request is an object
+    if !request.is_object() {
+        return Err(RedisCtlError::InvalidInput {
+            message: "Database configuration must be a JSON object".to_string(),
+        });
+    }
+
+    let request_obj = request.as_object_mut().unwrap();
+
+    // CLI parameters override JSON values
+    // Required parameters (when not using pure --data mode)
+    if let Some(name_val) = name {
+        request_obj.insert("name".to_string(), json!(name_val));
+    } else if data.is_none() {
+        return Err(RedisCtlError::InvalidInput {
+            message: "--name is required (unless using --data with complete configuration)"
+                .to_string(),
+        });
+    }
+
+    // Memory configuration (must have either --memory, --dataset-size, or in --data)
+    if let Some(mem) = memory {
+        request_obj.insert("memoryLimitInGb".to_string(), json!(mem));
+    } else if let Some(dataset) = dataset_size {
+        request_obj.insert("datasetSizeInGb".to_string(), json!(dataset));
+    } else if data.is_none() {
+        return Err(RedisCtlError::InvalidInput {
+            message: "Either --memory or --dataset-size is required (unless using --data with complete configuration)".to_string(),
+        });
+    }
+
+    // Protocol (only set if non-default or not already in data)
+    if protocol != "redis" || !request_obj.contains_key("protocol") {
+        request_obj.insert("protocol".to_string(), json!(protocol));
+    }
+
+    // Replication (only set if true or not already in data)
+    if replication || !request_obj.contains_key("replication") {
+        request_obj.insert("replication".to_string(), json!(replication));
+    }
+
+    // Optional parameters - only set if provided
+    if let Some(persistence) = data_persistence {
+        request_obj.insert("dataPersistence".to_string(), json!(persistence));
+    }
+
+    // Eviction policy (only set if non-default or not already in data)
+    if eviction_policy != "volatile-lru" || !request_obj.contains_key("dataEvictionPolicy") {
+        request_obj.insert("dataEvictionPolicy".to_string(), json!(eviction_policy));
+    }
+
+    if let Some(version) = redis_version {
+        request_obj.insert("redisVersion".to_string(), json!(version));
+    }
+
+    if oss_cluster {
+        request_obj.insert("supportOSSClusterAPI".to_string(), json!(true));
+    }
+
+    if let Some(port_val) = port {
+        request_obj.insert("port".to_string(), json!(port_val));
+    }
 
     let response = client
         .post_raw(