edgee: credentials: handle profiles

Author: CLEMENTINATOR

crates/api-client/src/auth.rs

@@ -4,16 +4,29 @@ use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    connect_builder::{IsUnset, SetApiToken, State},
+    connect_builder::{IsUnset, SetApiToken, SetBaseurl, State},
     ConnectBuilder,
 };
 
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Default, Serialize, Clone)]
+pub struct Config {
+    #[serde(default)]
+    api_token: Option<String>,
+    #[serde(default)]
+    url: Option<String>,
+
+    #[serde(flatten)]
+    profiles: std::collections::HashMap<String, Credentials>,
+}
+
+#[derive(Debug, Deserialize, Default, Serialize, Clone)]
 pub struct Credentials {
-    pub api_token: Option<String>,
+    pub api_token: String,
+    #[serde(default)]
+    pub url: Option<String>,
 }
 
-impl Credentials {
+impl Config {
     pub fn path() -> Result<PathBuf> {
         let config_dir = dirs::config_dir()
             .ok_or_else(|| anyhow::anyhow!("Could not get user config directory"))?
@@ -66,23 +79,52 @@ impl Credentials {
             .context("Could not write credentials data")
     }
 
-    pub fn check_api_token(&self) -> Result<()> {
-        let Some(_api_token) = self.api_token.as_deref() else {
-            anyhow::bail!("Not logged in");
-        };
+    pub fn get(&self, profile: &Option<String>) -> Option<Credentials> {
+        match profile {
+            Some(profile) => self.profiles.get(profile).cloned(),
+            None => match (self.api_token.clone(), self.url.clone()) {
+                (Some(api_token), Some(url)) => Some(Credentials {
+                    api_token,
+                    url: Some(url),
+                }),
+                (Some(api_token), _) => Some(Credentials {
+                    api_token,
+                    url: Some("https://api.edgee.app".to_string()),
+                }),
+                _ => None,
+            },
+        }
+    }
 
-        // TODO: Check API token is valid using the API
+    pub fn set(&mut self, profile: Option<String>, creds: Credentials) {
+        match profile {
+            Some(profile) => {
+                self.profiles.insert(profile, creds);
+            }
+            None => {
+                self.api_token = Some(creds.api_token);
+                self.url = creds.url;
+            }
+        }
+    }
+}
 
+impl Credentials {
+    pub fn check_api_token(&self) -> Result<()> {
+        // TODO: Check API token is valid using the API
         Ok(())
     }
 }
 
-impl<'a, S: State> ConnectBuilder<'a, S> {
-    pub fn credentials(self, creds: &Credentials) -> ConnectBuilder<'a, SetApiToken<S>>
+impl<S: State> ConnectBuilder<S> {
+    pub fn credentials(self, creds: &Credentials) -> ConnectBuilder<SetApiToken<SetBaseurl<S>>>
     where
         S::ApiToken: IsUnset,
+        S::Baseurl: IsUnset,
     {
-        let api_token = creds.api_token.as_deref().unwrap();
-        self.api_token(api_token)
+        let api_token = creds.api_token.clone();
+        let url = creds.url.clone();
+        self.baseurl(url.unwrap_or("https://api.edgee.app".to_string()))
+            .api_token(api_token)
     }
 }

crates/api-client/src/lib.rs

@@ -18,13 +18,13 @@ progenitor::generate_api! {
     finish_fn = connect,
     on(String, into),
 )]
-pub fn connect(#[builder(default = PROD_BASEURL)] baseurl: &str, api_token: String) -> Client {
+pub fn connect(#[builder(default = PROD_BASEURL)] baseurl: String, api_token: String) -> Client {
     use reqwest::header::{self, HeaderMap};
 
     let mut default_headers = HeaderMap::new();
 
     // if EDGEE_API_URL env var is set, redefine baseurl
-    let baseurl = std::env::var("EDGEE_API_URL").unwrap_or(baseurl.to_string());
+    let baseurl = baseurl.to_string();
 
     // if EDGEE_API_TOKEN env var is set, redefine api_token
     let api_token = std::env::var("EDGEE_API_TOKEN").unwrap_or(api_token.to_string());

crates/cli/src/commands/auth/login.rs

@@ -2,40 +2,62 @@ use anyhow::Result;
 
 use edgee_api_client::ResultExt;
 
-setup_command! {}
+setup_command! {
+    #[arg(short, long, id = "PROFILE")]
+    profile: Option<String>,
 
-pub async fn run(_opts: Options) -> Result<()> {
+    #[arg(short, long, id = "URL")]
+    url: Option<String>,
+}
+
+pub async fn run(opts: Options) -> Result<()> {
     use inquire::{Confirm, Password, PasswordDisplayMode};
 
-    use edgee_api_client::auth::Credentials;
+    use edgee_api_client::auth::{Config, Credentials};
+
+    let url = match opts.url {
+        Some(url) => url,
+        None => std::env::var("EDGEE_API_URL").unwrap_or("https://api.edgee.app".to_string()),
+    };
 
-    let mut creds = Credentials::load()?;
+    let mut config = Config::load()?;
+    let creds = config.get(&opts.profile);
 
     let confirm_overwrite =
         Confirm::new("An API token is already configured, do you want to overwrite it?")
             .with_default(false);
-    if creds.api_token.is_some() && !confirm_overwrite.prompt()? {
+    if creds.is_some() && !confirm_overwrite.prompt()? {
         return Ok(());
     }
 
-    let confirm_auto_open_browser = Confirm::new("Your default browser will be opening to Edgee's API token creation page. Do you want to continue?")
+    let api_token = match std::env::var("EDGEE_API_TOKEN") {
+        Ok(token) => token,
+        Err(_) => {
+            let confirm_auto_open_browser = Confirm::new("Your default browser will be opening to Edgee's API token creation page. Do you want to continue?")
         .with_default(true);
 
-    if confirm_auto_open_browser.prompt()? {
-        open::that("https://www.edgee.cloud/~/me/settings/tokens")?;
-    }
+            if confirm_auto_open_browser.prompt()? {
+                open::that("https://www.edgee.cloud/~/me/settings/tokens")?;
+            }
 
-    let api_token = Password::new("Enter Edgee API token (press Ctrl+R to toggle input display):")
-        .with_help_message("You can create one at https://www.edgee.cloud/~/me/settings/tokens")
-        .with_display_mode(PasswordDisplayMode::Masked)
-        .with_display_toggle_enabled()
-        .without_confirmation()
-        .with_validator(inquire::required!("API token cannot be empty"))
-        .prompt()?;
-    creds.api_token.replace(api_token);
+            Password::new("Enter Edgee API token (press Ctrl+R to toggle input display):")
+                .with_help_message(
+                    "You can create one at https://www.edgee.cloud/~/me/settings/tokens",
+                )
+                .with_display_mode(PasswordDisplayMode::Masked)
+                .with_display_toggle_enabled()
+                .without_confirmation()
+                .with_validator(inquire::required!("API token cannot be empty"))
+                .prompt()?
+        }
+    };
 
-    let client = edgee_api_client::new().credentials(&creds).connect();
+    let creds = Credentials {
+        api_token,
+        url: Some(url),
+    };
 
+    let client = edgee_api_client::new().credentials(&creds).connect();
     let user = client
         .get_me()
         .send()
@@ -44,5 +66,6 @@ pub async fn run(_opts: Options) -> Result<()> {
         .into_inner();
     println!("Logged as {} ({})", user.name, user.email);
 
-    creds.save()
+    config.set(opts.profile, creds);
+    config.save()
 }

crates/cli/src/commands/auth/whoami.rs

@@ -1,11 +1,29 @@
 use edgee_api_client::ResultExt;
 
-setup_command! {}
+setup_command! {
+    #[arg(short, long, id = "PROFILE")]
+    profile: Option<String>,
+}
+
+pub async fn run(opts: Options) -> anyhow::Result<()> {
+    use edgee_api_client::auth::Config;
+
+    let config = Config::load()?;
 
-pub async fn run(_opts: Options) -> anyhow::Result<()> {
-    use edgee_api_client::auth::Credentials;
+    let creds = match config.get(&opts.profile) {
+        Some(creds) => creds,
+        None => {
+            match opts.profile {
+                None => {
+                    anyhow::bail!("No API token configured");
+                }
+                Some(profile) => {
+                    anyhow::bail!("No API token configured for profile '{}'", profile);
+                }
+            };
+        }
+    };
 
-    let creds = Credentials::load()?;
     creds.check_api_token()?;
 
     let client = edgee_api_client::new().credentials(&creds).connect();
@@ -19,6 +37,12 @@ pub async fn run(_opts: Options) -> anyhow::Result<()> {
     println!("  ID:    {}", user.id);
     println!("  Name:  {}", user.name);
     println!("  Email: {}", user.email);
+    if let Some(url) = &creds.url {
+        println!("  Url:   {}", url);
+    }
+    if let Some(profile) = opts.profile {
+        println!("  Profile: {}", profile);
+    }
 
     Ok(())
 }

crates/cli/src/commands/components/push.rs

@@ -12,16 +12,33 @@ pub struct Options {
     ///
     /// Defaults to the user "self" org
     pub organization: Option<String>,
+
+    #[arg(short, long, id = "PROFILE")]
+    profile: Option<String>,
 }
 
 pub async fn run(opts: Options) -> anyhow::Result<()> {
     use inquire::{Confirm, Editor, Select};
 
-    use edgee_api_client::{auth::Credentials, ErrorExt, ResultExt};
+    use edgee_api_client::{auth::Config, ErrorExt, ResultExt};
 
     use crate::components::manifest;
 
-    let creds = Credentials::load()?;
+    let config = Config::load()?;
+
+    let creds = match config.get(&opts.profile) {
+        Some(creds) => creds,
+        None => {
+            match opts.profile {
+                None => {
+                    anyhow::bail!("No API token configured");
+                }
+                Some(profile) => {
+                    anyhow::bail!("No API token configured for profile '{}'", profile);
+                }
+            };
+        }
+    };
     creds.check_api_token()?;
 
     let Some(manifest_path) = manifest::find_manifest_path() else {