Automatically install missing dependencies, part 2

src/Bundler.js

@@ -16,6 +16,7 @@ const config = require('./utils/config');
 const emoji = require('./utils/emoji');
 const loadEnv = require('./utils/env');
 const PromiseQueue = require('./utils/PromiseQueue');
+const installPackage = require('./utils/installPackage');
 const bundleReport = require('./utils/bundleReport');
 const prettifyTime = require('./utils/prettifyTime');
 
@@ -93,10 +94,11 @@ class Bundler extends EventEmitter {
       rootDir: Path.dirname(this.mainFile),
       sourceMaps:
         typeof options.sourceMaps === 'boolean' ? options.sourceMaps : true,
-      hmrHostname:
-        options.hmrHostname ||
+      hmrHostname: options.hmrHostname ||
         (options.target === 'electron' ? 'localhost' : ''),
-      detailedReport: options.detailedReport || false
+      detailedReport: options.detailedReport || false,
+      autoinstall: (options.autoinstall || false) && !isProduction,
+      packageManager: options.packageManager
     };
   }
 
@@ -332,31 +334,55 @@ class Bundler extends EventEmitter {
       let thrown = err;
 
       if (thrown.message.indexOf(`Cannot find module '${dep.name}'`) === 0) {
-        if (dep.optional) {
-          return;
-        }
-
-        thrown.message = `Cannot resolve dependency '${dep.name}'`;
+        // Check if dependency is a local file
+        let isLocalFile = /^[/~.]/.test(dep.name);
 
-        // Add absolute path to the error message if the dependency specifies a relative path
-        if (dep.name.startsWith('.')) {
-          const absPath = Path.resolve(Path.dirname(asset.name), dep.name);
-          err.message += ` at '${absPath}'`;
+        // If it's not a local file, attempt to install the dep
+        if (!isLocalFile && this.options.autoinstall) {
+          let dir = Path.dirname(asset.name);
+          return await this.installDep(dep, dir);
         }
 
-        // Generate a code frame where the dependency was used
-        if (dep.loc) {
-          await asset.loadIfNeeded();
-          thrown.loc = dep.loc;
-          thrown = asset.generateErrorMessage(thrown);
+        // If the dep is optional, return before we throw
+        if (dep.optional) {
+          return;
         }
 
-        thrown.fileName = asset.name;
+        thrown = await Bundler.generateDepError(asset, dep, thrown);
       }
       throw thrown;
     }
   }
 
+  async installDep(dep, dir) {
+    logger.status(emoji.progress, `Installing ${dep.name}...`);
+
+    await installPackage({
+      dir,
+      modules: [dep.name],
+      installPeers: false,
+      saveDev: false,
+      packageManager: this.options.packageManager
+    });
+
+    return await this.resolveAsset(dep.name, dir);
+  }
+
+  static async generateDepError(asset, dep, err) {
+    // Set the error message
+    err.message = `Cannot resolve dependency '${dep.name}'`;
+
+    // Generate a code frame where the dependency was used
+    if (dep.loc) {
+      await asset.loadIfNeeded();
+      err.loc = dep.loc;
+      err = asset.generateErrorMessage(err);
+    }
+    err.fileName = asset.name;
+
+    return err;
+  }
+
   async processAsset(asset, isRebuild) {
     if (isRebuild) {
       asset.invalidate();

src/cli.js

@@ -39,6 +39,12 @@ program
   .option('--no-hmr', 'disable hot module replacement')
   .option('--no-cache', 'disable the filesystem cache')
   .option('--no-source-maps', 'disable sourcemaps')
+  .option('--no-autoinstall', 'disable autoinstall')
+  .option(
+    '-m, --package-manager <packageManager>',
+    'set the package manger for autoinstall (npm or yarn)',
+    /^(npm|yarn)$/
+  )
   .option(
     '-t, --target [target]',
     'set the runtime environment, either "node", "browser" or "electron". defaults to "browser"',
@@ -74,6 +80,12 @@ program
   .option('--no-hmr', 'disable hot module replacement')
   .option('--no-cache', 'disable the filesystem cache')
   .option('--no-source-maps', 'disable sourcemaps')
+  .option('--no-autoinstall', 'disable autoinstall')
+  .option(
+    '-m, --package-manager <packageManager>',
+    'set the package manger for autoinstall (npm or yarn)',
+    /^(npm|yarn)$/
+  )
   .option(
     '-t, --target [target]',
     'set the runtime environment, either "node", "browser" or "electron". defaults to "browser"',

src/utils/config.js

@@ -9,8 +9,6 @@ const PARSERS = {
 const existsCache = new Map();
 
 async function resolve(filepath, filenames, root = path.parse(filepath).root) {
-  filepath = path.dirname(filepath);
-
   // Don't traverse above the module root
   if (filepath === root || path.basename(filepath) === 'node_modules') {
     return null;
@@ -27,7 +25,9 @@ async function resolve(filepath, filenames, root = path.parse(filepath).root) {
     }
   }
 
-  return resolve(filepath, filenames, root);
+  let prevDirFilepath = path.dirname(filepath);
+
+  return resolve(prevDirFilepath, filenames, root);
 }
 
 async function load(filepath, filenames, root = path.parse(filepath).root) {

src/utils/installPackage.js

@@ -1,55 +1,32 @@
 const spawn = require('cross-spawn');
 const config = require('./config');
-const path = require('path');
 const promisify = require('./promisify');
 const resolve = promisify(require('resolve'));
+const commandExists = require('command-exists');
+const logger = require('../Logger');
 
-async function install(dir, modules, installPeers = true) {
-  let location = await config.resolve(dir, ['yarn.lock', 'package.json']);
+async function install(configObj) {
+  let {
+    dir: cwd,
+    modules,
+    installPeers = true,
+    saveDev = true,
+    packageManager
+  } = configObj;
 
-  return new Promise((resolve, reject) => {
-    let install;
-    let options = {
-      cwd: location ? path.dirname(location) : dir
-    };
-
-    if (location && path.basename(location) === 'yarn.lock') {
-      install = spawn('yarn', ['add', ...modules, '--dev'], options);
-    } else {
-      install = spawn('npm', ['install', ...modules, '--save-dev'], options);
-    }
-
-    install.stdout.pipe(process.stdout);
-    install.stderr.pipe(process.stderr);
-
-    install.on('close', async code => {
-      if (code !== 0) {
-        return reject(new Error(`Failed to install ${modules.join(', ')}.`));
-      }
-
-      if (!installPeers) {
-        return resolve();
-      }
+  packageManager = packageManager || (await determinePackageManager(cwd));
+  let commandToUse = packageManager === 'npm' ? 'install' : 'add';
+  let args = [commandToUse, ...modules, saveDev ? '-D' : null];
 
-      try {
-        await Promise.all(modules.map(m => installPeerDependencies(dir, m)));
-      } catch (err) {
-        return reject(
-          new Error(
-            `Failed to install peerDependencies for ${modules.join(', ')}.`
-          )
-        );
-      }
+  await run(packageManager, args, {cwd});
 
-      resolve();
-    });
-  });
+  if (installPeers) {
+    await Promise.all(modules.map(m => installPeerDependencies(cwd, m)));
+  }
 }
 
 async function installPeerDependencies(dir, name) {
-  let basedir = path.dirname(dir);
-
-  const [resolved] = await resolve(name, {basedir});
+  const [resolved] = await resolve(name, {basedir: dir});
   const pkg = await config.load(resolved, ['package.json']);
   const peers = pkg.peerDependencies || {};
 
@@ -59,8 +36,54 @@ async function installPeerDependencies(dir, name) {
   }
 
   if (modules.length) {
-    await install(dir, modules, false);
+    await install({dir, modules, installPeers: false});
+  }
+}
+
+async function determinePackageManager(cwd) {
+  let yarnLockFile = await config.resolve(cwd, ['yarn.lock']);
+  let yarnCommandExists = await checkForYarnCommand();
+
+  // If the yarn command exists and we find a yarn lockfile, use yarn
+  if (yarnCommandExists) {
+    if (yarnLockFile) {
+      return 'yarn';
+    } else {
+      logger.warn(
+        "Using NPM instead of Yarn. No 'yarn.lock' found in project directory, use the --package-manager flag to explicitly specify which package manager to use."
+      );
+    }
+  }
+
+  return 'npm';
+}
+
+async function checkForYarnCommand() {
+  try {
+    return await commandExists('yarn');
+  } catch (err) {
+    return false;
   }
 }
 
+function run(...args) {
+  return new Promise((resolve, reject) => {
+    // Spawn the process
+    let childProcess = spawn(...args);
+
+    // Setup outputs
+    childProcess.stdout.pipe(process.stdout);
+    childProcess.stderr.pipe(process.stderr);
+
+    // Resolve the promise when the process finishes
+    childProcess.on('close', statusCode => {
+      if (statusCode === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Install failure: ${args}`));
+      }
+    });
+  });
+}
+
 module.exports = install;

src/utils/localRequire.js

@@ -13,7 +13,7 @@ async function localRequire(name, path, triedInstall = false) {
       resolved = resolve.sync(name, {basedir});
     } catch (e) {
       if (e.code === 'MODULE_NOT_FOUND' && !triedInstall) {
-        await install(path, [name]);
+        await install({dir: basedir, modules: [name]});
         return localRequire(name, path, true);
       }
       throw e;

test/autoinstall.js

@@ -0,0 +1,56 @@
+const assert = require('assert');
+const install = require('../src/utils/installPackage');
+const fs = require('fs');
+const rimraf = require('rimraf');
+const promisify = require('../src/utils/promisify');
+const primraf = promisify(rimraf);
+const ncp = promisify(require('ncp'));
+const inputDirPath = __dirname + '/input';
+
+describe('autoinstall', function() {
+  beforeEach(async function() {
+    // Setup (clear the input dir and move integration test in)
+    await primraf(inputDirPath, {});
+    await ncp(__dirname + '/integration/babel-default', inputDirPath);
+  });
+
+  it('should install lodash using npm and save dev dependency to package.json', async function() {
+    let pkgName = 'lodash';
+
+    await install({
+      dir: inputDirPath,
+      modules: [pkgName],
+      saveDev: true,
+      packageManager: 'npm'
+    });
+
+    let expectedModulePath = inputDirPath + '/node_modules/' + pkgName;
+    assert(fs.existsSync(expectedModulePath), 'lodash is in node_modules');
+
+    let pkg = fs.readFileSync(inputDirPath + '/package.json');
+    pkg = JSON.parse(pkg);
+    assert(pkg.devDependencies[pkgName], 'lodash is saved as a dev dep');
+  });
+
+  it('should install lodash using yarn and save dev dependency to package.json', async function() {
+    let pkgName = 'lodash';
+
+    await install({
+      dir: inputDirPath,
+      modules: [pkgName],
+      saveDev: true,
+      packageManager: 'yarn'
+    });
+
+    let expectedModulePath = inputDirPath + '/node_modules/' + pkgName;
+    assert(fs.existsSync(expectedModulePath), 'lodash is in node_modules');
+
+    let pkg = fs.readFileSync(inputDirPath + '/package.json');
+    pkg = JSON.parse(pkg);
+    assert(pkg.devDependencies[pkgName], 'lodash is saved as a dev dep');
+  });
+
+  afterEach(async function() {
+    await primraf(inputDirPath);
+  });
+});