Do not install wasm-pack for webpack projects

src/commands/build/mod.rs

@@ -3,9 +3,10 @@ pub mod wranglerjs;
 mod watch;
 pub use watch::watch_and_build;
 
+use crate::commands;
+use crate::install::install;
 use crate::settings::target::{Target, TargetType};
 use crate::terminal::message;
-use crate::{commands, install};
 
 use std::path::PathBuf;
 use std::process::Command;
@@ -18,7 +19,7 @@ pub fn build(target: &Target) -> Result<(), failure::Error> {
         }
         TargetType::Rust => {
             let tool_name = "wasm-pack";
-            let binary_path = install::install(tool_name, "rustwasm")?.binary(tool_name)?;
+            let binary_path = install(tool_name, "rustwasm")?.binary(tool_name)?;
             let args = ["build", "--target", "no-modules"];
 
             let command = command(&args, &binary_path);

src/commands/build/watch/mod.rs

@@ -3,10 +3,11 @@ use ignore::overrides::OverrideBuilder;
 use ignore::WalkBuilder;
 pub use watcher::wait_for_changes;
 
+use crate::commands;
 use crate::commands::build::{command, wranglerjs};
+use crate::install::install;
 use crate::settings::target::{Target, TargetType};
 use crate::terminal::message;
-use crate::{commands, install};
 
 use notify::{self, RecursiveMode, Watcher};
 use std::sync::mpsc;
@@ -52,7 +53,7 @@ pub fn watch_and_build(
         }
         TargetType::Rust => {
             let tool_name = "wasm-pack";
-            let binary_path = install::install(tool_name, "rustwasm")?.binary(tool_name)?;
+            let binary_path = install(tool_name, "rustwasm")?.binary(tool_name)?;
             let args = ["build", "--target", "no-modules"];
 
             thread::spawn(move || {

src/commands/build/wranglerjs/mod.rs

@@ -23,6 +23,7 @@ use crate::commands::build::watch::wait_for_changes;
 use crate::commands::build::watch::COOLDOWN_PERIOD;
 use crate::commands::publish::package::Package;
 use crate::install;
+use crate::install::install_artifact;
 use crate::settings::target::Target;
 use crate::terminal::message;
 use crate::util;
@@ -152,14 +153,9 @@ fn setup_build(target: &Target) -> Result<(Command, PathBuf, Bundle), failure::E
 
     let node = which::which("node").unwrap();
     let mut command = Command::new(node);
-    let wranglerjs_path = install().expect("could not install wranglerjs");
+    let wranglerjs_path = install_wranglerjs().expect("could not install wranglerjs");
     command.arg(wranglerjs_path);
 
-    // export WASM_PACK_PATH for use by wasm-pack-plugin
-    // https://github.com/wasm-tool/wasm-pack-plugin/blob/caca20df84782223f002735a8a2e99b2291f957c/plugin.js#L13
-    let wasm_pack_path = install::install("wasm-pack", "rustwasm")?.binary("wasm-pack")?;
-    command.env("WASM_PACK_PATH", wasm_pack_path);
-
     // create a temp file for IPC with the wranglerjs process
     let mut temp_file = env::temp_dir();
     temp_file.push(format!(".wranglerjs_output{}", random_chars(5)));
@@ -292,16 +288,17 @@ fn get_source_dir() -> PathBuf {
 }
 
 // Install {wranglerjs} from our GitHub releases
-fn install() -> Result<PathBuf, failure::Error> {
+fn install_wranglerjs() -> Result<PathBuf, failure::Error> {
     let wranglerjs_path = if install::target::DEBUG {
         let source_path = get_source_dir();
         let wranglerjs_path = source_path.join("wranglerjs");
         log::info!("wranglerjs at: {:?}", wranglerjs_path);
         wranglerjs_path
     } else {
         let tool_name = "wranglerjs";
+        let author = "cloudflare";
         let version = env!("CARGO_PKG_VERSION");
-        let wranglerjs_path = install::install_artifact(tool_name, "cloudflare", version)?;
+        let wranglerjs_path = install_artifact(tool_name, author, version)?;
         log::info!("wranglerjs downloaded at: {:?}", wranglerjs_path.path());
         wranglerjs_path.path()
     };

src/commands/generate/mod.rs

@@ -1,9 +1,10 @@
 use std::path::PathBuf;
 use std::process::Command;
 
+use crate::commands;
 use crate::commands::validate_worker_name;
+use crate::install::install;
 use crate::settings::target::{Manifest, Site, TargetType};
-use crate::{commands, install};
 
 pub fn generate(
     name: &str,
@@ -31,7 +32,7 @@ pub fn generate(
 
 pub fn run_generate(name: &str, template: &str) -> Result<(), failure::Error> {
     let tool_name = "cargo-generate";
-    let binary_path = install::install(tool_name, "ashleygwilliams")?.binary(tool_name)?;
+    let binary_path = install(tool_name, "ashleygwilliams")?.binary(tool_name)?;
 
     let args = ["generate", "--git", template, "--name", name, "--force"];
 

tests/build.rs

@@ -8,7 +8,7 @@ use std::str;
 use std::sync::Mutex;
 
 use assert_cmd::prelude::*;
-use fixture::Fixture;
+use fixture::{rust, Fixture};
 
 lazy_static! {
     static ref BUILD_LOCK: Mutex<u8> = Mutex::new(0);
@@ -332,6 +332,67 @@ fn it_builds_with_webpack_target_webworker() {
     build_creates_assets(fixture, vec!["script.js"]);
 }
 
+#[test]
+fn it_builds_with_webpack_wasm_pack() {
+    let fixture = Fixture::new("webpack_wasm_pack");
+
+    fixture.create_dir("crate");
+    fixture.create_file("crate/Cargo.toml", &rust::get_cargo_toml());
+
+    fixture.create_dir("crate/src");
+    fixture.create_file("crate/src/lib.rs", &rust::get_lib());
+    fixture.create_file("crate/src/utils.rs", &rust::get_utils());
+
+    fixture.create_wrangler_toml(
+        r#"
+        type = "webpack"
+        webpack_config = "webpack.config.js"
+    "#,
+    );
+
+    fixture.create_file(
+        "webpack.config.js",
+        r#"
+        const path = require("path");
+        const WasmPackPlugin = require("@wasm-tool/wasm-pack-plugin");
+
+        module.exports = {
+            "entry": "./index.js",
+            "target": "webworker",
+            plugins: [
+                new WasmPackPlugin({
+                    crateDirectory: path.resolve(__dirname, "crate"),
+                }),
+            ]
+        }
+    "#,
+    );
+
+    fixture.create_file(
+        "package.json",
+        r#"
+        {
+            "name": "webpack_wasm_pack",
+            "main": "./index.js",
+            "dependencies": {
+            "@wasm-tool/wasm-pack-plugin": "^1.0.1"
+            }
+        }
+    "#,
+    );
+
+    fixture.create_file(
+        "index.js",
+        r#"
+        import("./crate/pkg/index.js").then(module => {
+            module.greet();
+        });
+        "#,
+    );
+
+    build_creates_assets(fixture, vec!["script.js", "module.wasm"]);
+}
+
 fn build_creates_assets(fixture: Fixture, script_names: Vec<&str>) {
     // Lock to avoid having concurrent builds
     let _g = BUILD_LOCK.lock().unwrap();

tests/fixture/mod.rs

@@ -1,3 +1,5 @@
+pub mod rust;
+
 use std::env;
 use std::fs;
 use std::fs::File;

tests/fixture/rust.rs

@@ -0,0 +1,91 @@
+pub fn get_lib() -> String {
+    return r#"
+        extern crate cfg_if;
+        extern crate wasm_bindgen;
+
+        mod utils;
+
+        use cfg_if::cfg_if;
+        use wasm_bindgen::prelude::*;
+
+        cfg_if! {
+            // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
+            // allocator.
+            if #[cfg(feature = "wee_alloc")] {
+                extern crate wee_alloc;
+                #[global_allocator]
+                static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+            }
+        }
+
+        #[wasm_bindgen]
+        pub fn greet() -> String {
+            "Hello, wasm-worker!".to_string()
+        }
+    "#
+    .to_string();
+}
+
+pub fn get_utils() -> String {
+    return r#"
+    use cfg_if::cfg_if;
+
+    cfg_if! {
+        // When the `console_error_panic_hook` feature is enabled, we can call the
+        // `set_panic_hook` function at least once during initialization, and then
+        // we will get better error messages if our code ever panics.
+        //
+        // For more details see
+        // https://github.com/rustwasm/console_error_panic_hook#readme
+        if #[cfg(feature = "console_error_panic_hook")] {
+            extern crate console_error_panic_hook;
+            pub use self::console_error_panic_hook::set_once as set_panic_hook;
+        } else {
+            #[inline]
+            pub fn set_panic_hook() {}
+        }
+    }
+    "#
+    .to_string();
+}
+
+pub fn get_cargo_toml() -> String {
+    return r#"
+    [package]
+    name = "worker"
+    version = "0.1.0"
+    authors = ["The Wrangler Team <[email protected]>"]
+    edition = "2018"
+
+    [lib]
+    crate-type = ["cdylib", "rlib"]
+
+    [features]
+    default = ["console_error_panic_hook"]
+
+    [dependencies]
+    cfg-if = "0.1.2"
+    wasm-bindgen = "0.2"
+
+    # The `console_error_panic_hook` crate provides better debugging of panics by
+    # logging them with `console.error`. This is great for development, but requires
+    # all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+    # code size when deploying.
+    console_error_panic_hook = { version = "0.1.1", optional = true }
+
+    # `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
+    # compared to the default allocator's ~10K. It is slower than the default
+    # allocator, however.
+    #
+    # Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
+    wee_alloc = { version = "0.4.2", optional = true }
+
+    [dev-dependencies]
+    wasm-bindgen-test = "0.2"
+
+    [profile.release]
+    # Tell `rustc` to optimize for small code size.
+    opt-level = "s" 
+    "#
+    .to_string();
+}