enable cargo-component lock files

Author: macovedj

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

@@ -16,7 +16,7 @@ use tokio::{
 };
 use wasm_pkg_client::{ContentDigest, PackageRef};
 
-use crate::resolver::{DependencyResolution, DependencyResolutionMap};
+use crate::resolver::{DependencyResolution, DependencyResolutionMap, DEFAULT_REGISTRY_NAME};
 
 /// The default name of the lock file.
 pub const LOCK_FILE_NAME: &str = "wkg.lock";
@@ -271,6 +271,17 @@ pub struct LockedPackage {
     pub versions: Vec<LockedPackageVersion>,
 }
 
+impl LockedPackage {
+    /// Gets the key used in sorting and searching the package list.
+    pub fn key(&self) -> (&str, &str, &str) {
+        (
+            self.name.namespace().as_ref(),
+            self.name.name().as_ref(),
+            self.registry.as_deref().unwrap_or(DEFAULT_REGISTRY_NAME),
+        )
+    }
+}
+
 impl Ord for LockedPackage {
     fn cmp(&self, other: &Self) -> Ordering {
         if self.name == other.name {
@@ -298,6 +309,13 @@ pub struct LockedPackageVersion {
     pub digest: ContentDigest,
 }
 
+impl LockedPackageVersion {
+    /// Gets the sort key for the locked package version.
+    pub fn key(&self) -> String {
+        self.requirement.to_string()
+    }
+}
+
 #[derive(Debug, Deserialize)]
 struct LockFileIntermediate {
     version: u64,

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

@@ -13,6 +13,10 @@ use anyhow::{bail, Context, Result};
 use futures_util::TryStreamExt;
 use indexmap::{IndexMap, IndexSet};
 use semver::{Comparator, Op, Version, VersionReq};
+use serde::{
+    de::{self, value::MapAccessDeserializer},
+    Deserialize, Serialize,
+};
 use tokio::io::{AsyncRead, AsyncReadExt};
 use wasm_pkg_client::{
     caching::{CachingClient, FileCache},
@@ -38,6 +42,108 @@ pub enum Dependency {
     Local(PathBuf),
 }
 
+impl Serialize for Dependency {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Self::Package(package) => {
+                if package.name.is_none() && package.registry.is_none() {
+                    let version = package.version.to_string();
+                    version.trim_start_matches('^').serialize(serializer)
+                } else {
+                    #[derive(Serialize)]
+                    struct Entry<'a> {
+                        package: Option<&'a PackageRef>,
+                        version: &'a str,
+                        registry: Option<&'a str>,
+                    }
+
+                    Entry {
+                        package: package.name.as_ref(),
+                        version: package.version.to_string().trim_start_matches('^'),
+                        registry: package.registry.as_deref(),
+                    }
+                    .serialize(serializer)
+                }
+            }
+            Self::Local(path) => {
+                #[derive(Serialize)]
+                struct Entry<'a> {
+                    path: &'a PathBuf,
+                }
+
+                Entry { path }.serialize(serializer)
+            }
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Dependency {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> de::Visitor<'de> for Visitor {
+            type Value = Dependency;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "a string or a table")
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(Self::Value::Package(s.parse().map_err(de::Error::custom)?))
+            }
+
+            fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                #[derive(Default, Deserialize)]
+                #[serde(default, deny_unknown_fields)]
+                struct Entry {
+                    path: Option<PathBuf>,
+                    package: Option<PackageRef>,
+                    version: Option<VersionReq>,
+                    registry: Option<String>,
+                }
+
+                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) => {
+                        Ok(Self::Value::Package(RegistryPackage {
+                            name,
+                            version,
+                            registry,
+                        }))
+                    }
+                    (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(
+                        "cannot specify both `path` and `registry` fields in a dependency entry",
+                    )),
+                    (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")),
+                }
+            }
+        }
+
+        deserializer.deserialize_any(Visitor)
+    }
+}
+
 impl FromStr for Dependency {
     type Err = anyhow::Error;
 
@@ -363,8 +469,10 @@ impl<'a> DependencyResolver<'a> {
         &mut self,
         name: &PackageRef,
         dependency: &Dependency,
+        is_wit: bool,
     ) -> Result<()> {
-        self.add_dependency_internal(name, dependency, false).await
+        self.add_dependency_internal(name, dependency, false, is_wit)
+            .await
     }
 
     /// Add a dependency to the resolver. If the dependency already exists, then it will be
@@ -373,15 +481,18 @@ impl<'a> DependencyResolver<'a> {
         &mut self,
         name: &PackageRef,
         dependency: &Dependency,
+        is_wit: bool,
     ) -> Result<()> {
-        self.add_dependency_internal(name, dependency, true).await
+        self.add_dependency_internal(name, dependency, true, is_wit)
+            .await
     }
 
     async fn add_dependency_internal(
         &mut self,
         name: &PackageRef,
         dependency: &Dependency,
         force_override: bool,
+        is_wit: bool,
     ) -> Result<()> {
         match dependency {
             Dependency::Package(package) => {
@@ -434,13 +545,15 @@ impl<'a> DependencyResolver<'a> {
                     return Ok(());
                 }
 
-                // 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
-                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")?;
+                // // 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 {
+                    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());
@@ -454,16 +567,17 @@ impl<'a> DependencyResolver<'a> {
     /// requirements to the resolver
     pub async fn add_packages(
         &mut self,
-        packages: impl IntoIterator<Item = (PackageRef, VersionReq)>,
+        packages: impl IntoIterator<Item = (PackageRef, VersionReq, bool)>,
     ) -> Result<()> {
-        for (package, req) in packages {
+        for (package, req, is_wit) 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

@@ -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)>)> {
+) -> Result<(PackageRef, HashSet<(PackageRef, VersionReq, bool)>)> {
     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)> =
+    let packages: HashSet<(PackageRef, VersionReq, bool)> =
         packages_from_foreign_deps(group.main.foreign_deps.into_keys())
             .chain(
                 group
@@ -186,7 +186,7 @@ pub async fn resolve_dependencies(
                 }
             };
             resolver
-                .add_dependency(&pkg, &dep)
+                .add_dependency(&pkg, &dep, true)
                 .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)> {
+) -> impl Iterator<Item = (PackageRef, VersionReq, bool)> {
     deps.into_iter().filter_map(|dep| {
         let name = PackageRef::new(dep.namespace.parse().ok()?, dep.name.parse().ok()?);
         let version = match dep.version {
@@ -301,6 +301,7 @@ fn packages_from_foreign_deps(
             version
                 .parse()
                 .expect("Unable to parse into version request, this is programmer error"),
+            true,
         ))
     })
 }