make aws credentials editable and refactor to hold name and id

This commit is contained in:
jfmonty2 committed 2026-11-20 06:14:34 -05:00
1 parent dbcf72fa38
commit 21efa29fdd
9 files changed
+289 -184

No files matched your search

Generated
+4 -2
View File
@@ -1447,6 +1447,7 @@ dependencies = [
"tempfile", "tempfile",
"testresult", "testresult",
"thiserror 2.0.21", "thiserror 2.0.21",
"uuid",
] ]
[[package]] [[package]]
@@ -1701,6 +1702,7 @@ dependencies = [
"libduckdb-sys", "libduckdb-sys",
"num-integer", "num-integer",
"strum 0.27.2", "strum 0.27.2",
"uuid",
] ]
[[package]] [[package]]
@@ -7967,9 +7969,9 @@ checksum = "3a3b425286980a367278453f3b6d28cdcb134b574e5a35824a6ff5eebad50bb6"
[[package]] [[package]]
name = "uuid" name = "uuid"
version = "1.29.0" version = "1.29.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4a0e2d11620c50695fe12bbbfde96b3477fe606e7284c22d505c12ce51214514" checksum = "3c14b15dffa2f4bd712103e857140aa04a4f2ff6e955c77d7eb8e53ee02a3b64"
dependencies = [ dependencies = [
"getrandom 0.4.3", "getrandom 0.4.3",
"js-sys", "js-sys",
+2 -1
View File
@@ -12,7 +12,7 @@ edition = "2024"
argon2 = { version = "0.6.0", features = ["parallel", "zeroize"] } argon2 = { version = "0.6.0", features = ["parallel", "zeroize"] }
base64ct = "1.8.3" base64ct = "1.8.3"
dirs = "7.0.0" 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"] } getrandom = { version = "0.4.3", features = ["sys_rng"] }
gpui-kit = "0.7.0" gpui-kit = "0.7.0"
gpui-omarchy = "0.2.1" gpui-omarchy = "0.2.1"
@@ -22,6 +22,7 @@ serde = "1.0.229"
serde_json = "1.0.154" serde_json = "1.0.154"
testresult = "0.4.2" testresult = "0.4.2"
thiserror = "2.0.21" thiserror = "2.0.21"
uuid = { version = "1.29.3", features = ["v4", "serde"] }
[dev-dependencies] [dev-dependencies]
gpui-kit = { version = "0.7.0", features = ["test-support"] } gpui-kit = { version = "0.7.0", features = ["test-support"] }
+2 -1
View File
@@ -5,7 +5,8 @@ INSERT INTO config VALUES ('{}');
CREATE TABLE aws_credentials ( 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, created_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL, updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
access_key_id VARCHAR UNIQUE NOT NULL, access_key_id VARCHAR UNIQUE NOT NULL,
+1 -1
View File
@@ -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 // 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. /// Our extra icons, falling back to gpui-kit's defaults.
pub struct CreddyAssets; pub struct CreddyAssets;
+8
View File
@@ -30,6 +30,7 @@ pub struct PassphraseInputBuilder {
id: SharedString, id: SharedString,
show: Option<Entity<bool>>, show: Option<Entity<bool>>,
placeholder: SharedString, placeholder: SharedString,
value: SharedString,
} }
impl PassphraseInputBuilder { impl PassphraseInputBuilder {
@@ -44,6 +45,11 @@ impl PassphraseInputBuilder {
self self
} }
pub fn value(mut self, value: impl Into<SharedString>) -> Self {
self.value = value.into();
self
}
pub fn build(self, window: &mut Window, cx: &mut App) -> Entity<PassphraseInput> { pub fn build(self, window: &mut Window, cx: &mut App) -> Entity<PassphraseInput> {
let show = self.show.unwrap_or_else(|| cx.new(|_| false)); let show = self.show.unwrap_or_else(|| cx.new(|_| false));
cx.new(|cx| { cx.new(|cx| {
@@ -52,6 +58,7 @@ impl PassphraseInputBuilder {
InputState::new(window, cx) InputState::new(window, cx)
.masked(masked) .masked(masked)
.placeholder(self.placeholder) .placeholder(self.placeholder)
.default_value(self.value)
}); });
// keep this field's masking in sync with the shared flag // keep this field's masking in sync with the shared flag
@@ -88,6 +95,7 @@ impl PassphraseInput {
id: id.into(), id: id.into(),
show: None, show: None,
placeholder: SharedString::default(), placeholder: SharedString::default(),
value: SharedString::default(),
} }
} }
+5 -2
View File
@@ -1,14 +1,17 @@
use jiff::Timestamp; use jiff::Timestamp;
use serde::{Serialize, Deserialize}; use serde::{Serialize, Deserialize};
use uuid::Uuid;
#[derive(Clone, Debug, Serialize, Deserialize)] #[derive(Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize)]
pub struct AwsCredential { pub struct AwsCredential {
pub id: Uuid,
pub name: String,
pub access_key_id: String, pub access_key_id: String,
pub secret_access_key: String, pub secret_access_key: String,
pub is_default: bool, pub is_default: bool,
} }
#[derive(Clone, Debug, Serialize, Deserialize)] #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct AwsSessionCredential { pub struct AwsSessionCredential {
pub version: usize, pub version: usize,
pub access_key_id: String, pub access_key_id: String,
+92 -83
View File
@@ -1,4 +1,3 @@
use std::collections::HashMap;
use duckdb::{Error, params}; use duckdb::{Error, params};
use crate::credentials::AwsCredential; use crate::credentials::AwsCredential;
use super::Db; use super::Db;
@@ -7,27 +6,37 @@ impl Db {
pub fn load_aws_credential(&self, name: &str) -> Result<AwsCredential, Error> { pub fn load_aws_credential(&self, name: &str) -> Result<AwsCredential, Error> {
let conn = self.connection.lock().unwrap(); let conn = self.connection.lock().unwrap();
conn.query_row( 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], params![name],
|row| Ok(AwsCredential { |row| Ok(AwsCredential {
access_key_id: row.get(0)?, id: row.get(0)?,
secret_access_key: row.get(1)?, name: row.get(1)?,
is_default: row.get(2)?, 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 mut conn = self.connection.lock().unwrap();
let tx = conn.transaction()?; let tx = conn.transaction()?;
if cred.is_default { if cred.is_default {
tx.execute( tx.execute(
"UPDATE aws_credentials SET is_default = false WHERE is_default AND name != ?", "UPDATE aws_credentials SET is_default = false WHERE is_default AND id != ?",
params![name], params![cred.id],
)?; )?;
} }
tx.execute( tx.execute(
"INSERT INTO aws_credentials ( "INSERT INTO aws_credentials (
id,
name, name,
created_at, created_at,
updated_at, updated_at,
@@ -35,52 +44,66 @@ impl Db {
secret_access_key, secret_access_key,
is_default, is_default,
) )
VALUES (?, now(), now(), ?, ?, ?) VALUES (?, ?, now(), now(), ?, ?, ?)
ON CONFLICT (name) DO UPDATE ON CONFLICT (id) DO UPDATE
SET SET
name = EXCLUDED.name,
updated_at = now(), updated_at = now(),
access_key_id = EXCLUDED.access_key_id, access_key_id = EXCLUDED.access_key_id,
secret_access_key = EXCLUDED.secret_access_key, secret_access_key = EXCLUDED.secret_access_key,
is_default = EXCLUDED.is_default", 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() tx.commit()
} }
pub fn list_aws_credentials(&self) -> Result<HashMap<String, AwsCredential>, Error> { pub fn list_aws_credentials(&self) -> Result<Vec<AwsCredential>, Error> {
let conn = self.connection.lock().unwrap(); 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 mut stmt = conn.prepare(
let rows = stmt.query_map([], |row| { "SELECT
let key: String = row.get(0)?; id,
let cred = AwsCredential{ name,
access_key_id: row.get(1)?, access_key_id,
secret_access_key: row.get(2)?, secret_access_key,
is_default: row.get(3)?, is_default
}; FROM aws_credentials
Ok((key, cred)) ORDER BY created_at"
})?; )?;
stmt.query_map([], |row| {
rows.collect() 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)] #[cfg(test)]
mod tests { mod tests {
use testresult::TestResult; use testresult::TestResult;
use uuid::Uuid;
use crate::test_data::TestEnv; use crate::test_data::TestEnv;
use super::*; 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] #[test]
fn test_save() -> TestResult { fn test_save() -> TestResult {
let env = TestEnv::new()?; let env = TestEnv::new()?;
let db = env.db()?; let db = env.db()?;
let cred = AwsCredential { db.save_aws_credential(&test_cred("test", "AKIAEXAMPLE"))?;
access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred)?;
Ok(()) Ok(())
} }
@@ -89,17 +112,12 @@ mod tests {
let env = TestEnv::new()?; let env = TestEnv::new()?;
let db = env.db()?; let db = env.db()?;
let cred = AwsCredential { let cred = test_cred("test", "AKIAEXAMPLE");
access_key_id: "AKIAEXAMPLE".into(), db.save_aws_credential(&cred)?;
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred)?;
let loaded = db.load_aws_credential("test")?; let loaded = db.load_aws_credential("test")?;
assert_eq!(loaded.access_key_id, cred.access_key_id); assert_eq!(loaded, cred);
assert_eq!(loaded.secret_access_key, cred.secret_access_key);
Ok(()) Ok(())
} }
@@ -108,23 +126,23 @@ mod tests {
let env = TestEnv::new()?; let env = TestEnv::new()?;
let db = env.db()?; let db = env.db()?;
let mut cred = AwsCredential { let mut cred = test_cred("test", "KEY1");
access_key_id: "KEY1".into(), db.save_aws_credential(&cred)?;
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred)?;
cred.name = "renamed".into();
cred.access_key_id = "KEY2".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")?; let creds = db.list_aws_credentials()?;
assert_eq!(loaded.access_key_id, "KEY2"); 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 // confirm that updated_at was modified, but not created_at
let conn = db.connection.lock().unwrap(); let conn = db.connection.lock().unwrap();
let (created_at, updated_at): (i64, i64) = conn.query_row( 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)?)) |row| Ok((row.get(0)?, row.get(1)?))
)?; )?;
@@ -133,34 +151,31 @@ mod tests {
Ok(()) 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] #[test]
fn test_list() -> TestResult { fn test_list() -> TestResult {
let env = TestEnv::new()?; let env = TestEnv::new()?;
let db = env.db()?; let db = env.db()?;
let cred1 = AwsCredential { // names are out of alphabetical order, since the list should be in order of creation
access_key_id: "KEY1".into(), let cred1 = test_cred("test2", "KEY1");
secret_access_key: "EXAMPLESECRET".into(), db.save_aws_credential(&cred1)?;
is_default: false, let cred2 = test_cred("test1", "KEY2");
}; db.save_aws_credential(&cred2)?;
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)?;
let creds = db.list_aws_credentials()?; let creds = db.list_aws_credentials()?;
assert_eq!(creds.len(), 2);
let loaded1 = creds.get("test").unwrap(); assert_eq!(creds[0], cred1);
assert_eq!(loaded1.access_key_id, cred1.access_key_id); assert_eq!(creds[1], cred2);
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);
Ok(()) Ok(())
} }
@@ -170,28 +185,22 @@ mod tests {
let env = TestEnv::new()?; let env = TestEnv::new()?;
let db = env.db()?; let db = env.db()?;
let cred1 = AwsCredential { let mut cred1 = test_cred("test", "KEY1");
access_key_id: "KEY1".into(), cred1.is_default = true;
secret_access_key: "EXAMPLESECRET".into(), db.save_aws_credential(&cred1)?;
is_default: true,
};
db.save_aws_credential("test", &cred1)?;
let cred2 = AwsCredential { let mut cred2 = test_cred("test2", "KEY2");
access_key_id: "KEY2".into(), cred2.is_default = true;
secret_access_key: "EXAMPLESECRET2".into(), db.save_aws_credential(&cred2)?;
is_default: true,
};
db.save_aws_credential("test2", &cred2)?;
assert!(!db.load_aws_credential("test")?.is_default); assert!(!db.load_aws_credential("test")?.is_default);
assert!(db.load_aws_credential("test2")?.is_default); assert!(db.load_aws_credential("test2")?.is_default);
// re-saving the current default shouldn't trip over its own row // 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); 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("test")?.is_default);
assert!(!db.load_aws_credential("test2")?.is_default); assert!(!db.load_aws_credential("test2")?.is_default);
+49 -2
View File
@@ -89,6 +89,7 @@ fn main() {
mod tests { mod tests {
use gpui_kit::{AnyWindowHandle, TestAppContext}; use gpui_kit::{AnyWindowHandle, TestAppContext};
use gpui_kit::test::TestWindowExt; use gpui_kit::test::TestWindowExt;
use uuid::Uuid;
use super::*; use super::*;
use crate::credentials::AwsCredential; use crate::credentials::AwsCredential;
use crate::test_data::{TEST_PASSPHRASE, TestEnv}; use crate::test_data::{TEST_PASSPHRASE, TestEnv};
@@ -259,11 +260,13 @@ mod tests {
fn test_credentials_tabs(cx: &mut TestAppContext) { fn test_credentials_tabs(cx: &mut TestAppContext) {
let env = TestEnv::new().unwrap(); let env = TestEnv::new().unwrap();
let cred = AwsCredential { let cred = AwsCredential {
id: Uuid::new_v4(),
name: "work".into(),
access_key_id: "AKIAEXAMPLE".into(), access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(), secret_access_key: "EXAMPLESECRET".into(),
is_default: false, 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); let window = open_app(&env, cx);
fill(window, "passphrase", TEST_PASSPHRASE, cx); fill(window, "passphrase", TEST_PASSPHRASE, cx);
click(window, "submit", cx); click(window, "submit", cx);
@@ -328,11 +331,13 @@ mod tests {
fn test_add_aws_credential_duplicate_name(cx: &mut TestAppContext) { fn test_add_aws_credential_duplicate_name(cx: &mut TestAppContext) {
let env = TestEnv::new().unwrap(); let env = TestEnv::new().unwrap();
let cred = AwsCredential { let cred = AwsCredential {
id: Uuid::new_v4(),
name: "work".into(),
access_key_id: "AKIAEXAMPLE".into(), access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(), secret_access_key: "EXAMPLESECRET".into(),
is_default: false, 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); let window = open_app(&env, cx);
fill(window, "passphrase", TEST_PASSPHRASE, cx); fill(window, "passphrase", TEST_PASSPHRASE, cx);
click(window, "submit", cx); click(window, "submit", cx);
@@ -354,4 +359,46 @@ mod tests {
}); });
assert_eq!(saved.access_key_id, "AKIAEXAMPLE"); 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::<AppSession>() 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);
}
} }
+126 -92
View File
@@ -12,16 +12,19 @@ use crate::components::{PassphraseInput, PassphraseInputEvent, colored_switch, e
use crate::credentials::AwsCredential; use crate::credentials::AwsCredential;
use crate::session::AppSession; use crate::session::AppSession;
use super::Screen; use super::Screen;
use uuid::Uuid;
pub struct CredentialsScreen { pub struct CredentialsScreen {
tab: usize, tab: usize,
aws: Vec<(String, AwsCredential)>, aws: Vec<AwsCredential>,
aws_form: Option<AwsForm>, aws_form: Option<AwsForm>,
error: Option<SharedString>, error: Option<SharedString>,
} }
struct AwsForm { struct AwsForm {
/// The id of the credential being edited, or None if this is a new one.
editing: Option<Uuid>,
name: Entity<InputState>, name: Entity<InputState>,
access_key_id: Entity<InputState>, access_key_id: Entity<InputState>,
secret_access_key: Entity<PassphraseInput>, secret_access_key: Entity<PassphraseInput>,
@@ -43,18 +46,25 @@ impl CredentialsScreen {
match db.list_aws_credentials() { match db.list_aws_credentials() {
Ok(creds) => { Ok(creds) => {
self.aws = creds.into_iter().collect(); self.aws = creds;
self.aws.sort_by(|a, b| a.0.cmp(&b.0));
self.error = None; self.error = None;
}, },
Err(e) => self.error = Some(format!("Failed to load credentials: {e}").into()), Err(e) => self.error = Some(format!("Failed to load credentials: {e}").into()),
} }
} }
fn add_aws(&mut self, window: &mut Window, cx: &mut Context<Self>) { fn open_aws_form(&mut self, editing: Option<Uuid>, window: &mut Window, cx: &mut Context<Self>) {
let name = cx.new(|cx| InputState::new(window, cx)); let existing = self.aws
let access_key_id = cx.new(|cx| InputState::new(window, cx)); .iter()
let secret_access_key = PassphraseInput::builder("aws-secret").build(window, cx); .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)); name.update(cx, |name, cx| name.focus(window, cx));
let mut _subscriptions = Vec::new(); let mut _subscriptions = Vec::new();
@@ -72,10 +82,11 @@ impl CredentialsScreen {
})); }));
self.aws_form = Some(AwsForm { self.aws_form = Some(AwsForm {
editing,
name, name,
access_key_id, access_key_id,
secret_access_key, secret_access_key,
is_default: false, is_default: existing.is_default,
_subscriptions, _subscriptions,
}); });
self.error = None; self.error = None;
@@ -84,21 +95,22 @@ impl CredentialsScreen {
fn save_aws(&mut self, cx: &mut Context<Self>) { fn save_aws(&mut self, cx: &mut Context<Self>) {
let Some(form) = &self.aws_form else { return }; 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 { 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(), 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(), secret_access_key: form.secret_access_key.read(cx).value(cx).trim().to_string(),
is_default: form.is_default, 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()); self.error = Some("All fields are required.".into());
cx.notify(); cx.notify();
return; 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 == cred.name && existing.id != cred.id) {
if self.aws.iter().any(|(existing, _)| *existing == name) { self.error = Some(format!("An AWS credential named \"{}\" already exists.", cred.name).into());
self.error = Some(format!("An AWS credential named \"{name}\" already exists.").into());
cx.notify(); cx.notify();
return; return;
} }
@@ -106,7 +118,7 @@ impl CredentialsScreen {
let AppSession::Unlocked(db) = cx.global::<AppSession>() else { let AppSession::Unlocked(db) = cx.global::<AppSession>() else {
unreachable!("credentials screen is only shown while unlocked"); unreachable!("credentials screen is only shown while unlocked");
}; };
match db.save_aws_credential(&name, &cred) { match db.save_aws_credential(&cred) {
Ok(()) => { Ok(()) => {
self.aws_form = None; self.aws_form = None;
self.load_aws(cx); self.load_aws(cx);
@@ -119,43 +131,67 @@ impl CredentialsScreen {
fn render_aws_tab(&self, window: &mut Window, cx: &mut Context<Self>) -> Div { fn render_aws_tab(&self, window: &mut Window, cx: &mut Context<Self>) -> Div {
let t = cx.omarchy().clone(); let t = cx.omarchy().clone();
let list = if self.aws.is_empty() { let mut panel = div().flex().flex_col().gap(rems(0.5));
empty_state("AWS access keys", "You have no saved AWS credentials.", cx) if self.aws.is_empty() {
} else { panel = panel.child(empty_state("AWS access keys", "You have no saved AWS credentials.", cx));
div() }
.flex() for cred in &self.aws {
.flex_col() if let Some(form) = &self.aws_form
.gap(rems(0.5)) && form.editing == Some(cred.id)
.children(self.aws.iter().map(|(name, cred)| { {
div() panel = panel.child(self.render_aws_form(form, window, cx));
.id(SharedString::from(name)) continue;
.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 Some(form) = &self.aws_form else { let id = cred.id;
return div().flex().flex_col().gap(rems(1.)).child(list).child( 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) button("aws-add", "Add", ButtonVariant::Primary, cx)
.self_center() .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<Self>) -> Div {
let t = cx.omarchy().clone();
let field = |label: &'static str, input: gpui_kit::AnyElement| { let field = |label: &'static str, input: gpui_kit::AnyElement| {
div() div()
.flex() .flex()
@@ -166,51 +202,49 @@ impl CredentialsScreen {
}; };
let this = cx.entity(); let this = cx.entity();
div().flex().flex_col().gap(rems(1.)).child(list).child( div()
div() .flex()
.flex() .flex_col()
.flex_col() .gap(rems(1.))
.gap(rems(1.)) .p(rems(1.))
.p(rems(1.)) .border_1()
.border_1() .border_color(t.border)
.border_color(t.border) .child(field("Name", input("aws-name", &form.name, window, cx).into_any_element()))
.child(field("Name", input("aws-name", &form.name, window, cx).into_any_element())) .child(field(
.child(field( "Key ID",
"Key ID", input("aws-key-id", &form.access_key_id, window, cx)
input("aws-key-id", &form.access_key_id, window, cx) .font_family(t.mono_font.clone())
.font_family(t.mono_font.clone()) .into_any_element(),
.into_any_element(), ))
)) .child(field("Secret key", form.secret_access_key.clone().into_any_element()))
.child(field("Secret key", form.secret_access_key.clone().into_any_element())) .child(
.child( div()
div() .flex()
.flex() .items_center()
.items_center() .gap(rems(0.5))
.gap(rems(0.5)) .child(
.child( colored_switch("aws-default", "Default AWS access key", form.is_default, t.success, cx)
colored_switch("aws-default", "Default AWS access key", form.is_default, t.success, cx) .on_change(move |value, _, _, cx| this.update(cx, |this, cx| {
.on_change(move |value, _, _, cx| this.update(cx, |this, cx| { if let Some(form) = &mut this.aws_form {
if let Some(form) = &mut this.aws_form { form.is_default = value;
form.is_default = value; }
} cx.notify();
cx.notify(); })),
})), )
) .child(
.child( button("aws-cancel", "Cancel", ButtonVariant::Outline, cx)
button("aws-cancel", "Cancel", ButtonVariant::Outline, cx) .ml_auto()
.ml_auto() .on_click(cx.listener(|this, _, _, cx| {
.on_click(cx.listener(|this, _, _, cx| { this.aws_form = None;
this.aws_form = None; this.error = None;
this.error = None; cx.notify();
cx.notify(); })),
})), )
) .child(
.child( button("aws-save", "Save", ButtonVariant::Primary, cx)
button("aws-save", "Save", ButtonVariant::Primary, cx) .on_click(cx.listener(|this, _, _, cx| this.save_aws(cx))),
.on_click(cx.listener(|this, _, _, cx| this.save_aws(cx))), ),
), )
),
)
} }
} }