added overlay setyp

Author: mkatychev

crates/wasm-pkg-client/src/caching/file.rs

@@ -16,6 +16,7 @@ use crate::{ContentStream, Release};
 
 use super::Cache;
 
+#[derive(Clone)]
 pub struct FileCache {
     root: PathBuf,
 }

crates/wasm-pkg-client/src/caching/mod.rs

@@ -4,10 +4,11 @@ use std::sync::Arc;
 use wasm_pkg_common::{
     digest::ContentDigest,
     package::{PackageRef, Version},
+    registry::Registry,
     Error,
 };
 
-use crate::{Client, ContentStream, Release, VersionInfo};
+use crate::{Client, ContentStream, InnerClient, Release, VersionInfo};
 
 mod file;
 
@@ -45,20 +46,12 @@ pub trait Cache {
 
 /// A client that caches response data using the given cache implementation. Can be used without an
 /// underlying client to be used as a read-only cache.
+#[derive(Clone)]
 pub struct CachingClient<T> {
     pub client: Option<Client>,
     cache: Arc<T>,
 }
 
-impl<T: Cache> Clone for CachingClient<T> {
-    fn clone(&self) -> Self {
-        Self {
-            client: self.client.clone(),
-            cache: self.cache.clone(),
-        }
-    }
-}
-
 impl<T: Cache> CachingClient<T> {
     /// Creates a new caching client from the given client and cache implementation. If no client is
     /// given, the client will be in offline or read-only mode, meaning it will only be able to return
@@ -70,6 +63,16 @@ impl<T: Cache> CachingClient<T> {
         }
     }
 
+    async fn with_overlays(
+        mut self,
+        overlays: impl IntoIterator<Item = (Registry, Arc<InnerClient>)>,
+    ) -> Self {
+        if let Some(client) = &mut self.client {
+            client.overlays = overlays.into_iter().collect();
+        }
+        self
+    }
+
     /// Returns whether or not the client is in read-only mode.
     pub fn is_readonly(&self) -> bool {
         self.client.is_none()

crates/wasm-pkg-client/src/lib.rs

@@ -95,6 +95,8 @@ pub struct PublishOpts {
 pub struct Client {
     config: Arc<Config>,
     sources: Arc<RwLock<RegistrySources>>,
+    /// Mapping of sources to local registries that will be overlaid on them.
+    overlays: RegistrySources,
 }
 
 impl Client {
@@ -103,6 +105,20 @@ impl Client {
         Self {
             config: Arc::new(config),
             sources: Default::default(),
+            overlays: Default::default(),
+        }
+    }
+
+    /// Like [`Self::new`] but includes sources from source
+    /// replacement configurations.
+    pub fn new_with_overlays(
+        config: Config,
+        overlays: impl IntoIterator<Item = (Registry, Arc<InnerClient>)>,
+    ) -> Self {
+        Self {
+            config: Arc::new(config),
+            sources: Default::default(),
+            overlays: overlays.into_iter().collect(),
         }
     }
 

crates/wasm-pkg-common/src/config.rs

@@ -290,6 +290,16 @@ pub struct RegistryConfig {
 }
 
 impl RegistryConfig {
+    pub fn with_default_backend<T: Serialize>(
+        mut self,
+        default_backend: &str,
+        backend_config: T,
+    ) -> Result<Self, Error> {
+        self.default_backend = Some(default_backend.to_string());
+        self.set_backend_config("local", backend_config)?;
+        Ok(self)
+    }
+
     /// Merges the given other config into this one.
     pub fn merge(&mut self, other: Self) {
         let Self {

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

@@ -944,6 +944,59 @@ impl PublishPlan {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+    use std::path::PathBuf;
+
+    use super::PublishPlan;
+    use wasm_pkg_client::PackageRef;
+
+    fn transitive_local_paths() -> Vec<PathBuf> {
+        let fixtures =
+            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/transitive-local");
+        ["example-a", "example-b", "example-c"]
+            .into_iter()
+            .map(|name| fixtures.join(name).join("wit"))
+            .collect()
+    }
+
+    #[test]
+    fn publish_plan_from_paths_collects_all_packages() {
+        let paths = transitive_local_paths();
+        let plan = PublishPlan::from_paths(&paths).expect("plan should build");
+
+        assert!(!plan.is_empty());
+        assert_eq!(plan.len(), 3);
+
+        for name in ["example-a:foo", "example-b:bar", "example-c:baz"] {
+            let pkg: PackageRef = name.parse().expect("valid package ref");
+            assert!(
+                plan.get_path(&pkg).is_some(),
+                "expected `{name}` to have an associated path in the plan",
+            );
+        }
+    }
+
+    #[test]
+    fn publish_plan_iter_yields_each_package_once() {
+        let paths = transitive_local_paths();
+        let plan = PublishPlan::from_paths(&paths).expect("plan should build");
+
+        let seen: Vec<PackageRef> = plan.iter().map(|spec| spec.package.clone()).collect();
+        assert_eq!(seen.len(), 3, "iter should yield one entry per package");
+
+        let unique: HashSet<_> = seen.iter().cloned().collect();
+        assert_eq!(unique.len(), seen.len(), "iter must not yield duplicates");
+
+        let expected: HashSet<PackageRef> = ["example-a:foo", "example-b:bar", "example-c:baz"]
+            .into_iter()
+            .map(|s| s.parse().unwrap())
+            .collect();
+        assert_eq!(unique, expected);
+    }
+}
+
 /// Format a collection of packages as a list
 ///
 /// e.g. "foo:a@0.1.0, bar:b@0.2.0, and baz:c@0.3.0".

crates/wkg/src/main.rs

@@ -7,6 +7,7 @@ use tokio::io::AsyncWriteExt;
 use tracing::level_filters::LevelFilter;
 use wasm_pkg_client::{
     caching::{CachingClient, FileCache},
+    local::LocalConfig,
     Client, PackagePublisher, PublishOpts,
 };
 use wasm_pkg_common::{
@@ -252,8 +253,6 @@ struct PublishArgs {
 
 impl PublishArgs {
     pub async fn run(self) -> anyhow::Result<()> {
-        let mut client = self.common.get_client().await?;
-
         let package = match self.package {
             Some(_) if self.paths.len() > 2 => {
                 anyhow::bail!("`--package` is currently unsupported when providing more than one path argument");
@@ -271,35 +270,41 @@ impl PublishArgs {
         let path = match &self.paths[..] {
             [path] => path,
             paths => {
-                let (overlay, tmp_dir) = wasm_pkg_client::local::LocalBackend::temp_dir()?;
-                let local_backend = wasm_pkg_client::local::LocalConfig {
-                    root: tmp_dir.path().to_path_buf(),
-                };
-                let mut reg_config = RegistryConfig::default();
-                reg_config.set_default_backend(Some("local".to_owned()));
-                reg_config.set_backend_config("local", &local_backend)?;
-
-                let plan = PublishPlan::from_paths(paths)?;
-                let mut lock_file = LockFile::load(true).await?;
+                let mut config = self.common.load_config().await?;
+                let cache = self.common.load_cache().await?;
 
+                let (overlay, tmp_dir) = wasm_pkg_client::local::LocalBackend::temp_dir()?;
+                let reg_config = RegistryConfig::default().with_default_backend(
+                    "local",
+                    LocalConfig {
+                        root: tmp_dir.path().to_path_buf(),
+                    },
+                )?;
                 // Route every package in the plan to the local overlay registry
                 // backed by `reg_config`, so the client used in `build_wit_dir`
                 // resolves these packages against the local overlay instead of
                 // an upstream remote.
-                let mut config = self.common.load_config().await?;
-                let local_registry: Registry = "local".parse()?;
+                let local_registry: Registry = "tmp_local_publish".parse()?;
                 config
                     .get_or_insert_registry_config_mut(&local_registry)
                     .merge(reg_config);
+
+                let plan = PublishPlan::from_paths(paths)?;
+
+                // TODO(mkatychev): Add support for `PackageLoader::get_release` to handle
+                // querying on a per package, namespace, and registry level
+                // to handle cargo style overlays.
+                // see this reference of `cargo::core::Dependency` usage for local overlays in Cargo:
+                // https://github.com/rust-lang/cargo/blob/d6900d00af2644ea1c0068c5694d9dbe11a3ab39/src/cargo/sources/overlay.rs#L47
                 for spec in plan.iter() {
                     config.set_package_registry_override(
                         spec.package.clone(),
                         RegistryMapping::Registry(local_registry.clone()),
                     );
                 }
-                let cache = self.common.load_cache().await?;
                 let client = CachingClient::new(Some(Client::new(config)), cache);
 
+                let mut lock_file = LockFile::load(true).await?;
                 for spec in plan.iter_edges() {
                     let path = plan.get_path(&spec.package).unwrap();
                     let (publish_path, _tmp) = if path.is_dir() {
@@ -333,6 +338,8 @@ impl PublishArgs {
             }
         };
 
+        let client = self.common.get_client().await?;
+
         // If the input is a directory, build a WIT package from it into a temp
         // file first. _tmp is held until the publish completes so the file
         // isn't deleted out from under us.