@ohos-ports/parcel-package-manager 2.16.4-beta.0

package/src/installPackage.js

@@ -0,0 +1,284 @@
+// @flow
+
+import type {FilePath, PackageJSON} from '@parcel/types';
+import type {
+  ModuleRequest,
+  PackageManager,
+  PackageInstaller,
+  InstallOptions,
+} from '@parcel/types';
+import type {FileSystem} from '@parcel/fs';
+
+import invariant from 'assert';
+import path from 'path';
+import nullthrows from 'nullthrows';
+import semver from 'semver';
+import ThrowableDiagnostic, {
+  generateJSONCodeHighlights,
+  encodeJSONKeyComponent,
+  md,
+} from '@parcel/diagnostic';
+import logger from '@parcel/logger';
+import {loadConfig, PromiseQueue, resolveConfig} from '@parcel/utils';
+import WorkerFarm from '@parcel/workers';
+
+import {Npm} from './Npm';
+import {Yarn} from './Yarn';
+import {Pnpm} from './Pnpm.js';
+import {getConflictingLocalDependencies} from './utils';
+import getCurrentPackageManager from './getCurrentPackageManager';
+import validateModuleSpecifier from './validateModuleSpecifier';
+
+async function install(
+  fs: FileSystem,
+  packageManager: PackageManager,
+  modules: Array<ModuleRequest>,
+  from: FilePath,
+  projectRoot: FilePath,
+  options: InstallOptions = {},
+): Promise<void> {
+  let {installPeers = true, saveDev = true, packageInstaller} = options;
+  let moduleNames = modules.map(m => m.name).join(', ');
+
+  logger.progress(`Installing ${moduleNames}...`);
+
+  let fromPkgPath = await resolveConfig(
+    fs,
+    from,
+    ['package.json'],
+    projectRoot,
+  );
+  let cwd = fromPkgPath ? path.dirname(fromPkgPath) : fs.cwd();
+
+  if (!packageInstaller) {
+    packageInstaller = await determinePackageInstaller(fs, from, projectRoot);
+  }
+
+  try {
+    await packageInstaller.install({
+      modules,
+      saveDev,
+      cwd,
+      packagePath: fromPkgPath,
+      fs,
+    });
+  } catch (err) {
+    throw new Error(`Failed to install ${moduleNames}: ${err.message}`);
+  }
+
+  if (installPeers) {
+    await Promise.all(
+      modules.map(m =>
+        installPeerDependencies(
+          fs,
+          packageManager,
+          m,
+          from,
+          projectRoot,
+          options,
+        ),
+      ),
+    );
+  }
+}
+
+async function installPeerDependencies(
+  fs: FileSystem,
+  packageManager: PackageManager,
+  module: ModuleRequest,
+  from: FilePath,
+  projectRoot: FilePath,
+  options,
+) {
+  const {resolved} = await packageManager.resolve(module.name, from);
+  const modulePkg: PackageJSON = nullthrows(
+    await loadConfig(fs, resolved, ['package.json'], projectRoot),
+  ).config;
+  const peers = modulePkg.peerDependencies || {};
+
+  let modules: Array<ModuleRequest> = [];
+  for (let [name, range] of Object.entries(peers)) {
+    invariant(typeof range === 'string');
+
+    let conflicts = await getConflictingLocalDependencies(
+      fs,
+      name,
+      from,
+      projectRoot,
+    );
+    if (conflicts) {
+      let {pkg} = await packageManager.resolve(name, from);
+      invariant(pkg);
+      if (!semver.satisfies(pkg.version, range)) {
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message: md`Could not install the peer dependency "${name}" for "${module.name}", installed version ${pkg.version} is incompatible with ${range}`,
+            origin: '@parcel/package-manager',
+            codeFrames: [
+              {
+                filePath: conflicts.filePath,
+                language: 'json',
+                code: conflicts.json,
+                codeHighlights: generateJSONCodeHighlights(
+                  conflicts.json,
+                  conflicts.fields.map(field => ({
+                    key: `/${field}/${encodeJSONKeyComponent(name)}`,
+                    type: 'key',
+                    message: 'Found this conflicting local requirement.',
+                  })),
+                ),
+              },
+            ],
+          },
+        });
+      }
+
+      continue;
+    }
+    modules.push({name, range});
+  }
+
+  if (modules.length) {
+    await install(
+      fs,
+      packageManager,
+      modules,
+      from,
+      projectRoot,
+      Object.assign({}, options, {installPeers: false}),
+    );
+  }
+}
+
+async function determinePackageInstaller(
+  fs: FileSystem,
+  filepath: FilePath,
+  projectRoot: FilePath,
+): Promise<PackageInstaller> {
+  let configFile = await resolveConfig(
+    fs,
+    filepath,
+    ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'],
+    projectRoot,
+  );
+
+  let configName = configFile && path.basename(configFile);
+
+  // Always use the package manager that seems to be used in the project,
+  // falling back to a different one wouldn't update the existing lockfile.
+  if (configName === 'package-lock.json') {
+    return new Npm();
+  } else if (configName === 'pnpm-lock.yaml') {
+    return new Pnpm();
+  } else if (configName === 'yarn.lock') {
+    return new Yarn();
+  }
+
+  let currentPackageManager = getCurrentPackageManager()?.name;
+  if (currentPackageManager === 'npm') {
+    return new Npm();
+  } else if (currentPackageManager === 'yarn') {
+    return new Yarn();
+  } else if (currentPackageManager === 'pnpm') {
+    return new Pnpm();
+  }
+
+  if (await Yarn.exists()) {
+    return new Yarn();
+  } else if (await Pnpm.exists()) {
+    return new Pnpm();
+  } else {
+    return new Npm();
+  }
+}
+
+let queue = new PromiseQueue({maxConcurrent: 1});
+let modulesInstalling: Set<string> = new Set();
+
+// Exported so that it may be invoked from the worker api below.
+// Do not call this directly! This can result in concurrent package installations
+// across multiple instances of the package manager.
+export function _addToInstallQueue(
+  fs: FileSystem,
+  packageManager: PackageManager,
+  modules: Array<ModuleRequest>,
+  filePath: FilePath,
+  projectRoot: FilePath,
+  options?: InstallOptions,
+): Promise<mixed> {
+  modules = modules.map(request => ({
+    name: validateModuleSpecifier(request.name),
+    range: request.range,
+  }));
+
+  // Wrap PromiseQueue and track modules that are currently installing.
+  // If a request comes in for a module that is currently installing, don't bother
+  // enqueuing it.
+  let modulesToInstall = modules.filter(
+    m => !modulesInstalling.has(getModuleRequestKey(m)),
+  );
+  if (modulesToInstall.length) {
+    for (let m of modulesToInstall) {
+      modulesInstalling.add(getModuleRequestKey(m));
+    }
+
+    queue
+      .add(() =>
+        install(
+          fs,
+          packageManager,
+          modulesToInstall,
+          filePath,
+          projectRoot,
+          options,
+        ).then(() => {
+          for (let m of modulesToInstall) {
+            modulesInstalling.delete(getModuleRequestKey(m));
+          }
+        }),
+      )
+      .then(
+        () => {},
+        () => {},
+      );
+  }
+
+  return queue.run();
+}
+
+export function installPackage(
+  fs: FileSystem,
+  packageManager: PackageManager,
+  modules: Array<ModuleRequest>,
+  filePath: FilePath,
+  projectRoot: FilePath,
+  options?: InstallOptions,
+): Promise<mixed> {
+  if (WorkerFarm.isWorker()) {
+    let workerApi = WorkerFarm.getWorkerApi();
+    // TODO this should really be `__filename` but without the rewriting.
+    let bundlePath =
+      process.env.PARCEL_BUILD_ENV === 'production' &&
+      !process.env.PARCEL_SELF_BUILD
+        ? path.join(__dirname, '..', 'lib/index.js')
+        : __filename;
+    return workerApi.callMaster({
+      location: bundlePath,
+      args: [fs, packageManager, modules, filePath, projectRoot, options],
+      method: '_addToInstallQueue',
+    });
+  }
+
+  return _addToInstallQueue(
+    fs,
+    packageManager,
+    modules,
+    filePath,
+    projectRoot,
+    options,
+  );
+}
+
+function getModuleRequestKey(moduleRequest: ModuleRequest): string {
+  return [moduleRequest.name, moduleRequest.range].join('@');
+}

