feat(claim) create yaml add maintainers and relays

- create yaml file with maintainers and relays
- add maintainers to repo event
- add current user as maintainer
- custom repo relays from cli argument
- save git-server in repo event

1 files changed, 165 insertions, 19 deletions

diff --git a/src/repo_ref.rs b/src/repo_ref.rs
index a92b5b3..a5b35c9 100644
--- a/src/repo_ref.rs
+++ b/src/repo_ref.rs
@@ -1,20 +1,26 @@
+use std::{fs::File, io::BufReader, str::FromStr};
+
 use anyhow::{bail, Context, Result};
-use nostr::Tag;
+use nostr::{secp256k1::XOnlyPublicKey, FromBech32, Tag, ToBech32};
+use serde::{Deserialize, Serialize};
 
 #[cfg(not(test))]
 use crate::client::Client;
-use crate::client::Connect;
 #[cfg(test)]
 use crate::client::MockConnect;
+use crate::{
+    client::Connect,
+    git::{Repo, RepoActions},
+};
 
 #[derive(Default)]
 pub struct RepoRef {
     pub name: String,
     pub description: String,
     pub root_commit: String,
+    pub git_server: String,
     pub relays: Vec<String>,
-    // git_server: String,
-    // other maintainers
+    pub maintainers: Vec<XOnlyPublicKey>,
     // code languages and hashtags
 }
 
@@ -35,6 +41,10 @@ impl TryFrom<nostr::Event> for RepoRef {
             r.description = t.as_vec()[1].clone();
         }
 
+        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("git-server")) {
+            r.git_server = t.as_vec()[1].clone();
+        }
+
         if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("d")) {
             r.root_commit = t.as_vec()[1].clone();
         }
@@ -46,6 +56,15 @@ impl TryFrom<nostr::Event> for RepoRef {
             .map(|t| t.as_vec()[1].clone())
             .collect();
 
+        for tag in event.tags.iter().filter(|t| t.as_vec()[0].eq("p")) {
+            let pk = tag.as_vec()[1].clone();
+            r.maintainers.push(
+                nostr_sdk::prelude::XOnlyPublicKey::from_str(&pk)
+                    .context(format!("cannot convert {pk} into a valid nostr public key"))
+                    .context("invalid repository event")?,
+            );
+        }
+
         Ok(r)
     }
 }
@@ -62,10 +81,17 @@ impl RepoRef {
                     Tag::Reference(format!("r-{}", self.root_commit)),
                     Tag::Name(self.name.clone()),
                     Tag::Description(self.description.clone()),
+                    Tag::Generic(
+                        nostr::TagKind::Custom("git-server".to_string()),
+                        vec![self.git_server.clone()],
+                    ),
+                    Tag::Reference(self.git_server.clone()),
                 ],
                 self.relays.iter().map(|r| Tag::Relay(r.into())).collect(),
-                // git_servers
-                // other maintainers
+                self.maintainers
+                    .iter()
+                    .map(|pk| Tag::PubKey(*pk, None))
+                    .collect(),
                 // code languages and hashtags
             ]
             .concat(),
