@ohos-ports/parcel-package-manager 2.9.3-beta.1

package/src/Pnpm.js

@@ -0,0 +1,194 @@
+// @flow strict-local
+
+import type {PackageInstaller, InstallerOptions} from './types';
+
+import path from 'path';
+import fs from 'fs';
+import commandExists from 'command-exists';
+import spawn from 'cross-spawn';
+import logger from '@parcel/logger';
+import split from 'split2';
+import JSONParseStream from './JSONParseStream';
+import promiseFromProcess from './promiseFromProcess';
+import {registerSerializableClass} from '@parcel/core';
+import {exec, npmSpecifierFromModuleRequest} from './utils';
+
+// $FlowFixMe
+import pkg from '../package.json';
+
+const PNPM_CMD = 'pnpm';
+
+type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+
+type ErrorLog = {|
+  err: {|
+    message: string,
+    code: string,
+    stack: string,
+  |},
+|};
+
+type PNPMLog =
+  | {|
+      +name: 'pnpm:progress',
+      packageId: string,
+      status: 'fetched' | 'found_in_store' | 'resolved',
+    |}
+  | {|
+      +name: 'pnpm:root',
+      added?: {|
+        id?: string,
+        name: string,
+        realName: string,
+        version?: string,
+        dependencyType?: 'prod' | 'dev' | 'optional',
+        latest?: string,
+        linkedFrom?: string,
+      |},
+      removed?: {|
+        name: string,
+        version?: string,
+        dependencyType?: 'prod' | 'dev' | 'optional',
+      |},
+    |}
+  | {|+name: 'pnpm:importing', from: string, method: string, to: string|}
+  | {|+name: 'pnpm:link', target: string, link: string|}
+  | {|+name: 'pnpm:stats', prefix: string, removed?: number, added?: number|};
+
+type PNPMResults = {|
+  level: LogLevel,
+  prefix?: string,
+  message?: string,
+  ...ErrorLog,
+  ...PNPMLog,
+|};
+
+let hasPnpm: ?boolean;
+let pnpmVersion: ?number;
+
+export class Pnpm implements PackageInstaller {
+  static async exists(): Promise<boolean> {
+    if (hasPnpm != null) {
+      return hasPnpm;
+    }
+
+    try {
+      hasPnpm = Boolean(await commandExists('pnpm'));
+    } catch (err) {
+      hasPnpm = false;
+    }
+
+    return hasPnpm;
+  }
+
+  async install({
+    modules,
+    cwd,
+    saveDev = true,
+  }: InstallerOptions): Promise<void> {
+    if (pnpmVersion == null) {
+      let version = await exec('pnpm --version');
+      pnpmVersion = parseInt(version.stdout, 10);
+    }
+
+    let args = ['add', '--reporter', 'ndjson'];
+    if (saveDev) {
+      args.push('-D');
+    }
+    if (pnpmVersion >= 7) {
+      if (fs.existsSync(path.join(cwd, 'pnpm-workspace.yaml'))) {
+        // installs in workspace root (regardless of cwd)
+        args.push('-w');
+      }
+    } else {
+      // ignores workspace root check
+      args.push('-W');
+    }
+    args = args.concat(modules.map(npmSpecifierFromModuleRequest));
+
+    let env = {};
+    for (let key in process.env) {
+      if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+        env[key] = process.env[key];
+      }
+    }
+
+    let addedCount = 0,
+      removedCount = 0;
+
+    let installProcess = spawn(PNPM_CMD, args, {
+      cwd,
+      env,
+    });
+    installProcess.stdout
+      .pipe(split())
+      .pipe(new JSONParseStream())
+      .on('error', e => {
+        logger.warn({
+          origin: '@parcel/package-manager',
+          message: e.chunk,
+          stack: e.stack,
+        });
+      })
+      .on('data', (json: PNPMResults) => {
+        if (json.level === 'error') {
+          logger.error({
+            origin: '@parcel/package-manager',
+            message: json.err.message,
+            stack: json.err.stack,
+          });
+        } else if (json.level === 'info' && typeof json.message === 'string') {
+          logger.info({
+            origin: '@parcel/package-manager',
+            message: prefix(json.message),
+          });
+        } else if (json.name === 'pnpm:stats') {
+          addedCount += json.added ?? 0;
+          removedCount += json.removed ?? 0;
+        }
+      });
+
+    let stderr = [];
+    installProcess.stderr
+      .on('data', str => {
+        stderr.push(str.toString());
+      })
+      .on('error', e => {
+        logger.warn({
+          origin: '@parcel/package-manager',
+          message: e.message,
+        });
+      });
+
+    try {
+      await promiseFromProcess(installProcess);
+
+      if (addedCount > 0 || removedCount > 0) {
+        logger.log({
+          origin: '@parcel/package-manager',
+          message: `Added ${addedCount} ${
+            removedCount > 0 ? `and removed ${removedCount} ` : ''
+          }packages via pnpm`,
+        });
+      }
+
+      // Since we succeeded, stderr might have useful information not included
+      // in the json written to stdout. It's also not necessary to log these as
+      // errors as they often aren't.
+      for (let message of stderr) {
+        logger.log({
+          origin: '@parcel/package-manager',
+          message,
+        });
+      }
+    } catch (e) {
+      throw new Error('pnpm failed to install modules');
+    }
+  }
+}
+
+function prefix(message: string): string {
+  return 'pnpm: ' + message;
+}
+
+registerSerializableClass(`${pkg.version}:Pnpm`, Pnpm);

