Added binary resolver.

Author: SamTV12345

Cargo.lock

@@ -16,6 +16,7 @@ async-trait = "0.1.75"
 async-recursion = "1.0.5"
 homedir = "0.3.3"
 serde_yaml_ng = "0.10.0"
+path-clean = "1.0.1"
 
 serde = { version = "1.0.193", features = ["derive"] }
 serde_json = "1.0.108"

Cargo.toml

@@ -1,10 +1,7 @@
 {
   "type": "module",
   "dependencies": {
-    "is-even": "^1.0.0"
-  },
-  "devDependencies": {
-    "eslint": "^7.2.0"
+    "typescript": "^5.6.2"
   },
   "scripts": {
     "start": "node"

package.json

@@ -0,0 +1,108 @@
+use std::sync::mpsc::Sender;
+use async_trait::async_trait;
+use crate::cache::RegistryKey;
+use crate::contracts::{Pipe, PipeArtifact};
+use crate::errors::ExecutionError;
+use crate::package::{BinType, PackageMetaRecorder, PackageRecorder, ResolvedBinary};
+
+pub struct PeerResolver {
+    recorder: PackageRecorder
+}
+
+impl PeerResolver {
+    pub fn new(recorder: PackageRecorder) -> Self {
+        PeerResolver {
+            recorder
+        }
+    }
+
+    fn handle_insert( req: &mut PackageMetaRecorder, outer_dep: (&RegistryKey, &PackageMetaRecorder)) {
+        match &mut req.resolved_dependencies {
+            Some(deps) => {
+                deps.insert(outer_dep.0.name.clone(), outer_dep.0
+                    .version.clone());
+            }
+            None => {
+                let mut deps = std::collections::HashMap::new();
+                deps.insert(outer_dep.0.name.clone(), outer_dep.0.version.clone());
+                req.resolved_dependencies = Some(deps)
+            }
+        }
+        if let Some(bin) = &outer_dep.1.bin {
+            match &mut req.resolved_binaries {
+                Some(b) => {
+                    match bin {
+                        BinType::Bin(s) => {
+                            let splitted_name = s.rsplitn(2, '/').next().unwrap().replace(".js", "");
+                            b.push(ResolvedBinary{
+                                name: splitted_name,
+                                path: format!("{}/{}", outer_dep.1.name, s),
+                                package_name: outer_dep.1.name.clone()
+                            });
+                        }
+                        BinType::BinMappings(a) => {
+                            a.iter().for_each(|s| {
+                                b.push(ResolvedBinary{
+                                    name: s.0.to_string(),
+                                    path: format!("{}/{}", outer_dep.1.name, s.1),
+                                    package_name: outer_dep.1.name.clone()
+                                });
+                            });
+                        }
+                    }
+                }
+                None => {
+                    match bin {
+                        BinType::Bin(s) => {
+                            let splitted_name = s.rsplitn(2, '/').next().unwrap().replace("\
+                                .js", "");
+                            let vec = vec![ResolvedBinary{
+                                name: splitted_name,
+                                path: format!("{}/{}", outer_dep.1.name, s),
+                                package_name: outer_dep.1.name.clone()
+                            }];
+                            req.resolved_binaries = Some(vec);
+                        }
+                        BinType::BinMappings(a) => {
+                            let mut bin_vec = vec![];
+                            a.iter().for_each(|s| {
+                                bin_vec.push(ResolvedBinary{
+                                    name: s.0.to_string(),
+                                    path: format!("{}/{}", outer_dep.1.name, s.1),
+                                    package_name: outer_dep.1.name.clone()
+                                });
+                            });
+                            req.resolved_binaries = Some(bin_vec);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl Pipe<PackageRecorder> for PeerResolver {
+    async fn run(&mut self) -> Result<PackageRecorder, ExecutionError> {
+       self.recorder.sub_dependencies.clone().iter().for_each(|outer_dep|{
+           if let Some(mut deps) = outer_dep.1.depth_traces.clone() {
+               // Iterate over the traces
+                deps.iter_mut().for_each(|mut d|{
+                     d.reverse();
+                    for (i, parent_of_outer_dep) in d.iter().enumerate() {
+                        // This is a direct parent
+                        if i == 0 {
+                           if let Some(reg) = self.recorder.sub_dependencies.get_mut(parent_of_outer_dep) {
+                               PeerResolver::handle_insert(reg, outer_dep);
+                           } else if let Some(req) = self.recorder.main_packages.get_mut
+                           (parent_of_outer_dep) {
+                                 PeerResolver::handle_insert(req, outer_dep);
+                           }
+                        }
+                    }
+                })
+           }
+       });
+        Ok(self.recorder.clone())
+    }
+}

src/actors/PeerResolver.rs

@@ -15,7 +15,7 @@ use crate::{
     pipeline::{DownloaderPipe, ExtractorPipe, LinkerPipe, ResolverPipe},
     ui::UIProgress,
 };
-use crate::pipeline::BinaryLinkerPipeline;
+use crate::actors::PeerResolver::PeerResolver;
 
 #[derive(Debug, Clone)]
 pub enum PackageType {
@@ -106,6 +106,14 @@ impl Actor<PipeResult> for InstallActor {
             resolve_artifacts.0.get_artifacts().len()
         ));
 
+
+        // ─── Start Mutating ───────────────────────
+        let recorder = PeerResolver::new(resolve_artifacts.1)
+            .run()
+            .await?;
+
+
+
         // ─── Start Downloading ──────────────────────
 
         CraftLogger::verbose("Downloading dependencies");
@@ -118,6 +126,8 @@ impl Actor<PipeResult> for InstallActor {
             download_artifacts.get_artifacts().len()
         ));
 
+
+
         // ─── Start Extracting ───────────────────────
 
         CraftLogger::verbose("Extracting dependencies");
@@ -137,12 +147,14 @@ impl Actor<PipeResult> for InstallActor {
             tx.clone(),
             resolve_artifacts.0.get_artifacts(),
             extracted_artifacts.get_artifacts(),
+            recorder.clone()
         )
         .run()
         .await?;
 
+
         // ─── Sync Lock File ────────────────────────
-        LockFileActor::new(resolve_artifacts.0.get_artifacts(), resolve_artifacts.1.clone())
+        LockFileActor::new(resolve_artifacts.0.get_artifacts(), recorder)
             .run()
             .expect("Error writing lockfile");
 
@@ -152,7 +164,6 @@ impl Actor<PipeResult> for InstallActor {
 
 
         // ─── Link binaries ────────────────────────────────
-        let bin_linker = BinaryLinkerPipeline::new(resolve_artifacts.1.main_packages);
 
 
         drop(tx);

src/actors/install.rs

@@ -2,6 +2,7 @@ mod cache_clean;
 mod install;
 mod preprocesse_dependency_install;
 mod run;
+mod PeerResolver;
 
 pub use cache_clean::CacheCleanActor;
 pub use install::InstallActor;

src/actors/mod.rs

@@ -5,9 +5,10 @@ use async_trait::async_trait;
 use nodejs_semver::{Range, Version};
 use std::fmt::Display;
 use std::{collections::HashMap, fs::File, io, path::PathBuf};
+use serde::{Deserialize, Serialize};
 
 //
-#[derive(Eq, Debug, Hash, PartialEq, Clone)]
+#[derive(Eq, Debug, Hash, PartialEq, Clone, Serialize, Deserialize)]
 pub struct RegistryKey {
     pub name: String,
     pub version: String,

src/cache/registry.rs

@@ -177,13 +177,13 @@ impl LockFileActor {
         let mut hashmap: HashMap<String, PackageMetaHandler> = HashMap::new();
 
         self.recorder.main_packages.iter().for_each(|p| {
-            let pm_handler: PackageMetaHandler = p.clone().into();
-            hashmap.insert(p.to_string(), pm_handler);
+            let pm_handler: PackageMetaHandler = p.1.clone().into();
+            hashmap.insert(p.0.to_string(), pm_handler);
         });
 
         self.recorder.sub_dependencies.iter().for_each(|p| {
-            let pm_handler: PackageMetaHandler = p.clone().into();
-            hashmap.insert(p.to_string(), pm_handler);
+            let pm_handler: PackageMetaHandler = p.1.clone().into();
+            hashmap.insert(p.0.to_string(), pm_handler);
         });
 
         lockfile_structure.packages = Some(hashmap)

src/lockfile/lock_file_actor.rs

@@ -14,4 +14,5 @@ pub use package_recorder::PackageMetaHandler;
 pub use package_recorder::PackageRecorder;
 pub use pkg::Package;
 pub use npm_package::BinType;
-pub use package_recorder::PackageMetaRecorder;
+pub use package_recorder::PackageMetaRecorder;
+pub use package_recorder::ResolvedBinary;

src/package/mod.rs

@@ -69,6 +69,8 @@ pub struct NpmPackage {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub workspaces: Option<Vec<String>>,
     pub dist: Distribution,
+    #[serde(skip_serializing)]
+    pub depth_traces: Option<Vec<Vec<RegistryKey>>>
 }
 
 #[derive(Deserialize, Serialize, Debug, Clone)]
@@ -109,6 +111,7 @@ impl From<NpmPackage> for PackageMetaRecorder {
             engines: val.engines,
             os: val.os,
             bin: val.bin.clone(),
+            depth_traces: val.depth_traces,
             ..Default::default()
         };
 

src/package/npm_package.rs

@@ -2,6 +2,9 @@ use crate::package::npm_package::{EnginesType, PeerDependencyMeta};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fmt::{Display, Formatter};
+use std::path::PathBuf;
+use crate::cache::{RegistryKey, DEP_CACHE_FOLDER};
+use crate::fs::get_config_dir;
 use crate::package::BinType;
 
 #[derive(Clone, Default, Debug)]
@@ -17,9 +20,29 @@ pub struct PackageMetaRecorder {
     pub os: Option<Vec<String>>,
     pub dependencies: Option<HashMap<String, String>>,
     pub resolved_dependencies: Option<HashMap<String, String>>,
-    pub bin: Option<BinType>
+    pub bin: Option<BinType>,
+    pub depth_traces: Option<Vec<Vec<RegistryKey>>>,
+    pub resolved_binaries: Option<Vec<ResolvedBinary>>,
+    // This involves transitive dependencies
+    pub resolved_peer_dependencies: Option<HashMap<String, String>>,
 }
 
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+pub struct ResolvedBinary {
+    pub name: String,
+    pub path: String,
+    pub package_name: String,
+}
+
+impl PackageMetaRecorder {
+    pub fn resolve_path_to_package(&self) -> PathBuf {
+        get_config_dir(DEP_CACHE_FOLDER.clone())
+            .join(format!("{}-{}", self.name, self.version))
+            .join("package")
+    }
+}
+
+
 impl Display for PackageMetaRecorder {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}@{}", self.name, self.version)
@@ -38,7 +61,10 @@ impl From<PackageMetaRecorder> for PackageMetaHandler {
             peer_dependencies_meta: val.peer_dependencies_meta,
             dependencies: val.dependencies,
             resolved_dependencies: val.resolved_dependencies,
-            bin: val.bin
+            bin: val.bin,
+            depth_traces: val.depth_traces,
+            resolved_binaries: val.resolved_binaries,
+            resolved_peer_dependencies: val.resolved_peer_dependencies
         }
     }
 }
@@ -62,11 +88,16 @@ pub struct PackageMetaHandler {
     pub os: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub dependencies: Option<HashMap<String, String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing)]
     pub resolved_dependencies: Option<HashMap<String, String>>,
+    #[serde(skip_serializing)]
+    pub resolved_peer_dependencies: Option<HashMap<String, String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub bin: Option<BinType>
-
+    pub bin: Option<BinType>,
+    #[serde(skip_serializing)]
+    pub resolved_binaries: Option<Vec<ResolvedBinary>>,
+    #[serde(skip_serializing)]
+    pub depth_traces: Option<Vec<Vec<RegistryKey>>>
 }
 
 #[derive(Clone, Default, Debug, Deserialize, Serialize)]
@@ -76,6 +107,6 @@ pub struct PackageResolution {
 
 #[derive(Clone, Default, Debug)]
 pub struct PackageRecorder {
-    pub main_packages: Vec<PackageMetaRecorder>,
-    pub sub_dependencies: Vec<PackageMetaRecorder>,
+    pub main_packages: HashMap<RegistryKey,PackageMetaRecorder>,
+    pub sub_dependencies: HashMap<RegistryKey,PackageMetaRecorder>,
 }

src/package/package_recorder.rs

@@ -51,13 +51,11 @@ impl ExtractArtifacts {
     }
 
     pub fn add(&mut self, package: NpmPackage, unzip_at: PathBuf) {
-        let name = format!("{}@{}", package.name.clone(), package.version.clone());
         let item = ExtractArtifactItem::new(package.clone(), unzip_at);
 
-        self.tmp_cache.insert(name, item);
+        self.tmp_cache.insert(package.to_string(), item);
     }
 
-    #[cfg(test)]
     pub fn get(&self, package_name: &str) -> Option<&ExtractArtifactItem> {
         self.tmp_cache.get(package_name)
     }