ember-try 3.0.0 → 5.0.0

package/lib/dependency-manager-adapters/npm.js

@@ -1,295 +1,11 @@
 'use strict';
 
-const CoreObject = require('core-object');
-const fs = require('fs-extra');
-const util = require('util');
-const copy = util.promisify(fs.copy);
-const path = require('path');
-const debug = require('debug')('ember-try:dependency-manager-adapter:npm');
-const rimraf = util.promisify(require('rimraf'));
-const chalk = require('chalk');
-const semver = require('semver');
-
-module.exports = CoreObject.extend({
-  init() {
-    this._super.apply(this, arguments);
-    this.run = this.run || require('../utils/run');
-  },
-  useYarnCommand: false,
-  yarnLock: 'yarn.lock',
-  yarnLockBackupFileName: 'yarn.lock.ember-try',
-  configKey: 'npm',
-  packageJSON: 'package.json',
-  packageJSONBackupFileName: 'package.json.ember-try',
-  nodeModules: 'node_modules',
-  nodeModulesBackupLocation: '.node_modules.ember-try',
-  npmShrinkWrap: 'npm-shrinkwrap.json',
-  npmShrinkWrapBackupFileName: 'npm-shrinkwrap.json.ember-try',
-  packageLock: 'package-lock.json',
-  packageLockBackupFileName: 'package-lock.json.ember-try',
-
-  async setup(options) {
-    if (!options) {
-      options = {};
-    }
-
-    this._runYarnCheck(options.ui);
-
-    return await this._backupOriginalDependencies();
-  },
-
-  async changeToDependencySet(depSet) {
-    this.applyDependencySet(depSet);
-
-    await this._install(depSet);
-
-    let deps = Object.assign({}, depSet.dependencies, depSet.devDependencies);
-    let currentDeps = Object.keys(deps).map((dep) => {
-      return {
-        name: dep,
-        versionExpected: deps[dep],
-        versionSeen: this._findCurrentVersionOf(dep),
-        packageManager: this.useYarnCommand ? 'yarn' : 'npm',
-      };
-    });
-
-    debug('Switched to dependencies: \n', currentDeps);
-
-    return currentDeps;
-  },
-
-  async cleanup() {
-    try {
-      await this._restoreOriginalDependencies();
-
-      debug('Remove backup package.json and node_modules');
-
-      let cleanupTasks = [
-        rimraf(path.join(this.cwd, this.packageJSONBackupFileName)),
-        rimraf(path.join(this.cwd, this.nodeModulesBackupLocation)),
-      ];
-
-      if (fs.existsSync(path.join(this.cwd, this.yarnLockBackupFileName))) {
-        cleanupTasks.push(rimraf(path.join(this.cwd, this.yarnLockBackupFileName)));
-      }
-
-      if (fs.existsSync(path.join(this.cwd, this.npmShrinkWrapBackupFileName))) {
-        cleanupTasks.push(rimraf(path.join(this.cwd, this.npmShrinkWrapBackupFileName)));
-      }
-
-      if (fs.existsSync(path.join(this.cwd, this.packageLockBackupFileName))) {
-        cleanupTasks.push(rimraf(path.join(this.cwd, this.packageLockBackupFileName)));
-      }
-
-      return await Promise.all(cleanupTasks);
-    } catch (e) {
-      console.log('Error cleaning up npm scenario:', e); // eslint-disable-line no-console
-    }
-  },
-
-  _runYarnCheck(ui) {
-    if (!this.useYarnCommand) {
-      try {
-        if (fs.statSync(path.join(this.cwd, this.yarnLock)).isFile()) {
-          ui.writeLine(
-            chalk.yellow(
-              'Detected a yarn.lock file. Add `useYarn: true` to your `config/ember-try.js` configuration file if you want to use Yarn to install npm dependencies.'
-            )
-          );
-        }
-      } catch (e) {
-        // If no yarn.lock is found, no need to warn.
-      }
-    }
-  },
-
-  _findCurrentVersionOf(packageName) {
-    let filename = path.join(this.cwd, this.nodeModules, packageName, this.packageJSON);
-    if (fs.existsSync(filename)) {
-      return JSON.parse(fs.readFileSync(filename)).version;
-    } else {
-      return null;
-    }
-  },
-
-  async _install(depSet) {
-    let mgrOptions = this.managerOptions || [];
-    let cmd = this.useYarnCommand ? 'yarn' : 'npm';
-
-    // buildManagerOptions overrides all default
-    if (typeof this.buildManagerOptions === 'function') {
-      mgrOptions = this.buildManagerOptions(depSet);
-
-      if (!Array.isArray(mgrOptions)) {
-        throw new Error('buildManagerOptions must return an array of options');
-      }
-    } else {
-      if (this.useYarnCommand) {
-        if (mgrOptions.indexOf('--no-lockfile') === -1) {
-          mgrOptions = mgrOptions.concat(['--no-lockfile']);
-        }
-        // npm warns on incompatible engines
-        // yarn errors, not a good experience
-        if (mgrOptions.indexOf('--ignore-engines') === -1) {
-          mgrOptions = mgrOptions.concat(['--ignore-engines']);
-        }
-      } else if (mgrOptions.indexOf('--no-shrinkwrap') === -1) {
-        mgrOptions = mgrOptions.concat(['--no-shrinkwrap']);
-      }
-    }
-
-    debug('Run npm/yarn install with options %s', mgrOptions);
-
-    await this.run(cmd, [].concat(['install'], mgrOptions), { cwd: this.cwd });
-
-    if (!this.useYarnCommand) {
-      let res = await this.run('npm', ['--version'], { cwd: this.cwd, stdio: 'pipe' });
-      let version = res.stdout;
-      if (version.match(/^4./)) {
-        debug('Running npm prune because version is %s', version);
-        return await this.run(this.configKey, ['prune'], { cwd: this.cwd });
-      }
-
-      debug('Not running npm prune because version is %s', version);
-    }
-  },
-
-  applyDependencySet(depSet) {
-    debug('Changing to dependency set: %s', JSON.stringify(depSet));
-
-    if (!depSet) {
-      return;
-    }
-
-    let backupPackageJSON = path.join(this.cwd, this.packageJSONBackupFileName);
-    let packageJSONFile = path.join(this.cwd, this.packageJSON);
-    let packageJSON = JSON.parse(fs.readFileSync(backupPackageJSON));
-    let newPackageJSON = this._packageJSONForDependencySet(packageJSON, depSet);
-
-    debug('Write package.json with: \n', JSON.stringify(newPackageJSON));
-
-    fs.writeFileSync(packageJSONFile, JSON.stringify(newPackageJSON, null, 2));
-  },
-
-  _packageJSONForDependencySet(packageJSON, depSet) {
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'dependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'devDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'peerDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'ember');
-
-    if (this.useYarnCommand) {
-      this._overridePackageJSONDependencies(packageJSON, depSet, 'resolutions');
-    } else {
-      this._overridePackageJSONDependencies(packageJSON, depSet, 'overrides');
-    }
-
-    return packageJSON;
-  },
-
-  _overridePackageJSONDependencies(packageJSON, depSet, kindOfDependency) {
-    if (!depSet[kindOfDependency]) {
-      return;
-    }
-
-    let packageNames = Object.keys(depSet[kindOfDependency]);
-
-    packageNames.forEach((packageName) => {
-      if (!packageJSON[kindOfDependency]) {
-        packageJSON[kindOfDependency] = {};
-      }
-
-      let version = depSet[kindOfDependency][packageName];
-      if (version === null) {
-        delete packageJSON[kindOfDependency][packageName];
-      } else {
-        packageJSON[kindOfDependency][packageName] = version;
-
-        // in npm we need to always add an override if the version is a pre-release
-        if (
-          !this.useYarnCommand &&
-          (semver.prerelease(version) || /^https*:\/\/.*\.tg*z/.test(version))
-        ) {
-          if (!packageJSON.overrides) {
-            packageJSON.overrides = {};
-          }
-
-          packageJSON.overrides[packageName] = `$${packageName}`;
-        }
-      }
-    });
-  },
-
-  _restoreOriginalDependencies() {
-    debug('Restoring original package.json and node_modules');
-
-    let restoreTasks = [
-      copy(
-        path.join(this.cwd, this.packageJSONBackupFileName),
-        path.join(this.cwd, this.packageJSON)
-      ),
-    ];
-
-    let nodeModulesBackupLocation = path.join(this.cwd, this.nodeModulesBackupLocation);
-    if (fs.existsSync(nodeModulesBackupLocation)) {
-      restoreTasks.push(
-        copy(nodeModulesBackupLocation, path.join(this.cwd, this.nodeModules), { clobber: true })
-      );
-    }
-
-    let yarnLockBackupFileName = path.join(this.cwd, this.yarnLockBackupFileName);
-    if (fs.existsSync(yarnLockBackupFileName)) {
-      restoreTasks.push(copy(yarnLockBackupFileName, path.join(this.cwd, this.yarnLock)));
-    }
-
-    let npmShrinkWrapBackupFileName = path.join(this.cwd, this.npmShrinkWrapBackupFileName);
-    if (fs.existsSync(npmShrinkWrapBackupFileName)) {
-      restoreTasks.push(copy(npmShrinkWrapBackupFileName, path.join(this.cwd, this.npmShrinkWrap)));
-    }
-
-    let packageLockBackupFileName = path.join(this.cwd, this.packageLockBackupFileName);
-    if (fs.existsSync(packageLockBackupFileName)) {
-      restoreTasks.push(copy(packageLockBackupFileName, path.join(this.cwd, this.packageLock)));
-    }
-
-    return Promise.all(restoreTasks);
-  },
-
-  _backupOriginalDependencies() {
-    debug('Backing up package.json and node_modules');
-
-    let backupTasks = [
-      copy(
-        path.join(this.cwd, this.packageJSON),
-        path.join(this.cwd, this.packageJSONBackupFileName)
-      ),
-    ];
-
-    let nodeModulesPath = path.join(this.cwd, this.nodeModules);
-    if (fs.existsSync(nodeModulesPath)) {
-      backupTasks.push(
-        copy(nodeModulesPath, path.join(this.cwd, this.nodeModulesBackupLocation), {
-          clobber: true,
-        })
-      );
-    }
-
-    let yarnLockPath = path.join(this.cwd, this.yarnLock);
-    if (fs.existsSync(yarnLockPath)) {
-      backupTasks.push(copy(yarnLockPath, path.join(this.cwd, this.yarnLockBackupFileName)));
-    }
-
-    let npmShrinkWrapPath = path.join(this.cwd, this.npmShrinkWrap);
-    if (fs.existsSync(npmShrinkWrapPath)) {
-      backupTasks.push(
-        copy(npmShrinkWrapPath, path.join(this.cwd, this.npmShrinkWrapBackupFileName))
-      );
-    }
-
-    let packageLockPath = path.join(this.cwd, this.packageLock);
-    if (fs.existsSync(packageLockPath)) {
-      backupTasks.push(copy(packageLockPath, path.join(this.cwd, this.packageLockBackupFileName)));
-    }
-
-    return Promise.all(backupTasks);
-  },
-});
+const { LOCKFILE } = require('../utils/package-managers');
+const { BaseAdapter } = require('./base');
+
+module.exports = class NpmAdapter extends BaseAdapter {
+  defaultInstallOptions = ['--no-package-lock'];
+  lockfile = LOCKFILE.npm;
+  name = 'npm';
+  overridesKey = 'overrides';
+};

