From 21efa29fddbf23daa9080d458bdb06595c17b407 Mon Sep 17 00:00:00 2001 From: Joseph Montanaro Date: Fri, 20 Nov 2026 06:14:34 -0500 Subject: [PATCH] make aws credentials editable and refactor to hold name and id --- Cargo.lock | 6 +- Cargo.toml | 3 +- migrations/001_initial.sql | 3 +- src/assets.rs | 2 +- src/components/passphrase_input.rs | 8 ++ src/credentials/aws.rs | 7 +- src/db/aws.rs | 175 ++++++++++++----------- src/main.rs | 51 ++++++- src/screens/credentials.rs | 218 +++++++++++++++++------------ 9 files changed, 289 insertions(+), 184 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 87f3820..6deab47 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1447,6 +1447,7 @@ dependencies = [ "tempfile", "testresult", "thiserror 2.0.21", + "uuid", ] [[package]] @@ -1701,6 +1702,7 @@ dependencies = [ "libduckdb-sys", "num-integer", "strum 0.27.2", + "uuid", ] [[package]] @@ -7967,9 +7969,9 @@ checksum = "3a3b425286980a367278453f3b6d28cdcb134b574e5a35824a6ff5eebad50bb6" [[package]] name = "uuid" -version = "1.29.0" +version = "1.29.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a0e2d11620c50695fe12bbbfde96b3477fe606e7284c22d505c12ce51214514" +checksum = "3c14b15dffa2f4bd712103e857140aa04a4f2ff6e955c77d7eb8e53ee02a3b64" dependencies = [ "getrandom 0.4.3", "js-sys", diff --git a/Cargo.toml b/Cargo.toml index e6bb887..6914575 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,7 +12,7 @@ edition = "2024" argon2 = { version = "0.6.0", features = ["parallel", "zeroize"] } base64ct = "1.8.3" dirs = "7.0.0" -duckdb = { version = "1.20000.1", features = ["bundled"] } +duckdb = { version = "1.20000.1", features = ["bundled", "uuid"] } getrandom = { version = "0.4.3", features = ["sys_rng"] } gpui-kit = "0.7.0" gpui-omarchy = "0.2.1" @@ -22,6 +22,7 @@ serde = "1.0.229" serde_json = "1.0.154" testresult = "0.4.2" thiserror = "2.0.21" +uuid = { version = "1.29.3", features = ["v4", "serde"] } [dev-dependencies] gpui-kit = { version = "0.7.0", features = ["test-support"] } diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql index e6d4610..a0fc65a 100644 --- a/migrations/001_initial.sql +++ b/migrations/001_initial.sql @@ -5,7 +5,8 @@ INSERT INTO config VALUES ('{}'); CREATE TABLE aws_credentials ( - name VARCHAR PRIMARY KEY NOT NULL, + id UUID PRIMARY KEY NOT NULL, + name VARCHAR UNIQUE NOT NULL, created_at TIMESTAMP WITH TIME ZONE NOT NULL, updated_at TIMESTAMP WITH TIME ZONE NOT NULL, access_key_id VARCHAR UNIQUE NOT NULL, diff --git a/src/assets.rs b/src/assets.rs index db1cd8b..71843a7 100644 --- a/src/assets.rs +++ b/src/assets.rs @@ -5,7 +5,7 @@ use gpui_kit::{AssetSource, Result, SharedString}; // gpui-kit only embeds the icons its own components use, so anything else has to be listed here -icon_assets!(CreddyIcons, [Key, LogOut, ShieldCheck]); +icon_assets!(CreddyIcons, [Key, LogOut, Pencil, ShieldCheck]); /// Our extra icons, falling back to gpui-kit's defaults. pub struct CreddyAssets; diff --git a/src/components/passphrase_input.rs b/src/components/passphrase_input.rs index dd8c89c..2655f3e 100644 --- a/src/components/passphrase_input.rs +++ b/src/components/passphrase_input.rs @@ -30,6 +30,7 @@ pub struct PassphraseInputBuilder { id: SharedString, show: Option>, placeholder: SharedString, + value: SharedString, } impl PassphraseInputBuilder { @@ -44,6 +45,11 @@ impl PassphraseInputBuilder { self } + pub fn value(mut self, value: impl Into) -> Self { + self.value = value.into(); + self + } + pub fn build(self, window: &mut Window, cx: &mut App) -> Entity { let show = self.show.unwrap_or_else(|| cx.new(|_| false)); cx.new(|cx| { @@ -52,6 +58,7 @@ impl PassphraseInputBuilder { InputState::new(window, cx) .masked(masked) .placeholder(self.placeholder) + .default_value(self.value) }); // keep this field's masking in sync with the shared flag @@ -88,6 +95,7 @@ impl PassphraseInput { id: id.into(), show: None, placeholder: SharedString::default(), + value: SharedString::default(), } } diff --git a/src/credentials/aws.rs b/src/credentials/aws.rs index 5228044..a4383a7 100644 --- a/src/credentials/aws.rs +++ b/src/credentials/aws.rs @@ -1,14 +1,17 @@ use jiff::Timestamp; use serde::{Serialize, Deserialize}; +use uuid::Uuid; -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize)] pub struct AwsCredential { + pub id: Uuid, + pub name: String, pub access_key_id: String, pub secret_access_key: String, pub is_default: bool, } -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] pub struct AwsSessionCredential { pub version: usize, pub access_key_id: String, diff --git a/src/db/aws.rs b/src/db/aws.rs index 281daab..77b98db 100644 --- a/src/db/aws.rs +++ b/src/db/aws.rs @@ -1,4 +1,3 @@ -use std::collections::HashMap; use duckdb::{Error, params}; use crate::credentials::AwsCredential; use super::Db; @@ -7,27 +6,37 @@ impl Db { pub fn load_aws_credential(&self, name: &str) -> Result { let conn = self.connection.lock().unwrap(); conn.query_row( - "SELECT access_key_id, secret_access_key, is_default FROM aws_credentials WHERE name = ?", + "SELECT + id, + name, + access_key_id, + secret_access_key, + is_default + FROM aws_credentials + WHERE name = ?", params![name], |row| Ok(AwsCredential { - access_key_id: row.get(0)?, - secret_access_key: row.get(1)?, - is_default: row.get(2)?, + id: row.get(0)?, + name: row.get(1)?, + access_key_id: row.get(2)?, + secret_access_key: row.get(3)?, + is_default: row.get(4)?, }) ) } - pub fn save_aws_credential(&self, name: &str, cred: &AwsCredential) -> Result<(), Error> { + pub fn save_aws_credential(&self, cred: &AwsCredential) -> Result<(), Error> { let mut conn = self.connection.lock().unwrap(); let tx = conn.transaction()?; if cred.is_default { tx.execute( - "UPDATE aws_credentials SET is_default = false WHERE is_default AND name != ?", - params![name], + "UPDATE aws_credentials SET is_default = false WHERE is_default AND id != ?", + params![cred.id], )?; } tx.execute( "INSERT INTO aws_credentials ( + id, name, created_at, updated_at, @@ -35,52 +44,66 @@ impl Db { secret_access_key, is_default, ) - VALUES (?, now(), now(), ?, ?, ?) - ON CONFLICT (name) DO UPDATE + VALUES (?, ?, now(), now(), ?, ?, ?) + ON CONFLICT (id) DO UPDATE SET + name = EXCLUDED.name, updated_at = now(), access_key_id = EXCLUDED.access_key_id, secret_access_key = EXCLUDED.secret_access_key, is_default = EXCLUDED.is_default", - params![name, cred.access_key_id, cred.secret_access_key, cred.is_default], + params![cred.id, cred.name, cred.access_key_id, cred.secret_access_key, cred.is_default], )?; tx.commit() } - pub fn list_aws_credentials(&self) -> Result, Error> { + pub fn list_aws_credentials(&self) -> Result, Error> { let conn = self.connection.lock().unwrap(); - let mut stmt = conn.prepare("SELECT name, access_key_id, secret_access_key, is_default FROM aws_credentials")?; - let rows = stmt.query_map([], |row| { - let key: String = row.get(0)?; - let cred = AwsCredential{ - access_key_id: row.get(1)?, - secret_access_key: row.get(2)?, - is_default: row.get(3)?, - }; - Ok((key, cred)) - })?; - - rows.collect() + let mut stmt = conn.prepare( + "SELECT + id, + name, + access_key_id, + secret_access_key, + is_default + FROM aws_credentials + ORDER BY created_at" + )?; + stmt.query_map([], |row| { + Ok(AwsCredential{ + id: row.get(0)?, + name: row.get(1)?, + access_key_id: row.get(2)?, + secret_access_key: row.get(3)?, + is_default: row.get(4)?, + }) + })?.collect() } } #[cfg(test)] mod tests { use testresult::TestResult; + use uuid::Uuid; use crate::test_data::TestEnv; use super::*; + fn test_cred(name: &str, access_key_id: &str) -> AwsCredential { + AwsCredential { + id: Uuid::new_v4(), + name: name.into(), + access_key_id: access_key_id.into(), + secret_access_key: "EXAMPLESECRET".into(), + is_default: false, + } + } + #[test] fn test_save() -> TestResult { let env = TestEnv::new()?; let db = env.db()?; - let cred = AwsCredential { - access_key_id: "AKIAEXAMPLE".into(), - secret_access_key: "EXAMPLESECRET".into(), - is_default: false, - }; - db.save_aws_credential("test", &cred)?; + db.save_aws_credential(&test_cred("test", "AKIAEXAMPLE"))?; Ok(()) } @@ -89,17 +112,12 @@ mod tests { let env = TestEnv::new()?; let db = env.db()?; - let cred = AwsCredential { - access_key_id: "AKIAEXAMPLE".into(), - secret_access_key: "EXAMPLESECRET".into(), - is_default: false, - }; - db.save_aws_credential("test", &cred)?; + let cred = test_cred("test", "AKIAEXAMPLE"); + db.save_aws_credential(&cred)?; let loaded = db.load_aws_credential("test")?; - assert_eq!(loaded.access_key_id, cred.access_key_id); - assert_eq!(loaded.secret_access_key, cred.secret_access_key); + assert_eq!(loaded, cred); Ok(()) } @@ -108,23 +126,23 @@ mod tests { let env = TestEnv::new()?; let db = env.db()?; - let mut cred = AwsCredential { - access_key_id: "KEY1".into(), - secret_access_key: "EXAMPLESECRET".into(), - is_default: false, - }; - db.save_aws_credential("test", &cred)?; + let mut cred = test_cred("test", "KEY1"); + db.save_aws_credential(&cred)?; + cred.name = "renamed".into(); cred.access_key_id = "KEY2".into(); - db.save_aws_credential("test", &cred)?; + db.save_aws_credential(&cred)?; - let loaded = db.load_aws_credential("test")?; - assert_eq!(loaded.access_key_id, "KEY2"); + let creds = db.list_aws_credentials()?; + assert_eq!(creds.len(), 1); + assert_eq!(creds[0].id, cred.id); + assert_eq!(creds[0].name, "renamed"); + assert_eq!(creds[0].access_key_id, "KEY2"); // confirm that updated_at was modified, but not created_at let conn = db.connection.lock().unwrap(); let (created_at, updated_at): (i64, i64) = conn.query_row( - "SELECT created_at, updated_at FROM aws_credentials WHERE name = 'test'", + "SELECT created_at, updated_at FROM aws_credentials WHERE name = 'renamed'", [], |row| Ok((row.get(0)?, row.get(1)?)) )?; @@ -133,34 +151,31 @@ mod tests { Ok(()) } + #[test] + fn test_duplicate_name() -> TestResult { + let env = TestEnv::new()?; + let db = env.db()?; + + db.save_aws_credential(&test_cred("test", "KEY1"))?; + assert!(db.save_aws_credential(&test_cred("test", "KEY2")).is_err()); + Ok(()) + } + #[test] fn test_list() -> TestResult { let env = TestEnv::new()?; let db = env.db()?; - let cred1 = AwsCredential { - access_key_id: "KEY1".into(), - secret_access_key: "EXAMPLESECRET".into(), - is_default: false, - }; - db.save_aws_credential("test", &cred1)?; - - let cred2 = AwsCredential { - access_key_id: "KEY2".into(), - secret_access_key: "EXAMPLESECRET2".into(), - is_default: false, - }; - db.save_aws_credential("test2", &cred2)?; + // names are out of alphabetical order, since the list should be in order of creation + let cred1 = test_cred("test2", "KEY1"); + db.save_aws_credential(&cred1)?; + let cred2 = test_cred("test1", "KEY2"); + db.save_aws_credential(&cred2)?; let creds = db.list_aws_credentials()?; - - let loaded1 = creds.get("test").unwrap(); - assert_eq!(loaded1.access_key_id, cred1.access_key_id); - assert_eq!(loaded1.secret_access_key, cred1.secret_access_key); - - let loaded2 = creds.get("test2").unwrap(); - assert_eq!(loaded2.access_key_id, cred2.access_key_id); - assert_eq!(loaded2.secret_access_key, cred2.secret_access_key); + assert_eq!(creds.len(), 2); + assert_eq!(creds[0], cred1); + assert_eq!(creds[1], cred2); Ok(()) } @@ -170,28 +185,22 @@ mod tests { let env = TestEnv::new()?; let db = env.db()?; - let cred1 = AwsCredential { - access_key_id: "KEY1".into(), - secret_access_key: "EXAMPLESECRET".into(), - is_default: true, - }; - db.save_aws_credential("test", &cred1)?; + let mut cred1 = test_cred("test", "KEY1"); + cred1.is_default = true; + db.save_aws_credential(&cred1)?; - let cred2 = AwsCredential { - access_key_id: "KEY2".into(), - secret_access_key: "EXAMPLESECRET2".into(), - is_default: true, - }; - db.save_aws_credential("test2", &cred2)?; + let mut cred2 = test_cred("test2", "KEY2"); + cred2.is_default = true; + db.save_aws_credential(&cred2)?; assert!(!db.load_aws_credential("test")?.is_default); assert!(db.load_aws_credential("test2")?.is_default); // re-saving the current default shouldn't trip over its own row - db.save_aws_credential("test2", &cred2)?; + db.save_aws_credential(&cred2)?; assert!(db.load_aws_credential("test2")?.is_default); - db.save_aws_credential("test", &cred1)?; + db.save_aws_credential(&cred1)?; assert!(db.load_aws_credential("test")?.is_default); assert!(!db.load_aws_credential("test2")?.is_default); diff --git a/src/main.rs b/src/main.rs index 1288a40..4dd8d9c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -89,6 +89,7 @@ fn main() { mod tests { use gpui_kit::{AnyWindowHandle, TestAppContext}; use gpui_kit::test::TestWindowExt; + use uuid::Uuid; use super::*; use crate::credentials::AwsCredential; use crate::test_data::{TEST_PASSPHRASE, TestEnv}; @@ -259,11 +260,13 @@ mod tests { fn test_credentials_tabs(cx: &mut TestAppContext) { let env = TestEnv::new().unwrap(); let cred = AwsCredential { + id: Uuid::new_v4(), + name: "work".into(), access_key_id: "AKIAEXAMPLE".into(), secret_access_key: "EXAMPLESECRET".into(), is_default: false, }; - env.db().unwrap().save_aws_credential("work", &cred).unwrap(); + env.db().unwrap().save_aws_credential(&cred).unwrap(); let window = open_app(&env, cx); fill(window, "passphrase", TEST_PASSPHRASE, cx); click(window, "submit", cx); @@ -328,11 +331,13 @@ mod tests { fn test_add_aws_credential_duplicate_name(cx: &mut TestAppContext) { let env = TestEnv::new().unwrap(); let cred = AwsCredential { + id: Uuid::new_v4(), + name: "work".into(), access_key_id: "AKIAEXAMPLE".into(), secret_access_key: "EXAMPLESECRET".into(), is_default: false, }; - env.db().unwrap().save_aws_credential("work", &cred).unwrap(); + env.db().unwrap().save_aws_credential(&cred).unwrap(); let window = open_app(&env, cx); fill(window, "passphrase", TEST_PASSPHRASE, cx); click(window, "submit", cx); @@ -354,4 +359,46 @@ mod tests { }); assert_eq!(saved.access_key_id, "AKIAEXAMPLE"); } + + #[gpui_kit::test] + fn test_edit_aws_credential(cx: &mut TestAppContext) { + let env = TestEnv::new().unwrap(); + let cred = AwsCredential { + id: Uuid::new_v4(), + name: "work".into(), + access_key_id: "AKIAEXAMPLE".into(), + secret_access_key: "EXAMPLESECRET".into(), + is_default: false, + }; + env.db().unwrap().save_aws_credential(&cred).unwrap(); + let window = open_app(&env, cx); + fill(window, "passphrase", TEST_PASSPHRASE, cx); + click(window, "submit", cx); + click(window, "credentials", cx); + + click(window, "edit-work", cx); + act(window, cx, |window, cx| { + window.click("aws-name", cx); + window.press("ctrl-a", cx); + window.input("personal", cx); + }); + click(window, "aws-default", cx); + click(window, "aws-save", cx); + + assert_eq!(error_message(window, cx), None); + assert!(is_visible(window, "personal", cx)); + assert!(!is_visible(window, "work", cx)); + + let creds = cx.read(|cx| { + let AppSession::Unlocked(db) = cx.global::() else { panic!("locked") }; + db.list_aws_credentials().unwrap() + }); + assert_eq!(creds.len(), 1); + // fields that weren't touched keep the values the form was opened with + assert_eq!(creds[0].id, cred.id); + assert_eq!(creds[0].name, "personal"); + assert_eq!(creds[0].access_key_id, "AKIAEXAMPLE"); + assert_eq!(creds[0].secret_access_key, "EXAMPLESECRET"); + assert!(creds[0].is_default); + } } diff --git a/src/screens/credentials.rs b/src/screens/credentials.rs index 0a1bebb..ad769d3 100644 --- a/src/screens/credentials.rs +++ b/src/screens/credentials.rs @@ -12,16 +12,19 @@ use crate::components::{PassphraseInput, PassphraseInputEvent, colored_switch, e use crate::credentials::AwsCredential; use crate::session::AppSession; use super::Screen; +use uuid::Uuid; pub struct CredentialsScreen { tab: usize, - aws: Vec<(String, AwsCredential)>, + aws: Vec, aws_form: Option, error: Option, } struct AwsForm { + /// The id of the credential being edited, or None if this is a new one. + editing: Option, name: Entity, access_key_id: Entity, secret_access_key: Entity, @@ -43,18 +46,25 @@ impl CredentialsScreen { match db.list_aws_credentials() { Ok(creds) => { - self.aws = creds.into_iter().collect(); - self.aws.sort_by(|a, b| a.0.cmp(&b.0)); + self.aws = creds; self.error = None; }, Err(e) => self.error = Some(format!("Failed to load credentials: {e}").into()), } } - fn add_aws(&mut self, window: &mut Window, cx: &mut Context) { - let name = cx.new(|cx| InputState::new(window, cx)); - let access_key_id = cx.new(|cx| InputState::new(window, cx)); - let secret_access_key = PassphraseInput::builder("aws-secret").build(window, cx); + fn open_aws_form(&mut self, editing: Option, window: &mut Window, cx: &mut Context) { + let existing = self.aws + .iter() + .find(|cred| Some(cred.id) == editing) + .cloned() + .unwrap_or_default(); + + let name = cx.new(|cx| InputState::new(window, cx).default_value(existing.name)); + let access_key_id = cx.new(|cx| InputState::new(window, cx).default_value(existing.access_key_id)); + let secret_access_key = PassphraseInput::builder("aws-secret") + .value(existing.secret_access_key) + .build(window, cx); name.update(cx, |name, cx| name.focus(window, cx)); let mut _subscriptions = Vec::new(); @@ -72,10 +82,11 @@ impl CredentialsScreen { })); self.aws_form = Some(AwsForm { + editing, name, access_key_id, secret_access_key, - is_default: false, + is_default: existing.is_default, _subscriptions, }); self.error = None; @@ -84,21 +95,22 @@ impl CredentialsScreen { fn save_aws(&mut self, cx: &mut Context) { let Some(form) = &self.aws_form else { return }; - let name = form.name.read(cx).value().trim().to_string(); + let editing = form.editing; let cred = AwsCredential { + id: editing.unwrap_or_else(Uuid::new_v4), + name: form.name.read(cx).value().trim().to_string(), access_key_id: form.access_key_id.read(cx).value().trim().to_string(), secret_access_key: form.secret_access_key.read(cx).value(cx).trim().to_string(), is_default: form.is_default, }; - if name.is_empty() || cred.access_key_id.is_empty() || cred.secret_access_key.is_empty() { + if cred.name.is_empty() || cred.access_key_id.is_empty() || cred.secret_access_key.is_empty() { self.error = Some("All fields are required.".into()); cx.notify(); return; } - // saving is an upsert, so without this a new credential would silently replace the old one - if self.aws.iter().any(|(existing, _)| *existing == name) { - self.error = Some(format!("An AWS credential named \"{name}\" already exists.").into()); + if self.aws.iter().any(|existing| existing.name == cred.name && existing.id != cred.id) { + self.error = Some(format!("An AWS credential named \"{}\" already exists.", cred.name).into()); cx.notify(); return; } @@ -106,7 +118,7 @@ impl CredentialsScreen { let AppSession::Unlocked(db) = cx.global::() else { unreachable!("credentials screen is only shown while unlocked"); }; - match db.save_aws_credential(&name, &cred) { + match db.save_aws_credential(&cred) { Ok(()) => { self.aws_form = None; self.load_aws(cx); @@ -119,43 +131,67 @@ impl CredentialsScreen { fn render_aws_tab(&self, window: &mut Window, cx: &mut Context) -> Div { let t = cx.omarchy().clone(); - let list = if self.aws.is_empty() { - empty_state("AWS access keys", "You have no saved AWS credentials.", cx) - } else { - div() - .flex() - .flex_col() - .gap(rems(0.5)) - .children(self.aws.iter().map(|(name, cred)| { - div() - .id(SharedString::from(name)) - .test_support() - .flex() - .items_center() - .gap(rems(0.75)) - .p(rems(0.625)) - .border_1() - .border_color(if cred.is_default { t.accent } else { t.border }) - .child(div().font_weight(FontWeight::BOLD).child(name.clone())) - .children(cred.is_default.then(|| badge("Default", Status::Success, cx))) - .child( - div() - .ml_auto() - .font_family(t.mono_font.clone()) - .text_color(t.secondary) - .child(cred.access_key_id.clone()), - ) - })) - }; + let mut panel = div().flex().flex_col().gap(rems(0.5)); + if self.aws.is_empty() { + panel = panel.child(empty_state("AWS access keys", "You have no saved AWS credentials.", cx)); + } + for cred in &self.aws { + if let Some(form) = &self.aws_form + && form.editing == Some(cred.id) + { + panel = panel.child(self.render_aws_form(form, window, cx)); + continue; + } - let Some(form) = &self.aws_form else { - return div().flex().flex_col().gap(rems(1.)).child(list).child( + let id = cred.id; + panel = panel.child( + div() + .id(SharedString::from(&cred.name)) + .test_support() + .flex() + .items_center() + .gap(rems(0.75)) + .p(rems(0.625)) + .border_1() + .border_color(if cred.is_default { t.accent } else { t.border }) + .child(div().font_weight(FontWeight::BOLD).child(cred.name.clone())) + .children(cred.is_default.then(|| badge("Default", Status::Success, cx))) + .child( + div() + .ml_auto() + .font_family(t.mono_font.clone()) + .text_color(t.secondary) + .child(cred.access_key_id.clone()), + ) + .child( + icon_button( + SharedString::from(format!("edit-{}", cred.name)), + IconName::Pencil, + "Edit", + ButtonVariant::Outline, + cx, + ) + .on_click(cx.listener(move |this, _, window, cx| { + this.open_aws_form(Some(id), window, cx) + })), + ), + ); + } + + match &self.aws_form { + None => panel.child( button("aws-add", "Add", ButtonVariant::Primary, cx) .self_center() - .on_click(cx.listener(|this, _, window, cx| this.add_aws(window, cx))), - ); - }; + .mt(rems(0.5)) + .on_click(cx.listener(|this, _, window, cx| this.open_aws_form(None, window, cx))), + ), + Some(form) if form.editing.is_none() => panel.child(self.render_aws_form(form, window, cx)), + Some(_) => panel, + } + } + fn render_aws_form(&self, form: &AwsForm, window: &mut Window, cx: &mut Context) -> Div { + let t = cx.omarchy().clone(); let field = |label: &'static str, input: gpui_kit::AnyElement| { div() .flex() @@ -166,51 +202,49 @@ impl CredentialsScreen { }; let this = cx.entity(); - div().flex().flex_col().gap(rems(1.)).child(list).child( - div() - .flex() - .flex_col() - .gap(rems(1.)) - .p(rems(1.)) - .border_1() - .border_color(t.border) - .child(field("Name", input("aws-name", &form.name, window, cx).into_any_element())) - .child(field( - "Key ID", - input("aws-key-id", &form.access_key_id, window, cx) - .font_family(t.mono_font.clone()) - .into_any_element(), - )) - .child(field("Secret key", form.secret_access_key.clone().into_any_element())) - .child( - div() - .flex() - .items_center() - .gap(rems(0.5)) - .child( - colored_switch("aws-default", "Default AWS access key", form.is_default, t.success, cx) - .on_change(move |value, _, _, cx| this.update(cx, |this, cx| { - if let Some(form) = &mut this.aws_form { - form.is_default = value; - } - cx.notify(); - })), - ) - .child( - button("aws-cancel", "Cancel", ButtonVariant::Outline, cx) - .ml_auto() - .on_click(cx.listener(|this, _, _, cx| { - this.aws_form = None; - this.error = None; - cx.notify(); - })), - ) - .child( - button("aws-save", "Save", ButtonVariant::Primary, cx) - .on_click(cx.listener(|this, _, _, cx| this.save_aws(cx))), - ), - ), - ) + div() + .flex() + .flex_col() + .gap(rems(1.)) + .p(rems(1.)) + .border_1() + .border_color(t.border) + .child(field("Name", input("aws-name", &form.name, window, cx).into_any_element())) + .child(field( + "Key ID", + input("aws-key-id", &form.access_key_id, window, cx) + .font_family(t.mono_font.clone()) + .into_any_element(), + )) + .child(field("Secret key", form.secret_access_key.clone().into_any_element())) + .child( + div() + .flex() + .items_center() + .gap(rems(0.5)) + .child( + colored_switch("aws-default", "Default AWS access key", form.is_default, t.success, cx) + .on_change(move |value, _, _, cx| this.update(cx, |this, cx| { + if let Some(form) = &mut this.aws_form { + form.is_default = value; + } + cx.notify(); + })), + ) + .child( + button("aws-cancel", "Cancel", ButtonVariant::Outline, cx) + .ml_auto() + .on_click(cx.listener(|this, _, _, cx| { + this.aws_form = None; + this.error = None; + cx.notify(); + })), + ) + .child( + button("aws-save", "Save", ButtonVariant::Primary, cx) + .on_click(cx.listener(|this, _, _, cx| this.save_aws(cx))), + ), + ) } }