package/src/Yarn.js

@@ -0,0 +1,157 @@
+// @flow strict-local
+
+import type {PackageInstaller, InstallerOptions} from './types';
+
+import commandExists from 'command-exists';
+import spawn from 'cross-spawn';
+import logger from '@parcel/logger';
+import split from 'split2';
+import JSONParseStream from './JSONParseStream';
+import promiseFromProcess from './promiseFromProcess';
+import {registerSerializableClass} from '@parcel/core';
+import {exec, npmSpecifierFromModuleRequest} from './utils';
+
+// $FlowFixMe
+import pkg from '../package.json';
+
+const YARN_CMD = 'yarn';
+
+type YarnStdOutMessage =
+  | {|
+      +type: 'step',
+      data: {|
+        message: string,
+        current: number,
+        total: number,
+      |},
+    |}
+  | {|+type: 'success', data: string|}
+  | {|+type: 'info', data: string|}
+  | {|+type: 'tree' | 'progressStart' | 'progressTick'|};
+
+type YarnStdErrMessage = {|
+  +type: 'error' | 'warning',
+  data: string,
+|};
+
+let hasYarn: ?boolean;
+let yarnVersion: ?number;
+
+export class Yarn implements PackageInstaller {
+  static async exists(): Promise<boolean> {
+    if (hasYarn != null) {
+      return hasYarn;
+    }
+
+    try {
+      hasYarn = Boolean(await commandExists('yarn'));
+    } catch (err) {
+      hasYarn = false;
+    }
+
+    return hasYarn;
+  }
+
+  async install({
+    modules,
+    cwd,
+    saveDev = true,
+  }: InstallerOptions): Promise<void> {
+    if (yarnVersion == null) {
+      let version = await exec('yarn --version');
+      yarnVersion = parseInt(version.stdout, 10);
+    }
+
+    let args = ['add', '--json'].concat(
+      modules.map(npmSpecifierFromModuleRequest),
+    );
+
+    if (saveDev) {
+      args.push('-D');
+      if (yarnVersion < 2) {
+        args.push('-W');
+      }
+    }
+
+    // When Parcel is run by Yarn (e.g. via package.json scripts), several environment variables are
+    // added. When parcel in turn calls Yarn again, these can cause Yarn to behave stragely, so we
+    // filter them out when installing packages.
+    let env = {};
+    for (let key in process.env) {
+      if (
+        !key.startsWith('npm_') &&
+        key !== 'YARN_WRAP_OUTPUT' &&
+        key !== 'INIT_CWD' &&
+        key !== 'NODE_ENV'
+      ) {
+        env[key] = process.env[key];
+      }
+    }
+
+    let installProcess = spawn(YARN_CMD, args, {cwd, env});
+    installProcess.stdout
+      // Invoking yarn with --json provides streaming, newline-delimited JSON output.
+      .pipe(split())
+      .pipe(new JSONParseStream())
+      .on('error', e => {
+        logger.error(e, '@parcel/package-manager');
+      })
+      .on('data', (message: YarnStdOutMessage) => {
+        switch (message.type) {
+          case 'step':
+            logger.progress(
+              prefix(
+                `[${message.data.current}/${message.data.total}] ${message.data.message}`,
+              ),
+            );
+            return;
+          case 'success':
+          case 'info':
+            logger.info({
+              origin: '@parcel/package-manager',
+              message: prefix(message.data),
+            });
+            return;
+          default:
+          // ignore
+        }
+      });
+
+    installProcess.stderr
+      .pipe(split())
+      .pipe(new JSONParseStream())
+      .on('error', e => {
+        logger.error(e, '@parcel/package-manager');
+      })
+      .on('data', (message: YarnStdErrMessage) => {
+        switch (message.type) {
+          case 'warning':
+            logger.warn({
+              origin: '@parcel/package-manager',
+              message: prefix(message.data),
+            });
+            return;
+          case 'error':
+            logger.error({
+              origin: '@parcel/package-manager',
+              message: prefix(message.data),
+            });
+            return;
+          default:
+          // ignore
+        }
+      });
+
+    try {
+      return await promiseFromProcess(installProcess);
+    } catch (e) {
+      throw new Error('Yarn failed to install modules:' + e.message);
+    }
+  }
+}
+
+function prefix(message: string): string {
+  return 'yarn: ' + message;
+}
+
+registerSerializableClass(`${pkg.version}:Yarn`, Yarn);

