Merge pull request #13 from trouze/feat/auth

feat(src/cli/commands/init.rs): create init command and restructure a…

Author: trouze

src/api/discovery/mod.rs

@@ -65,7 +65,7 @@ pub fn require_environment_id(config: &Config) -> Result<u64> {
         .ok_or_else(|| {
             DbtpError::config(
                 "environment_id is required for Discovery API; \
-                 set via --environment-id, DBTP_ENVIRONMENT_ID, or `dbtp configure`",
+                 set via --environment-id or DBTP_ENVIRONMENT_ID",
             )
         })
 }

src/cli/commands/config_cmd.rs

@@ -0,0 +1,84 @@
+use clap::{Args, Subcommand};
+
+use crate::core::config;
+use crate::core::error::Result;
+
+#[derive(Debug, Args)]
+pub struct ConfigArgs {
+    #[command(subcommand)]
+    pub command: ConfigCommand,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum ConfigCommand {
+    /// Show all current settings
+    List,
+    /// Get the value of a single setting
+    Get {
+        /// Key name: host, token, account-id, project-id, output
+        key: String,
+    },
+    /// Set a configuration property
+    Set {
+        /// Key name: host, token, account-id, project-id, output
+        key: String,
+        /// Value to set
+        value: String,
+    },
+    /// Clear a configuration property
+    Unset {
+        /// Key name: host, token, account-id, project-id, output
+        key: String,
+    },
+}
+
+pub async fn exec(args: &ConfigArgs) -> Result<()> {
+    match &args.command {
+        ConfigCommand::List => {
+            let path = config::config_path()?;
+            if !path.exists() {
+                eprintln!("No config file found at {}", path.display());
+                eprintln!("Run `dbtp init` to set up credentials.");
+                return Ok(());
+            }
+
+            let keys = ["host", "token", "account-id", "project-id", "output"];
+            for key in &keys {
+                match config::get_property(key)? {
+                    Some(val) => {
+                        let display = if *key == "token" { mask_token(&val) } else { val };
+                        println!("{key} = {display}");
+                    }
+                    None => println!("{key} = (not set)"),
+                }
+            }
+        }
+
+        ConfigCommand::Get { key } => match config::get_property(key)? {
+            Some(val) => {
+                let display = if key == "token" { mask_token(&val) } else { val };
+                println!("{display}");
+            }
+            None => eprintln!("{key} is not set"),
+        },
+
+        ConfigCommand::Set { key, value } => {
+            config::set_property(key, value)?;
+            eprintln!("Set {key} = {}", if key == "token" { mask_token(value) } else { value.clone() });
+        }
+
+        ConfigCommand::Unset { key } => {
+            config::unset_property(key)?;
+            eprintln!("Unset {key}");
+        }
+    }
+
+    Ok(())
+}
+
+fn mask_token(token: &str) -> String {
+    if token.len() <= 8 {
+        return "***".to_string();
+    }
+    format!("{}...{}", &token[..4], &token[token.len() - 4..])
+}

src/cli/commands/configure.rs

@@ -56,7 +56,7 @@ pub async fn exec(
         .ok_or_else(|| {
             DbtpError::config(
                 "project_id is required for environment operations; \
-                 set via --project-id, DBTP_PROJECT_ID, or `dbtp configure`",
+                 set via --project-id, DBTP_PROJECT_ID, or `dbtp config set project-id`",
             )
         })?;
     let pid = resolve::resolve_project(client, raw_pid).await?;

src/cli/commands/environments.rs

@@ -0,0 +1,102 @@
+use clap::Args;
+
+use crate::api::admin::{accounts, projects};
+use crate::core::config::{self, ConfigFile, Connection, Defaults};
+use crate::core::error::Result;
+use crate::core::rest_client::RestClient;
+
+#[derive(Debug, Args)]
+pub struct InitArgs {
+    /// Disable interactive selection menus (use plain prompts only)
+    #[arg(long)]
+    pub non_interactive: bool,
+}
+
+pub async fn exec(args: &InitArgs) -> Result<()> {
+    eprintln!("Setting up dbtp credentials.\n");
+
+    let host = config::prompt("dbt Cloud host", "https://cloud.getdbt.com");
+    let token = config::prompt("API token", "");
+
+    let host = if !host.starts_with("https://") && !host.starts_with("http://") {
+        format!("https://{host}")
+    } else {
+        host
+    };
+
+    let account_id_str = config::prompt("Account ID", "");
+    let account_id = account_id_str
+        .parse::<u64>()
+        .map_err(|_| crate::core::error::DbtpError::config("Account ID must be a number"))?;
+
+    // Validate the connection
+    eprint!("\nValidating connection...");
+    match accounts::get_by_id(&host, &token, account_id).await {
+        Ok(_) => eprintln!(" ok"),
+        Err(e) => {
+            eprintln!(" failed\nWarning: could not verify credentials: {e}");
+            eprintln!("Saving anyway. Run `dbtp accounts show` to verify later.\n");
+        }
+    }
+
+    let project_id = if !args.non_interactive && config::is_interactive() && !token.is_empty() {
+        pick_project(&host, &token, account_id).await
+    } else {
+        None
+    };
+
+    let file = ConfigFile {
+        connection: Connection {
+            host: Some(host),
+            token: Some(token),
+            account_id: Some(account_id),
+        },
+        defaults: Defaults {
+            project_id,
+            output: "table".to_string(),
+        },
+    };
+
+    config::save_config(&file)?;
+
+    let path = config::config_path()?;
+    eprintln!("\nConfiguration saved to {}", path.display());
+    eprintln!("Run `dbtp config set project-id <id-or-name>` to set a default project.");
+
+    Ok(())
+}
+
+async fn pick_project(host: &str, token: &str, account_id: u64) -> Option<String> {
+    let client = match RestClient::new(host, token, Some(account_id)) {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("\nCould not build API client: {e}");
+            return None;
+        }
+    };
+
+    eprintln!("\nFetching projects...");
+    let list = match projects::list(&client, &[], None).await {
+        Ok(l) => l,
+        Err(e) => {
+            eprintln!("Could not fetch projects: {e}");
+            return None;
+        }
+    };
+
+    if list.is_empty() {
+        eprintln!("  No projects found.");
+        return None;
+    }
+
+    let items: Vec<(String, String)> = list
+        .iter()
+        .filter_map(|p| {
+            let name = p["name"].as_str()?.to_string();
+            let id = p["id"].as_u64()?.to_string();
+            Some((name, id))
+        })
+        .collect();
+
+    config::prompt_select("Select default project", &items)
+}

src/cli/commands/init.rs

@@ -121,7 +121,7 @@ pub async fn exec(args: &JobsArgs, client: &RestClient, config: &Config) -> Resu
                 .ok_or_else(|| {
                     DbtpError::config(
                         "project_id is required for job creation; \
-                         set via --project-id, DBTP_PROJECT_ID, or `dbtp configure`",
+                         set via --project-id, DBTP_PROJECT_ID, or `dbtp config set project-id`",
                     )
                 })?;
             let pid = resolve::resolve_project(client, raw_pid).await?;