feat: hashmap based caching

Cargo.toml

@@ -24,7 +24,9 @@ pacquet_cafs         = { path = "crates/cafs" }
 pacquet_diagnostics  = { path = "crates/diagnostics" }
 
 # Dependencies
+async-recursion    = { version = "1.0.4" }
 clap               = { version = "4", features = ["derive", "string"] }
+dashmap            = { version = "5.5.0" }
 home               = { version = "0.5.5" }
 insta              = { version = "1.31.0", features = ["yaml", "glob", "walkdir"] }
 futures-util       = { version = "0.3.28" }

crates/cafs/src/lib.rs

@@ -36,11 +36,11 @@ fn content_path_from_hex(file_type: FileType, hex: &str) -> PathBuf {
     p.join(format!("{}{}", &hex[2..], extension))
 }
 
-pub fn write_sync<P: Into<PathBuf>>(store_dir: P, buffer: &Vec<u8>) -> Result<PathBuf, CafsError> {
+pub fn write_sync(store_dir: &Path, buffer: &Vec<u8>) -> Result<PathBuf, CafsError> {
     let hex_integrity =
         IntegrityOpts::new().algorithm(Algorithm::Sha512).chain(buffer).result().to_hex().1;
     let content_path = content_path_from_hex(FileType::NonExec, &hex_integrity);
-    let file_path = store_dir.into().join(&content_path);
+    let file_path = store_dir.join(&content_path);
 
     if !file_path.exists() {
         let parent_dir = file_path.parent().unwrap();
@@ -51,10 +51,10 @@ pub fn write_sync<P: Into<PathBuf>>(store_dir: P, buffer: &Vec<u8>) -> Result<Pa
     Ok(content_path)
 }
 
-pub fn prune_sync<P: Into<PathBuf>>(store_dir: P) -> Result<(), CafsError> {
+pub fn prune_sync(store_dir: &Path) -> Result<(), CafsError> {
     // TODO: This should remove unreferenced packages, not all packages.
     // Ref: https://pnpm.io/cli/store#prune
-    fs::remove_dir_all(store_dir.into())?;
+    fs::remove_dir_all(store_dir)?;
     Ok(())
 }
 

crates/cli/Cargo.toml

@@ -23,15 +23,17 @@ pacquet_registry     = { workspace = true }
 pacquet_tarball      = { workspace = true }
 pacquet_diagnostics  = { workspace = true }
 
-clap         = { workspace = true }
-futures-util = { workspace = true }
-rayon        = { workspace = true }
-reflink-copy = { workspace = true }
-reqwest      = { workspace = true }
-node-semver  = { workspace = true }
-serde        = { workspace = true }
-serde_json   = { workspace = true }
-tokio        = { workspace = true }
+async-recursion = { workspace = true }
+clap            = { workspace = true }
+futures-util    = { workspace = true }
+rayon           = { workspace = true }
+reflink-copy    = { workspace = true }
+reqwest         = { workspace = true }
+node-semver     = { workspace = true }
+pipe-trait      = { workspace = true }
+serde           = { workspace = true }
+serde_json      = { workspace = true }
+tokio           = { workspace = true }
 
 [dev-dependencies]
 insta             = { workspace = true }

crates/cli/src/commands/add.rs

@@ -55,6 +55,7 @@ impl PackageManager {
     /// 6. Update package.json
     pub async fn add(&mut self, args: &AddCommandArgs) -> Result<(), PackageManagerError> {
         let latest_version = fetch_package_version_directly(
+            &self.tarball_cache,
             &self.config,
             &self.http_client,
             &args.package,
@@ -72,7 +73,14 @@ impl PackageManager {
 
         let direct_dependency_handles =
             latest_version.dependencies(self.config.auto_install_peers).map(|(name, version)| {
-                find_package_version_from_registry(config, http_client, name, version, path)
+                find_package_version_from_registry(
+                    &self.tarball_cache,
+                    config,
+                    http_client,
+                    name,
+                    version,
+                    path,
+                )
             });
 
         queue.push_front(future::join_all(direct_dependency_handles).await);
@@ -90,11 +98,12 @@ impl PackageManager {
                 let handles = dependency.dependencies(self.config.auto_install_peers).map(
                     |(name, version)| {
                         find_package_version_from_registry(
+                            &self.tarball_cache,
                             config,
                             http_client,
                             name,
                             version,
-                            node_modules_path.to_owned(),
+                            &node_modules_path,
                         )
                     },
                 );

crates/cli/src/commands/install.rs

@@ -1,10 +1,12 @@
 use crate::package::find_package_version_from_registry;
 use crate::package_manager::{PackageManager, PackageManagerError};
+use async_recursion::async_recursion;
 use clap::Parser;
 use futures_util::future;
+use pacquet_diagnostics::tracing;
 use pacquet_package_json::DependencyGroup;
 use pacquet_registry::PackageVersion;
-use std::collections::VecDeque;
+use pipe_trait::Pipe;
 
 #[derive(Parser, Debug)]
 pub struct InstallCommandArgs {
@@ -40,49 +42,60 @@
 }
 
 impl PackageManager {
+    /// Install dependencies of a dependency.
+    ///
+    /// This function is used by [`PackageManager::install`].
+    #[async_recursion]
+    async fn install_dependencies(&self, package: &PackageVersion) {
+        let node_modules_path =
+            self.config.virtual_store_dir.join(package.to_store_name()).join("node_modules");
+
+        tracing::info!(target: "pacquet::install", node_modules = ?node_modules_path, "Start subset");
+
+        package
+            .dependencies(self.config.auto_install_peers)
+            .map(|(name, version)| async {
+                let dependency = find_package_version_from_registry(
+                    &self.tarball_cache,
+                    &self.config,
+                    &self.http_client,
+                    name,
+                    version,
+                    &node_modules_path,
+                )
+                .await
+                .unwrap();
+                self.install_dependencies(&dependency).await;
+            })
+            .pipe(future::join_all)
+            .await;
+
+        tracing::info!(target: "pacquet::install", node_modules = ?node_modules_path, "Complete subset");
+    }
+
+    /// Jobs of the `install` command.
     pub async fn install(&self, args: &InstallCommandArgs) -> Result<(), PackageManagerError> {
-        let config = &self.config;
-        let path = &self.config.modules_dir;
-        let http_client = &self.http_client;
-        let mut queue: VecDeque<Vec<PackageVersion>> = VecDeque::new();
+        tracing::info!(target: "pacquet::install", "Start all");
 
-        let direct_dependency_handles = self
-            .package_json
+        self.package_json
             .dependencies(args.dependency_groups())
             .map(|(name, version)| async move {
-                find_package_version_from_registry(config, http_client, name, version, path)
-                    .await
-                    .unwrap()
-            });
-
-        queue.push_front(future::join_all(direct_dependency_handles).await);
-
-        while let Some(dependencies) = queue.pop_front() {
-            for dependency in dependencies {
-                let node_modules_path = self
-                    .config
-                    .virtual_store_dir
-                    .join(dependency.to_store_name())
-                    .join("node_modules");
-
-                let handles = dependency.dependencies(self.config.auto_install_peers).map(
-                    |(name, version)| async {
-                        find_package_version_from_registry(
-                            config,
-                            http_client,
-                            name,
-                            version,
-                            &node_modules_path,
-                        )
-                        .await
-                        .unwrap()
-                    },
-                );
-
-                queue.push_back(future::join_all(handles).await);
-            }
-        }
-
+                let dependency = find_package_version_from_registry(
+                    &self.tarball_cache,
+                    &self.config,
+                    &self.http_client,
+                    name,
+                    version,
+                    &self.config.modules_dir,
+                )
+                .await
+                .unwrap();
+                self.install_dependencies(&dependency).await;
+            })
+            .pipe(future::join_all)
+            .await;
+
+        tracing::info!(target: "pacquet::install", "Complete all");
         Ok(())
     }
 }

crates/cli/src/fs.rs

@@ -1,12 +1,12 @@
 use std::{io, os, path::Path};
 
 #[cfg(unix)]
-pub fn symlink_dir<P: AsRef<Path>>(original: P, link: P) -> io::Result<()> {
+pub fn symlink_dir(original: &Path, link: &Path) -> io::Result<()> {
     os::unix::fs::symlink(original, link)
 }
 
 #[cfg(windows)]
-pub fn symlink_dir<P: AsRef<Path>>(original: P, link: P) -> io::Result<()> {
+pub fn symlink_dir(original: &Path, link: &Path) -> io::Result<()> {
     os::windows::fs::symlink_dir(original, link)
 }
 

crates/cli/src/lib.rs

@@ -11,14 +11,15 @@
 use clap::Parser;
 use pacquet_diagnostics::{
     enable_tracing_by_env,
-    miette::{IntoDiagnostic, Result, WrapErr},
+    miette::{set_panic_hook, IntoDiagnostic, Result, WrapErr},
 };
 use pacquet_executor::execute_shell;
 use pacquet_npmrc::current_npmrc;
 use pacquet_package_json::PackageJson;
 
 pub async fn run_cli() -> Result<()> {
     enable_tracing_by_env();
+    set_panic_hook();
     let cli = Cli::parse();
     run_commands(cli).await
 }