package/src/index.js

@@ -0,0 +1,8 @@
+// @flow
+export type * from './types';
+export * from './Npm';
+export * from './Pnpm';
+export * from './Yarn';
+export * from './MockPackageInstaller';
+export * from './NodePackageManager';
+export {_addToInstallQueue} from './installPackage';

package/src/installPackage.js

@@ -0,0 +1,274 @@
+// @flow
+
+import type {FilePath, PackageJSON} from '@parcel/types';
+import type {
+  ModuleRequest,
+  PackageManager,
+  PackageInstaller,
+  InstallOptions,
+} from './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 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();
+  }
+
+  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/types.js

@@ -0,0 +1,63 @@
+// @flow
+
+import type {
+  FilePath,
+  FileCreateInvalidation,
+  SemverRange,
+  DependencySpecifier,
+  PackageJSON,
+} from '@parcel/types';
+import type {FileSystem} from '@parcel/fs';
+
+export type ResolveResult = {|
+  resolved: FilePath | DependencySpecifier,
+  pkg?: ?PackageJSON,
+  invalidateOnFileCreate: Array<FileCreateInvalidation>,
+  invalidateOnFileChange: Set<FilePath>,
+  type: number,
+|};
+
+export type InstallOptions = {
+  installPeers?: boolean,
+  saveDev?: boolean,
+  packageInstaller?: ?PackageInstaller,
+  ...
+};
+
+export type InstallerOptions = {|
+  modules: Array<ModuleRequest>,
+  fs: FileSystem,
+  cwd: FilePath,
+  packagePath?: ?FilePath,
+  saveDev?: boolean,
+|};
+
+export interface PackageInstaller {
+  install(opts: InstallerOptions): Promise<void>;
+}
+
+export type Invalidations = {|
+  invalidateOnFileCreate: Array<FileCreateInvalidation>,
+  invalidateOnFileChange: Set<FilePath>,
+  invalidateOnStartup: boolean,
+|};
+
+export interface PackageManager {
+  require(
+    id: DependencySpecifier,
+    from: FilePath,
+    ?{|range?: ?SemverRange, shouldAutoInstall?: boolean, saveDev?: boolean|},
+  ): Promise<any>;
+  resolve(
+    id: DependencySpecifier,
+    from: FilePath,
+    ?{|range?: ?SemverRange, shouldAutoInstall?: boolean, saveDev?: boolean|},
+  ): Promise<ResolveResult>;
+  getInvalidations(id: DependencySpecifier, from: FilePath): Invalidations;
+  invalidate(id: DependencySpecifier, from: FilePath): void;
+}
+
+export type ModuleRequest = {|
+  +name: string,
+  +range: ?SemverRange,
+|};