dependency kind enables component deps

Author: macovedj

crates/wasm-pkg-core/src/resolver.rs

@@ -30,6 +30,17 @@ use crate::{lock::LockFile, wit::get_packages};
 /// The name of the default registry.
 pub const DEFAULT_REGISTRY_NAME: &str = "default";
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum DependencyKind {
+    Component,
+    Wit,
+}
+
+impl Default for DependencyKind {
+    fn default() -> Self {
+        Self::Wit
+    }
+}
 // TODO: functions for resolving dependencies from a lock file
 
 /// Represents a WIT package dependency.
@@ -39,7 +50,7 @@ pub enum Dependency {
     Package(RegistryPackage),
 
     /// The dependency is a path to a local directory or file.
-    Local(PathBuf),
+    Local(PathBuf, DependencyKind),
 }
 
 impl Serialize for Dependency {
@@ -68,13 +79,14 @@ impl Serialize for Dependency {
                     .serialize(serializer)
                 }
             }
-            Self::Local(path) => {
+            Self::Local(path, kind) => {
                 #[derive(Serialize)]
                 struct Entry<'a> {
                     path: &'a PathBuf,
+                    kind: &'a DependencyKind,
                 }
 
-                Entry { path }.serialize(serializer)
+                Entry { path, kind }.serialize(serializer)
             }
         }
     }
@@ -112,30 +124,37 @@ impl<'de> Deserialize<'de> for Dependency {
                     package: Option<PackageRef>,
                     version: Option<VersionReq>,
                     registry: Option<String>,
+                    kind: DependencyKind,
                 }
 
                 let entry = Entry::deserialize(MapAccessDeserializer::new(map))?;
 