package/lib/dependency-manager-adapters/pnpm.js

@@ -1,172 +1,152 @@
 'use strict';
 
-const CoreObject = require('core-object');
 const fs = require('fs-extra');
-const path = require('path');
-const debug = require('debug')('ember-try:dependency-manager-adapter:pnpm');
+const path = require('node:path');
+const semver = require('semver');
+const YAML = require('yaml');
+const { LOCKFILE } = require('../utils/package-managers');
+const { BaseAdapter } = require('./base');
 
-const PACKAGE_JSON = 'package.json';
-const PACKAGE_JSON_BACKUP = 'package.json.ember-try';
-const PNPM_LOCKFILE = 'pnpm-lock.yaml';
+const WORKSPACE_YAML = 'pnpm-workspace.yaml';
 
-// Note: the upstream convention is to append `.ember-try` _after_ the file
-// extension, however this breaks syntax highlighting, so I've chosen to
-// insert it right before the file extension.
-const PNPM_LOCKFILE_BACKUP = 'pnpm-lock.ember-try.yaml';
+module.exports = class PnpmAdapter extends BaseAdapter {
+  defaultInstallOptions = ['--no-lockfile', '--ignore-scripts'];
+  lockfile = LOCKFILE.pnpm;
+  name = 'pnpm';
+  overridesKey = 'pnpm.overrides';
 
-module.exports = CoreObject.extend({
-  // This still needs to be `npm` because we're still reading the dependencies
-  // from the `npm` key of the ember-try config.
-  configKey: 'npm',
-
-  init() {
-    this._super.apply(this, arguments);
-    this.run = this.run || require('../utils/run');
-  },
+  pnpmVersion = null;
+  workspaceOverrides = null;
 
   async setup() {
-    let pkg = path.join(this.cwd, PACKAGE_JSON);
-    let pkgBackup = path.join(this.cwd, PACKAGE_JSON_BACKUP);
-    debug(`Copying ${PACKAGE_JSON}`);
-    await fs.copy(pkg, pkgBackup);
-
-    let lockFile = path.join(this.cwd, PNPM_LOCKFILE);
-    let lockFileBackup = path.join(this.cwd, PNPM_LOCKFILE_BACKUP);
-    if (fs.existsSync(lockFile)) {
-      debug(`Copying ${PNPM_LOCKFILE}`);
-      await fs.copy(lockFile, lockFileBackup);
-    }
-  },
+    await this._throwOnResolutionMode();
+    await super.setup();
+    await this.backup.addFile(WORKSPACE_YAML);
+  }
 
-  async changeToDependencySet(depSet) {
-    await this.applyDependencySet(depSet);
+  async applyDependencySet(dependencySet) {
+    await super.applyDependencySet(dependencySet);
 
-    await this._install(depSet);
-
-    let deps = Object.assign({}, depSet.dependencies, depSet.devDependencies);
-    let currentDeps = Object.keys(deps).map((dep) => {
-      return {
-        name: dep,
-        versionExpected: deps[dep],
-        versionSeen: this._findCurrentVersionOf(dep),
-        packageManager: 'pnpm',
-      };
-    });
-
-    debug('Switched to dependencies: \n', currentDeps);
-
-    return currentDeps;
-  },
+    if (this.workspaceOverrides !== null) {
+      this._writeWorkspaceOverrides(this.workspaceOverrides);
+    }
+  }
 
   async cleanup() {
-    try {
-      debug(`Restoring original ${PACKAGE_JSON}`);
-      let pkg = path.join(this.cwd, PACKAGE_JSON);
-      let pkgBackup = path.join(this.cwd, PACKAGE_JSON_BACKUP);
-      await fs.copy(pkgBackup, pkg);
-      await fs.remove(pkgBackup);
-
-      debug(`Restoring original ${PNPM_LOCKFILE}`);
-      let lockFile = path.join(this.cwd, PNPM_LOCKFILE);
-      let lockFileBackup = path.join(this.cwd, PNPM_LOCKFILE_BACKUP);
-      await fs.copy(lockFileBackup, lockFile);
-      await fs.remove(lockFileBackup);
-
-      await this._install();
-    } catch (e) {
-      console.log('Error cleaning up scenario:', e); // eslint-disable-line no-console
+    if (this.workspaceOverrides !== null) {
+      if (fs.existsSync(this.backup.pathForFile(WORKSPACE_YAML))) {
+        await this.backup.restoreFile(WORKSPACE_YAML);
+      } else {
+        await fs.remove(path.join(this.cwd, WORKSPACE_YAML));
+      }
     }
-  },
 
-  _findCurrentVersionOf(packageName) {
-    let filename = path.join(this.cwd, 'node_modules', packageName, PACKAGE_JSON);
-    if (fs.existsSync(filename)) {
-      return JSON.parse(fs.readFileSync(filename)).version;
-    } else {
-      return null;
+    await super.cleanup();
+  }
+
+  _packageJSONForDependencySet(packageJSON, dependencySet) {
+    if (!this._readsWorkspaceSettings()) {
+      return super._packageJSONForDependencySet(packageJSON, dependencySet);
     }
-  },
 
-  async _install(depSet) {
-    let mgrOptions = this.managerOptions || [];
+    // pnpm 11 and later ignore the `pnpm` field in package.json
+    const originalPnpmField = packageJSON.pnpm;
 
-    // buildManagerOptions overrides all default
-    if (typeof this.buildManagerOptions === 'function') {
-      mgrOptions = this.buildManagerOptions(depSet);
+    packageJSON.pnpm = { overrides: { ...this._readWorkspaceOverrides() } };
 
-      if (!Array.isArray(mgrOptions)) {
-        throw new Error('buildManagerOptions must return an array of options');
-      }
+    const result = super._packageJSONForDependencySet(packageJSON, dependencySet);
+
+    this.workspaceOverrides = result.pnpm.overrides;
+
+    if (originalPnpmField === undefined) {
+      delete result.pnpm;
     } else {
-      if (!mgrOptions.includes('--no-lockfile')) {
-        mgrOptions.push('--no-lockfile');
-      }
+      result.pnpm = originalPnpmField;
     }
 
-    // Note: We are explicitly *not* using `--no-lockfile` here, so that we
-    // only have to resolve the dependencies that have actually changed.
-
-    debug('Run pnpm install with options %s', mgrOptions);
+    return result;
+  }
 
-    await this.run('pnpm', [].concat(['install'], mgrOptions), { cwd: this.cwd });
-  },
+  _readsWorkspaceSettings() {
+    return this.pnpmVersion !== null && semver.satisfies(this.pnpmVersion, '>=11.0.0');
+  }
 
-  async applyDependencySet(depSet) {
-    debug('Changing to dependency set: %s', JSON.stringify(depSet));
+  _readWorkspaceDocument() {
+    const backupFile = this.backup.pathForFile(WORKSPACE_YAML);
 
-    if (!depSet) {
-      return;
+    if (fs.existsSync(backupFile)) {
+      return YAML.parseDocument(fs.readFileSync(backupFile, 'utf-8'));
     }
 
-    let backupPackageJSON = path.join(this.cwd, PACKAGE_JSON_BACKUP);
-    let packageJSONFile = path.join(this.cwd, PACKAGE_JSON);
-    let packageJSON = JSON.parse(fs.readFileSync(backupPackageJSON));
-    let newPackageJSON = this._packageJSONForDependencySet(packageJSON, depSet);
+    return new YAML.Document({});
+  }
 
-    debug('Write package.json with: \n', JSON.stringify(newPackageJSON));
-    fs.writeFileSync(packageJSONFile, JSON.stringify(newPackageJSON, null, 2));
+  _readWorkspaceOverrides() {
+    return this._readWorkspaceDocument().toJS()?.overrides ?? {};
+  }
 
-    // We restore the original lockfile here, so that we always create a minimal
-    // diff compared to the original locked dependency set.
+  _writeWorkspaceOverrides(overrides) {
+    const hasOverrides = Object.keys(overrides).length > 0;
 
-    let lockFile = path.join(this.cwd, PNPM_LOCKFILE);
-    let lockFileBackup = path.join(this.cwd, PNPM_LOCKFILE_BACKUP);
-    if (fs.existsSync(lockFileBackup)) {
-      debug(`Restoring original ${PNPM_LOCKFILE}`);
-      await fs.copy(lockFileBackup, lockFile);
+    if (!hasOverrides && !fs.existsSync(this.backup.pathForFile(WORKSPACE_YAML))) {
+      return;
     }
-  },
 
-  _packageJSONForDependencySet(packageJSON, depSet) {
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'dependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'devDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'peerDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'ember');
+    const document = this._readWorkspaceDocument();
 
-    // see https://pnpm.io/package_json#pnpmoverrides
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'overrides');
-
-    return packageJSON;
-  },
+    if (!hasOverrides) {
+      document.delete('overrides');
+    } else {
+      document.set('overrides', overrides);
+    }
 
-  _overridePackageJSONDependencies(packageJSON, depSet, kindOfDependency) {
-    if (!depSet[kindOfDependency]) {
-      return;
+    fs.writeFileSync(path.join(this.cwd, WORKSPACE_YAML), document.toString());
+  }
+
+  /**
+   * pnpm versions 8.0.0 through 8.6.* have the `resolution-mode` setting inverted to
+   * `lowest-direct`, which breaks ember-try. This method throws a helpful error in the following
+   * case: pnpm version is within dangerous range and `pnpm config get resolution-mode` reports an
+   * empty value.
+   *
+   * @returns Promise<void>
+   */
+  async _throwOnResolutionMode() {
+    this.pnpmVersion = await this._getPnpmVersion();
+    let resolutionMode = await this._getResolutionMode();
+
+    if (this._isResolutionModeWrong(this.pnpmVersion, resolutionMode)) {
+      throw new Error(
+        'You are using an old version of pnpm that uses wrong resolution mode that violates ember-try expectations. Please either upgrade pnpm or set `resolution-mode` to `highest` in `.npmrc`.',
+      );
     }
+  }
 
-    let packageNames = Object.keys(depSet[kindOfDependency]);
+  async _getPnpmVersion() {
+    let result = await this.run('pnpm', ['--version'], { cwd: this.cwd, stdio: 'pipe' });
+    return result.stdout.split('\n')[0];
+  }
 
-    for (let packageName of packageNames) {
-      if (!packageJSON[kindOfDependency]) {
-        packageJSON[kindOfDependency] = {};
-      }
+  async _getResolutionMode() {
+    let result = await this.run('pnpm', ['config', 'get', 'resolution-mode'], {
+      cwd: this.cwd,
+      stdio: 'pipe',
+    });
 
-      let version = depSet[kindOfDependency][packageName];
-      if (version === null) {
-        delete packageJSON[kindOfDependency][packageName];
-      } else {
-        packageJSON[kindOfDependency][packageName] = version;
-      }
+    return result.stdout.split('\n')[0];
+  }
+
+  _isResolutionModeWrong(versionStr, resolutionMode) {
+    // The `resolution-mode` is not set explicitly, and the current pnpm version makes it default
+    // to `lowest-direct`
+    if (
+      !resolutionMode.length &&
+      semver.gte(versionStr, '8.0.0') &&
+      semver.lt(versionStr, '8.7.0')
+    ) {
+      return true;
     }
-  },
-});
+
+    return false;
+  }
+};