package/src/promiseFromProcess.js

@@ -0,0 +1,19 @@
+// @flow strict-local
+
+import type {ChildProcess} from 'child_process';
+
+export default function promiseFromProcess(
+  childProcess: ChildProcess,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    childProcess.on('error', reject);
+    childProcess.on('close', code => {
+      if (code !== 0) {
+        reject(new Error('Child process failed'));
+        return;
+      }
+
+      resolve();
+    });
+  });
+}

package/src/utils.js

@@ -0,0 +1,93 @@
+// @flow strict-local
+
+import type {FilePath, ModuleRequest} from '@parcel/types';
+import type {FileSystem} from '@parcel/fs';
+
+import invariant from 'assert';
+import ThrowableDiagnostic from '@parcel/diagnostic';
+import {resolveConfig} from '@parcel/utils';
+import {exec as _exec} from 'child_process';
+import {promisify} from 'util';
+
+export const exec: (
+  command: string,
+  options?: child_process$execOpts,
+) => Promise<{|stdout: string | Buffer, stderr: string | Buffer|}> = _exec
+  ? promisify(_exec)
+  : // _exec is undefined in browser builds
+    _exec;
+
+export function npmSpecifierFromModuleRequest(
+  moduleRequest: ModuleRequest,
+): string {
+  return moduleRequest.range != null
+    ? [moduleRequest.name, moduleRequest.range].join('@')
+    : moduleRequest.name;
+}
+
+export function moduleRequestsFromDependencyMap(dependencyMap: {|
+  [string]: string,
+|}): Array<ModuleRequest> {
+  return Object.entries(dependencyMap).map(([name, range]) => {
+    invariant(typeof range === 'string');
+    return {
+      name,
+      range,
+    };
+  });
+}
+
+export async function getConflictingLocalDependencies(
+  fs: FileSystem,
+  name: string,
+  local: FilePath,
+  projectRoot: FilePath,
+): Promise<?{|json: string, filePath: FilePath, fields: Array<string>|}> {
+  let pkgPath = await resolveConfig(fs, local, ['package.json'], projectRoot);
+  if (pkgPath == null) {
+    return;
+  }
+
+  let pkgStr = await fs.readFile(pkgPath, 'utf8');
+  let pkg;
+  try {
+    pkg = JSON.parse(pkgStr);
+  } catch (e) {
+    // TODO: codeframe
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        message: 'Failed to parse package.json',
+        origin: '@parcel/package-manager',
+      },
+    });
+  }
+
+  if (typeof pkg !== 'object' || pkg == null) {
+    // TODO: codeframe
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        message: 'Expected package.json contents to be an object.',
+        origin: '@parcel/package-manager',
+      },
+    });
+  }
+
+  let fields = [];
+  for (let field of ['dependencies', 'devDependencies', 'peerDependencies']) {
+    if (
+      typeof pkg[field] === 'object' &&
+      pkg[field] != null &&
+      pkg[field][name] != null
+    ) {
+      fields.push(field);
+    }
+  }
+
+  if (fields.length > 0) {
+    return {
+      filePath: pkgPath,
+      json: pkgStr,
+      fields,
+    };
+  }
+}

package/src/validateModuleSpecifier.js

@@ -0,0 +1,12 @@
+// @flow
+
+const MODULE_REGEX = /^((@[^/\s]+\/){0,1}([^/\s.~]+[^/\s]*)){1}(@[^/\s]+){0,1}/;
+
+export default function validateModuleSpecifier(moduleName: string): string {
+  let matches = MODULE_REGEX.exec(moduleName);
+  if (matches) {
+    return matches[0];
+  }
+
+  return '';
+}