@@ -76,24 +102,30 @@ impl RepoRef {
 }
 
 pub async fn fetch(
+    git_repo: &Repo,
     root_commit: String,
     #[cfg(test)] client: &MockConnect,
     #[cfg(not(test))] client: &Client,
     // TODO: more rubust way of finding repo events
-    relays: Vec<String>,
+    fallback_relays: Vec<String>,
 ) -> Result<RepoRef> {
-    // TODO: fetch relay information from file
+    let repo_config = get_repo_config_from_yaml(git_repo);
 
-    let events: Vec<nostr::Event> = client
-        .get_events(
-            relays,
-            vec![
-                nostr::Filter::default()
-                    .kind(nostr::Kind::Custom(REPO_REF_KIND))
-                    .identifier(root_commit),
-            ],
-        )
-        .await?;
+    // TODO: check events only from maintainers. get relay list of maintainters.
+    // check those relays.
+
+    let mut repo_event_filter = nostr::Filter::default()
+        .kind(nostr::Kind::Custom(REPO_REF_KIND))
+        .identifier(root_commit);
+
+    let mut relays = fallback_relays;
+    if let Ok(repo_config) = repo_config {
+        repo_event_filter =
+            repo_event_filter.pubkeys(extract_pks(repo_config.maintainers.clone())?);
+        relays = repo_config.relays.clone();
+    }
+
+    let events: Vec<nostr::Event> = client.get_events(relays, vec![repo_event_filter]).await?;
 
     RepoRef::try_from(
         events
@@ -105,6 +137,68 @@ pub async fn fetch(
     )
 }
 
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
+pub struct RepoConfigYaml {
+    pub maintainers: Vec<String>,
+    pub relays: Vec<String>,
+}
+
+pub fn get_repo_config_from_yaml(git_repo: &Repo) -> Result<RepoConfigYaml> {
+    let path = git_repo.get_path()?.join("maintainers.yaml");
+    let file = File::open(path)
+        .context("should open maintainers.yaml if it exists")
+        .context("maintainers.yaml doesnt exist")?;
+    let reader = BufReader::new(file);
+    let repo_config_yaml: RepoConfigYaml = serde_yaml::from_reader(reader)
+        .context("should read maintainers.yaml with serde_yaml")
+        .context("maintainers.yaml incorrectly formatted")?;
+    Ok(repo_config_yaml)
+}
+
+pub fn extract_pks(pk_strings: Vec<String>) -> Result<Vec<XOnlyPublicKey>> {
+    let mut pks: Vec<XOnlyPublicKey> = vec![];
+    for s in pk_strings {
+        pks.push(
+            nostr_sdk::prelude::XOnlyPublicKey::from_bech32(s.clone())
+                .context(format!("cannot convert {s} into a valid nostr public key"))?,
+        );
+    }
+    Ok(pks)
+}
+
+pub fn save_repo_config_to_yaml(
+    git_repo: &Repo,
+    maintainers: Vec<XOnlyPublicKey>,
+    relays: Vec<String>,
+) -> Result<()> {
+    let path = git_repo.get_path()?.join("maintainers.yaml");
+    let file = if path.exists() {
+        std::fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(path)
+            .context("cannot open maintainers.yaml file with write and truncate options")?
+    } else {
+        std::fs::File::create(path).context("cannot create maintainers.yaml file")?
+    };
+    let mut maintainers_npubs = vec![];
+    for m in maintainers {
+        maintainers_npubs.push(
+            m.to_bech32()
+                .context("cannot convert public key into npub")?,
+        );
+    }
+    serde_yaml::to_writer(
+        file,
+        &RepoConfigYaml {
+            maintainers: maintainers_npubs,
+            relays,
+        },
+    )
+    .context("cannot write maintainers to maintainers.yaml file serde_yaml")
+}
+
 #[cfg(test)]
 mod tests {
     use test_utils::*;
@@ -116,7 +210,9 @@ mod tests {
             name: "test name".to_string(),
             description: "test description".to_string(),
             root_commit: "23471389461".to_string(),
+            git_server: "https://localhost:1000".to_string(),
             relays: vec!["ws://relay1.io".to_string(), "ws://relay2.io".to_string()],
+            maintainers: vec![TEST_KEY_1_KEYS.public_key(), TEST_KEY_2_KEYS.public_key()],
         }
         .to_event(&TEST_KEY_1_KEYS)
         .unwrap()
@@ -146,12 +242,28 @@ mod tests {
         }
 
         #[test]
+        fn git_server() {
+            assert_eq!(
+                RepoRef::try_from(create()).unwrap().git_server,
+                "https://localhost:1000",
+            )
+        }
+
+        #[test]
         fn relays() {
             assert_eq!(
                 RepoRef::try_from(create()).unwrap().relays,
                 vec!["ws://relay1.io".to_string(), "ws://relay2.io".to_string()],
             )
         }
+
+        #[test]
+        fn maintainers() {
+            assert_eq!(
+                RepoRef::try_from(create()).unwrap().maintainers,
+                vec![TEST_KEY_1_KEYS.public_key(), TEST_KEY_2_KEYS.public_key()],
+            )
+        }
     }
 
     mod to_event {
@@ -186,6 +298,21 @@ mod tests {
             }
 
             #[test]
+            fn git_server() {
+                assert!(create().tags.iter().any(|t| t.as_vec()[0].eq("git-server")
+                    && t.as_vec()[1].eq("https://localhost:1000")))
+            }
+
+            #[test]
+            fn git_server_as_reference() {
+                assert!(
+                    create().tags.iter().any(
+                        |t| t.as_vec()[0].eq("r") && t.as_vec()[1].eq("https://localhost:1000")
+                    )
+                )
+            }
+
+            #[test]
             fn root_commit_as_reference() {
                 assert!(
                     create()
@@ -209,8 +336,27 @@ mod tests {
             }
 
             #[test]
+            fn maintainers() {
+                let event = create();
+                let p_tags = event
+                    .tags
+                    .iter()
+                    .filter(|t| t.as_vec()[0].eq("p"))
+                    .collect::<Vec<&nostr::Tag>>();
+                assert_eq!(p_tags[0].as_vec().len(), 2);
+                assert_eq!(
+                    p_tags[0].as_vec()[1],
+                    TEST_KEY_1_KEYS.public_key().to_string()
+                );
+                assert_eq!(
+                    p_tags[1].as_vec()[1],
+                    TEST_KEY_2_KEYS.public_key().to_string()
+                );
+            }
+
+            #[test]
             fn no_other_tags() {
-                assert_eq!(create().tags.len(), 6)
+                assert_eq!(create().tags.len(), 10)
             }
         }
     }