feat(login): store in git config and use cache

replace ngit yaml file config with:
 * nsec / ncryptsec / npub in git config in nostr.* namespace
 * sql database cache for metadata and relay events

allow different logins to be used for different git repositories by
storing login in local git config

1 files changed, 2 insertions, 187 deletions

diff --git a/src/config.rs b/src/config.rs
index 7fca446..56619b8 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,107 +1,19 @@
-use std::{fs::File, io::BufReader};
-
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Result};
 use directories::ProjectDirs;
-#[cfg(test)]
-use mockall::*;
-use nostr::{PublicKey, ToBech32};
+use nostr::PublicKey;
 use serde::{self, Deserialize, Serialize};
 
-#[derive(Default)]
-#[allow(clippy::module_name_repetitions)]
-pub struct ConfigManager;
-
-#[cfg_attr(test, automock)]
-#[allow(clippy::module_name_repetitions)]
-pub trait ConfigManagement {
-    fn load(&self) -> Result<MyConfig>;
-    fn save(&self, cfg: &MyConfig) -> Result<()>;
-}
-
 pub fn get_dirs() -> Result<ProjectDirs> {
     ProjectDirs::from("", "CodeCollaboration", "ngit").ok_or(anyhow!(
         "should find operating system home directories with rust-directories crate"
     ))
 }
 
-impl ConfigManagement for ConfigManager {
-    fn load(&self) -> Result<MyConfig> {
-        let config_path = get_dirs()?.config_dir().join("config.json");
-        if config_path.exists() {
-            let file =
-                File::open(config_path).context("should open application configuration file")?;
-            let reader = BufReader::new(file);
-            let config: MyConfig = serde_json::from_reader(reader)
-                .context("should read config from config file with serde_json")?;
-            Ok(config)
-        } else {
-            Ok(MyConfig::default())
-        }
-    }
-    fn save(&self, cfg: &MyConfig) -> Result<()> {
-        let dirs = get_dirs()?;
-        let config_path = dirs.config_dir().join("config.json");
-        let file = if config_path.exists() {
-            std::fs::OpenOptions::new()
-                .create(true)
-                .write(true)
-                .truncate(true)
-                .open(config_path)
-                .context(
-                    "should open application configuration file with write and truncate options",
-                )?
-        } else {
-            std::fs::create_dir_all(dirs.config_dir())
-                .context("should create application config directories")?;
-            std::fs::File::create(config_path).context("should create application config file")?
-        };
-        serde_json::to_writer_pretty(file, cfg)
-            .context("should write configuration to config file with serde_json")
-    }
-}
-
-#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
-#[allow(clippy::module_name_repetitions)]
-pub struct MyConfig {
-    pub version: u8,
-    pub users: Vec<UserRef>,
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct UserRef {
     pub public_key: PublicKey,
-    pub encrypted_key: String,
     pub metadata: UserMetadata,
     pub relays: UserRelays,
-    pub last_checked: u64,
-}
-
-impl UserRef {
-    pub fn new(public_key: PublicKey, encrypted_key: String) -> Self {
-        Self {
-            public_key,
-            encrypted_key,
-            relays: UserRelays {
-                relays: vec![],
-                created_at: 0,
-            },
-            metadata: UserMetadata {
-                #[allow(clippy::expect_used)]
-                name: public_key
-                    .to_bech32()
-                    .expect("public key should always produce bech32"),
-                // name: format!(
-                //     "{}",
-                //     public_key
-                //         .to_bech32()
-                //         .expect("public key should always produce bech32"),
-                // )
-                // .as_str()[..10].to_string(),
-                created_at: 0,
-            },
-            last_checked: 0,
-        }
-    }
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -132,100 +44,3 @@ pub struct UserRelayRef {
     pub read: bool,
     pub write: bool,
 }
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-    use serial_test::serial;
-
-    use super::*;
-
-    fn backup_existing_config() -> Result<()> {
-        let config_path = get_dirs()?.config_dir().join("config.json");
-        let backup_config_path = get_dirs()?.config_dir().join("config-backup.json");
-        if config_path.exists() {
-            std::fs::rename(config_path, backup_config_path)?;
-        }
-        Ok(())
-    }
-
-    fn restore_config_backup() -> Result<()> {
-        let config_path = get_dirs()?.config_dir().join("config.json");
-        let backup_config_path = get_dirs()?.config_dir().join("config-backup.json");
-        if config_path.exists() {
-            std::fs::remove_file(&config_path)?;
-        }
-        if backup_config_path.exists() {
-            std::fs::rename(backup_config_path, config_path)?;
-        }
-        Ok(())
-    }
-
-    mod load {
-        use super::*;
-
-        #[test]
-        #[serial]
-        fn when_config_file_doesnt_exist_defaults_are_returned() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            assert_eq!(c.load()?, MyConfig::default());
-            restore_config_backup()?;
-            Ok(())
-        }
-
-        #[test]
-        #[serial]
-        fn when_config_file_exists_it_is_returned() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            let new_config = MyConfig {
-                version: 255,
-                ..MyConfig::default()
-            };
-            c.save(&new_config)?;
-            assert_eq!(c.load()?, new_config);
-            restore_config_backup()?;
-            Ok(())
-        }
-    }
-
-    mod save {
-        use super::*;
-
-        #[test]
-        #[serial]
-        fn when_config_file_doesnt_config_is_saved() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            let new_config = MyConfig {
-                version: 255,
-                ..MyConfig::default()
-            };
-            c.save(&new_config)?;
-            assert_eq!(c.load().unwrap(), new_config);
-            restore_config_backup()?;
-            Ok(())
-        }
-
-        #[test]
-        #[serial]
-        fn when_config_file_exists_new_config_is_saved() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            let config = MyConfig {
-                version: 255,
-                ..MyConfig::default()
-            };
-            c.save(&config)?;
-            let new_config = MyConfig {
-                version: 254,
-                ..MyConfig::default()
-            };
-            c.save(&new_config)?;
-            assert_eq!(c.load().unwrap(), new_config);
-            restore_config_backup()?;
-            Ok(())
-        }
-    }
-}