feat!(database): Rebuild database struct and query logic

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxide"
-version = "0.9.1"
+version = "0.10.0"
 edition = "2021"
 build = "build.rs"
 license = "MIT"

src/api/alias.rs

@@ -163,11 +163,11 @@ mod tests {
         alias.get_repo("kubernetes", "k8s").unwrap();
 
         let merge = MergeOptions {
-            owner: format!("test-alias"),
-            name: format!("ro"),
+            owner: "test-alias".to_string(),
+            name: "ro".to_string(),
             upstream: None,
-            source: format!("test"),
-            target: format!("main"),
+            source: "test".to_string(),
+            target: "main".to_string(),
         };
         let result = alias
             .create_merge(merge.clone(), String::new(), String::new())

src/api/cache.rs

@@ -9,8 +9,7 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 
 use crate::api::{ApiRepo, MergeOptions, Provider};
-use crate::config::Config;
-use crate::repo::Remote;
+use crate::config::{Config, RemoteConfig};
 use crate::utils::{self, FileLock};
 
 pub struct Cache {
@@ -76,13 +75,16 @@ impl Provider for Cache {
 impl Cache {
     pub fn new(
         cfg: &Config,
-        remote: &Remote,
+        remote_cfg: &RemoteConfig,
         upstream: Box<dyn Provider>,
         force: bool,
     ) -> Result<Cache> {
         let lock = FileLock::acquire(cfg, "cache")?;
-        let expire = Duration::from_secs(remote.cfg.cache_hours as u64 * 3600);
-        let dir = cfg.get_meta_dir().join("cache").join(&remote.name);
+        let expire = Duration::from_secs(remote_cfg.cache_hours as u64 * 3600);
+        let dir = cfg
+            .get_meta_dir()
+            .join("cache")
+            .join(&remote_cfg.get_name());
         Ok(Cache {
             dir,
             expire,
@@ -172,13 +174,9 @@ mod cache_tests {
         let cfg = config_tests::load_test_config("api_cache/normal");
         let upstream = StaticProvider::mock();
         let expect_repos = upstream.list_repos("fioncat").unwrap();
-        let remote_cfg = cfg.must_get_remote("github").unwrap();
-        let remote = &Remote {
-            name: String::from("github"),
-            cfg: remote_cfg.clone(),
-        };
+        let remote_cfg = cfg.get_remote("github").unwrap();
 
-        let mut cache = Cache::new(&cfg, &remote, upstream, true).unwrap();
+        let mut cache = Cache::new(&cfg, &remote_cfg, upstream, true).unwrap();
 
         assert_eq!(cache.list_repos("fioncat").unwrap(), expect_repos);
 
@@ -194,13 +192,9 @@ mod cache_tests {
         let cfg = config_tests::load_test_config("api_cache/expire");
         let upstream = StaticProvider::mock();
         let expect_repos = upstream.list_repos("kubernetes").unwrap();
-        let remote_cfg = cfg.must_get_remote("github").unwrap();
-        let remote = &Remote {
-            name: String::from("github"),
-            cfg: remote_cfg.clone(),
-        };
+        let remote_cfg = cfg.get_remote("github").unwrap();
 
-        let mut cache = Cache::new(&cfg, &remote, upstream, true).unwrap();
+        let mut cache = Cache::new(&cfg, &remote_cfg, upstream, true).unwrap();
         // Set a small expire time to simulate expiration.
         cache.expire = Duration::from_secs(100);
         assert_eq!(cache.list_repos("kubernetes").unwrap(), expect_repos);

src/api/github.rs

@@ -7,7 +7,7 @@ use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
 use crate::api::{ApiRepo, ApiUpstream, MergeOptions, Provider};
-use crate::repo::Remote;
+use crate::config::RemoteConfig;
 
 #[derive(Debug, Deserialize)]
 struct Repo {
@@ -192,11 +192,11 @@ impl Provider for Github {
 impl Github {
     const API_VERSION: &'static str = "2022-11-28";
 
-    pub fn new(remote: &Remote) -> Box<dyn Provider> {
-        let client = super::build_common_client(remote);
+    pub fn new(remote_cfg: &RemoteConfig) -> Box<dyn Provider> {
+        let client = super::build_common_client(remote_cfg);
         Box::new(Github {
-            token: remote.cfg.token.clone(),
-            per_page: remote.cfg.list_limit,
+            token: remote_cfg.token.clone(),
+            per_page: remote_cfg.list_limit,
             client,
         })
     }

src/api/gitlab.rs

@@ -5,8 +5,7 @@ use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
 use crate::api::{ApiRepo, MergeOptions, Provider};
-use crate::config::defaults;
-use crate::repo::Remote;
+use crate::config::{defaults, RemoteConfig};
 
 #[derive(Debug, Deserialize)]
 struct GitlabRepo {
@@ -123,20 +122,20 @@ impl Provider for Gitlab {
 impl Gitlab {
     const API_VERSION: u8 = 4;
 
-    pub fn new(remote: &Remote) -> Box<dyn Provider> {
-        let client = super::build_common_client(remote);
-        let domain = match &remote.cfg.api_domain {
+    pub fn new(remote_cfg: &RemoteConfig) -> Box<dyn Provider> {
+        let client = super::build_common_client(remote_cfg);
+        let domain = match &remote_cfg.api_domain {
             Some(domain) => domain.clone(),
             None => String::from("gitlab.com"),
         };
 
         let url = format!("https://{domain}/api/v{}", Self::API_VERSION);
 
         Box::new(Gitlab {
-            token: remote.cfg.token.clone(),
+            token: remote_cfg.token.clone(),
             client,
             url,
-            per_page: remote.cfg.list_limit,
+            per_page: remote_cfg.list_limit,
         })
     }
 

src/api/mod.rs

@@ -14,8 +14,7 @@ use crate::api::alias::Alias;
 use crate::api::cache::Cache;
 use crate::api::github::Github;
 use crate::api::gitlab::Gitlab;
-use crate::config::{Config, ProviderType};
-use crate::repo::Remote;
+use crate::config::{Config, ProviderType, RemoteConfig};
 
 /// Represents repository information obtained from a [`Provider`].
 #[derive(Debug, PartialEq, Deserialize, Serialize)]
@@ -122,9 +121,9 @@ pub trait Provider {
 }
 
 /// Build common http client.
-fn build_common_client(remote: &Remote) -> Client {
+fn build_common_client(remote_cfg: &RemoteConfig) -> Client {
     Client::builder()
-        .timeout(Duration::from_secs(remote.cfg.api_timeout))
+        .timeout(Duration::from_secs(remote_cfg.api_timeout))
         .build()
         .unwrap()
 }
@@ -144,23 +143,30 @@ fn build_common_client(remote: &Remote) -> Client {
 /// names so that the remote API can correctly identify them.
 /// * `force` - Only effective when cache is enabled, indicating that the current
 /// cache should be forcibly expired to refresh cache data.
-pub fn build_provider(cfg: &Config, remote: &Remote, force: bool) -> Result<Box<dyn Provider>> {
-    if let None = remote.cfg.provider {
-        bail!("missing provider config for remote '{}'", remote.name);
+pub fn build_provider(
+    cfg: &Config,
+    remote_cfg: &RemoteConfig,
+    force: bool,
+) -> Result<Box<dyn Provider>> {
+    if let None = remote_cfg.provider {
+        bail!(
+            "missing provider config for remote '{}'",
+            remote_cfg.get_name()
+        );
     }
 
-    let mut provider = match remote.cfg.provider.as_ref().unwrap() {
-        ProviderType::Github => Github::new(remote),
-        ProviderType::Gitlab => Gitlab::new(remote),
+    let mut provider = match remote_cfg.provider.as_ref().unwrap() {
+        ProviderType::Github => Github::new(remote_cfg),
+        ProviderType::Gitlab => Gitlab::new(remote_cfg),
     };
 
-    if remote.cfg.cache_hours > 0 {
-        let cache = Cache::new(cfg, remote, provider, force)?;
+    if remote_cfg.cache_hours > 0 {
+        let cache = Cache::new(cfg, remote_cfg, provider, force)?;
         provider = Box::new(cache);
     }
 
-    if remote.cfg.has_alias() {
-        let (alias_owner, alias_repo) = remote.cfg.get_alias_map();
+    if remote_cfg.has_alias() {
+        let (alias_owner, alias_repo) = remote_cfg.get_alias_map();
         provider = Alias::new(alias_owner, alias_repo, provider);
     }
 

src/cmd/attach.rs

@@ -45,8 +45,8 @@ impl Run for AttachArgs {
             .with_repo_path(path);
 
         let head = Some(self.head.clone());
-        let selector = Selector::from_args(&db, &head, &self.query, opts);
-        let (repo, exists) = selector.one()?;
+        let selector = Selector::from_args(&head, &self.query, opts);
+        let (mut repo, exists) = selector.one(&db)?;
 
         if exists {
             bail!(
@@ -61,19 +61,20 @@ impl Run for AttachArgs {
             repo.name_with_remote()
         );
 
-        if let Some(user) = &repo.remote.cfg.user {
+        if let Some(user) = &repo.remote_cfg.user {
             Cmd::git(&["config", "user.name", user.as_str()])
                 .with_display(format!("Set user to '{}'", user))
                 .execute_check()?;
         }
-        if let Some(email) = &repo.remote.cfg.email {
+        if let Some(email) = &repo.remote_cfg.email {
             Cmd::git(&["config", "user.email", email.as_str()])
                 .with_display(format!("Set email to '{}'", email))
                 .execute_check()?;
         }
 
         info!("Attach current directory to {}", repo.name_with_remote());
-        db.update(repo, append_labels);
+        repo.append_labels(append_labels);
+        db.upsert(repo.update());
 
         db.save()
     }

src/cmd/copy.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashSet;
 use std::fs;
 use std::io;
@@ -56,8 +57,16 @@ impl Run for CopyArgs {
             labels.extend(extra_labels);
         }
 
-        let repo = Repo::new(cfg, &self.remote, &owner, &name, None, &Some(labels))?;
-        if let Some(_) = db.get(&self.remote, &owner, &name) {
+        let mut repo = Repo::new(
+            cfg,
+            Cow::Borrowed(&self.remote),
+            Cow::Owned(owner),
+            Cow::Owned(name),
+            None,
+        )?;
+        repo.append_labels(Some(labels));
+
+        if let Some(_) = db.get(&self.remote, repo.owner.as_ref(), repo.name.as_ref()) {
             confirm!(
                 "Do you want to overwrite the repo {}",
                 repo.name_with_remote()
@@ -115,7 +124,7 @@ impl Run for CopyArgs {
 
         println!("{path}");
 
-        db.update(repo, None);
+        db.upsert(repo);
         db.save()
     }
 }

src/cmd/detach.rs

@@ -20,7 +20,7 @@ impl Run for DetachArgs {
             repo.name_with_remote()
         );
 
-        db.remove(repo);
+        db.remove(repo.update());
 
         db.save()
     }