1use gpui::App;
  2use sqlez_macros::sql;
  3use util::ResultExt as _;
  4
  5use crate::{define_connection, query, write_and_log};
  6
  7define_connection!(pub static ref KEY_VALUE_STORE: KeyValueStore<()> =
  8    &[sql!(
  9        CREATE TABLE IF NOT EXISTS kv_store(
 10            key TEXT PRIMARY KEY,
 11            value TEXT NOT NULL
 12        ) STRICT;
 13    )];
 14);
 15
 16pub trait Dismissable {
 17    const KEY: &'static str;
 18
 19    fn dismissed() -> bool {
 20        KEY_VALUE_STORE
 21            .read_kvp(Self::KEY)
 22            .log_err()
 23            .is_some_and(|s| s.is_some())
 24    }
 25
 26    fn set_dismissed(is_dismissed: bool, cx: &mut App) {
 27        write_and_log(cx, move || async move {
 28            if is_dismissed {
 29                KEY_VALUE_STORE
 30                    .write_kvp(Self::KEY.into(), "1".into())
 31                    .await
 32            } else {
 33                KEY_VALUE_STORE.delete_kvp(Self::KEY.into()).await
 34            }
 35        })
 36    }
 37}
 38
 39impl KeyValueStore {
 40    query! {
 41        pub fn read_kvp(key: &str) -> Result<Option<String>> {
 42            SELECT value FROM kv_store WHERE key = (?)
 43        }
 44    }
 45
 46    pub async fn write_kvp(&self, key: String, value: String) -> anyhow::Result<()> {
 47        log::debug!("Writing key-value pair for key {key}");
 48        self.write_kvp_inner(key, value).await
 49    }
 50
 51    query! {
 52        async fn write_kvp_inner(key: String, value: String) -> Result<()> {
 53            INSERT OR REPLACE INTO kv_store(key, value) VALUES ((?), (?))
 54        }
 55    }
 56
 57    query! {
 58        pub async fn delete_kvp(key: String) -> Result<()> {
 59            DELETE FROM kv_store WHERE key = (?)
 60        }
 61    }
 62}
 63
 64#[cfg(test)]
 65mod tests {
 66    use crate::kvp::KeyValueStore;
 67
 68    #[gpui::test]
 69    async fn test_kvp() {
 70        let db = KeyValueStore::open_test_db("test_kvp").await;
 71
 72        assert_eq!(db.read_kvp("key-1").unwrap(), None);
 73
 74        db.write_kvp("key-1".to_string(), "one".to_string())
 75            .await
 76            .unwrap();
 77        assert_eq!(db.read_kvp("key-1").unwrap(), Some("one".to_string()));
 78
 79        db.write_kvp("key-1".to_string(), "one-2".to_string())
 80            .await
 81            .unwrap();
 82        assert_eq!(db.read_kvp("key-1").unwrap(), Some("one-2".to_string()));
 83
 84        db.write_kvp("key-2".to_string(), "two".to_string())
 85            .await
 86            .unwrap();
 87        assert_eq!(db.read_kvp("key-2").unwrap(), Some("two".to_string()));
 88
 89        db.delete_kvp("key-1".to_string()).await.unwrap();
 90        assert_eq!(db.read_kvp("key-1").unwrap(), None);
 91    }
 92}
 93
 94define_connection!(pub static ref GLOBAL_KEY_VALUE_STORE: GlobalKeyValueStore<()> =
 95    &[sql!(
 96        CREATE TABLE IF NOT EXISTS kv_store(
 97            key TEXT PRIMARY KEY,
 98            value TEXT NOT NULL
 99        ) STRICT;
100    )];
101    global
102);
103
104impl GlobalKeyValueStore {
105    query! {
106        pub fn read_kvp(key: &str) -> Result<Option<String>> {
107            SELECT value FROM kv_store WHERE key = (?)
108        }
109    }
110
111    pub async fn write_kvp(&self, key: String, value: String) -> anyhow::Result<()> {
112        log::debug!("Writing global key-value pair for key {key}");
113        self.write_kvp_inner(key, value).await
114    }
115
116    query! {
117        async fn write_kvp_inner(key: String, value: String) -> Result<()> {
118            INSERT OR REPLACE INTO kv_store(key, value) VALUES ((?), (?))
119        }
120    }
121
122    query! {
123        pub async fn delete_kvp(key: String) -> Result<()> {
124            DELETE FROM kv_store WHERE key = (?)
125        }
126    }
127}