-                match (entry.path, entry.package, entry.version, entry.registry) {
-                    (Some(path), None, None, None) => Ok(Self::Value::Local(path)),
-                    (None, name, Some(version), registry) => {
+                match (
+                    entry.path,
+                    entry.package,
+                    entry.version,
+                    entry.registry,
+                    entry.kind,
+                ) {
+                    (Some(path), None, None, None, kind) => Ok(Self::Value::Local(path, kind)),
+                    (None, name, Some(version), registry, _) => {
                         Ok(Self::Value::Package(RegistryPackage {
                             name,
                             version,
                             registry,
                         }))
                     }
-                    (Some(_), None, Some(_), _) => Err(de::Error::custom(
+                    (Some(_), None, Some(_), _, _) => Err(de::Error::custom(
                         "cannot specify both `path` and `version` fields in a dependency entry",
                     )),
-                    (Some(_), None, None, Some(_)) => Err(de::Error::custom(
+                    (Some(_), None, None, Some(_), _) => Err(de::Error::custom(
                         "cannot specify both `path` and `registry` fields in a dependency entry",
                     )),
-                    (Some(_), Some(_), _, _) => Err(de::Error::custom(
+                    (Some(_), Some(_), _, _, _) => Err(de::Error::custom(
                         "cannot specify both `path` and `package` fields in a dependency entry",
                     )),
-                    (None, None, _, _) => Err(de::Error::missing_field("package")),
-                    (None, Some(_), None, _) => Err(de::Error::missing_field("version")),
+                    (None, None, _, _, _) => Err(de::Error::missing_field("package")),
+                    (None, Some(_), None, _, _) => Err(de::Error::missing_field("version")),
                 }
             }
         }
@@ -469,10 +488,8 @@ impl<'a> DependencyResolver<'a> {
         &mut self,
         name: &PackageRef,
         dependency: &Dependency,
-        is_wit: bool,
     ) -> Result<()> {
-        self.add_dependency_internal(name, dependency, false, is_wit)
-            .await
+        self.add_dependency_internal(name, dependency, false).await
     }
 
     /// Add a dependency to the resolver. If the dependency already exists, then it will be
@@ -481,18 +498,15 @@ impl<'a> DependencyResolver<'a> {
         &mut self,
         name: &PackageRef,
         dependency: &Dependency,
-        is_wit: bool,
     ) -> Result<()> {
-        self.add_dependency_internal(name, dependency, true, is_wit)
-            .await
+        self.add_dependency_internal(name, dependency, true).await
     }
 
     async fn add_dependency_internal(
         &mut self,
         name: &PackageRef,
         dependency: &Dependency,
         force_override: bool,
-        is_wit: bool,
     ) -> Result<()> {
         match dependency {
             Dependency::Package(package) => {
@@ -533,7 +547,7 @@ impl<'a> DependencyResolver<'a> {
                     },
                 );
             }
-            Dependency::Local(p) => {
+            Dependency::Local(p, kind) => {
                 // A local path dependency, insert a resolution immediately
                 let res = DependencyResolution::Local(LocalResolution {
                     name: name.clone(),
@@ -547,13 +561,15 @@ impl<'a> DependencyResolver<'a> {
 
                 // // Now that we check we haven't already inserted this dep, get the packages from the
                 // // local dependency and add those to the resolver before adding the dependency
-                if is_wit {
+                // if is_wit {
+                if kind == &DependencyKind::Wit {
                     let (_, packages) = get_packages(p)
                         .context("Error getting dependent packages from local dependency")?;
                     Box::pin(self.add_packages(packages))
                         .await
                         .context("Error adding packages to resolver for local dependency")?;
                 }
+                // }
 
                 let prev = self.resolutions.insert(name.clone(), res);
                 assert!(prev.is_none());
@@ -567,17 +583,16 @@ impl<'a> DependencyResolver<'a> {
     /// requirements to the resolver
     pub async fn add_packages(
         &mut self,
-        packages: impl IntoIterator<Item = (PackageRef, VersionReq, bool)>,
+        packages: impl IntoIterator<Item = (PackageRef, VersionReq)>,
     ) -> Result<()> {
-        for (package, req, is_wit) in packages {
+        for (package, req) in packages {
             self.add_dependency(
                 &package,
                 &Dependency::Package(RegistryPackage {
                     name: Some(package.clone()),
                     version: req,
                     registry: None,
                 }),
-                is_wit,
             )
             .await?;
         }

crates/wasm-pkg-core/src/wit.rs

@@ -15,8 +15,8 @@ use crate::{
     config::Config,
     lock::LockFile,
     resolver::{
-        DecodedDependency, Dependency, DependencyResolution, DependencyResolutionMap,
-        DependencyResolver, LocalResolution, RegistryPackage,
+        DecodedDependency, Dependency, DependencyKind, DependencyResolution,
+        DependencyResolutionMap, DependencyResolver, LocalResolution, RegistryPackage,
     },
 };
 
@@ -117,7 +117,7 @@ pub async fn fetch_dependencies(
 /// for resolving dependencies.
 pub fn get_packages(
     path: impl AsRef<Path>,
-) -> Result<(PackageRef, HashSet<(PackageRef, VersionReq, bool)>)> {
+) -> Result<(PackageRef, HashSet<(PackageRef, VersionReq)>)> {
     let group =
         wit_parser::UnresolvedPackageGroup::parse_path(path).context("Couldn't parse package")?;
 
@@ -137,7 +137,7 @@ pub fn get_packages(
     );
 
     // Get all package refs from the main package and then from any nested packages
-    let packages: HashSet<(PackageRef, VersionReq, bool)> =
+    let packages: HashSet<(PackageRef, VersionReq)> =
         packages_from_foreign_deps(group.main.foreign_deps.into_keys())
             .chain(
                 group
@@ -168,12 +168,12 @@ pub async fn resolve_dependencies(
             let dep = match (ovride.path.as_ref(), ovride.version.as_ref()) {
                 (Some(path), None) => {
                     let path = tokio::fs::canonicalize(path).await?;
-                    Dependency::Local(path)
+                    Dependency::Local(path, DependencyKind::Wit)
                 }
                 (Some(path), Some(_)) => {
                     tracing::warn!("Ignoring version override for local package");
                     let path = tokio::fs::canonicalize(path).await?;
-                    Dependency::Local(path)
+                    Dependency::Local(path, DependencyKind::Wit)
                 }
                 (None, Some(version)) => Dependency::Package(RegistryPackage {
                     name: Some(pkg.clone()),
@@ -186,7 +186,7 @@ pub async fn resolve_dependencies(
                 }
             };
             resolver
-                .add_dependency(&pkg, &dep, true)
+                .add_dependency(&pkg, &dep)
                 .await
                 .context("Unable to add dependency")?;
         }
@@ -289,7 +289,7 @@ pub async fn populate_dependencies(
 
 fn packages_from_foreign_deps(
     deps: impl IntoIterator<Item = PackageName>,
-) -> impl Iterator<Item = (PackageRef, VersionReq, bool)> {
+) -> impl Iterator<Item = (PackageRef, VersionReq)> {
     deps.into_iter().filter_map(|dep| {
         let name = PackageRef::new(dep.namespace.parse().ok()?, dep.name.parse().ok()?);
         let version = match dep.version {
@@ -301,7 +301,6 @@ fn packages_from_foreign_deps(
             version
                 .parse()
                 .expect("Unable to parse into version request, this is programmer error"),
-            true,
         ))
     })
 }