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

package/src/utils.js

@@ -0,0 +1,92 @@
+// @flow strict-local
+
+import type {ModuleRequest} from './types';
+import type {FilePath} 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|}> =
+  promisify(_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 '';
+}

package/test/NodePackageManager.test.js

@@ -0,0 +1,310 @@
+// @flow strict-local
+
+import {MemoryFS, NodeFS, OverlayFS} from '@parcel/fs';
+import assert from 'assert';
+import invariant from 'assert';
+import path from 'path';
+import sinon from 'sinon';
+import ThrowableDiagnostic from '@parcel/diagnostic';
+import {loadConfig} from '@parcel/utils';
+import WorkerFarm from '@parcel/workers';
+import {MockPackageInstaller, NodePackageManager} from '../src';
+
+const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+
+describe('NodePackageManager', function () {
+  let fs;
+  let packageManager;
+  let packageInstaller;
+  let workerFarm;
+
+  // These can sometimes take a lil while
+  this.timeout(20000);
+
+  beforeEach(() => {
+    workerFarm = new WorkerFarm({
+      workerPath: require.resolve('@parcel/core/src/worker.js'),
+    });
+    fs = new OverlayFS(new MemoryFS(workerFarm), new NodeFS());
+    packageInstaller = new MockPackageInstaller();
+    packageManager = new NodePackageManager(fs, '/', packageInstaller);
+  });
+
+  afterEach(async () => {
+    loadConfig.clear();
+    await workerFarm.end();
+  });
+
+  it('resolves packages that exist', async () => {
+    assert.deepEqual(
+      await packageManager.resolve(
+        'foo',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      ),
+      {
+        pkg: {
+          version: '1.1.0',
+        },
+        resolved: path.join(FIXTURES_DIR, 'has-foo/node_modules/foo/index.js'),
+        type: 1,
+        invalidateOnFileChange: new Set([
+          path.join(FIXTURES_DIR, 'has-foo/node_modules/foo/package.json'),
+        ]),
+        invalidateOnFileCreate: [
+          {
+            fileName: 'node_modules/foo',
+            aboveFilePath: path.join(FIXTURES_DIR, 'has-foo'),
+          },
+        ],
+      },
+    );
+  });
+
+  it('requires packages that exist', async () => {
+    assert.deepEqual(
+      await packageManager.require(
+        'foo',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      ),
+      'foobar',
+    );
+  });
+
+  it("autoinstalls packages that don't exist", async () => {
+    packageInstaller.register('a', fs, path.join(FIXTURES_DIR, 'packages/a'));
+
+    assert.deepEqual(
+      await packageManager.resolve(
+        'a',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+        {shouldAutoInstall: true},
+      ),
+      {
+        pkg: {
+          name: 'a',
+        },
+        resolved: path.join(FIXTURES_DIR, 'has-foo/node_modules/a/index.js'),
+        type: 1,
+        invalidateOnFileChange: new Set([
+          path.join(FIXTURES_DIR, 'has-foo/node_modules/a/package.json'),
+        ]),
+        invalidateOnFileCreate: [
+          {
+            fileName: 'node_modules/a',
+            aboveFilePath: path.join(FIXTURES_DIR, 'has-foo'),
+          },
+        ],
+      },
+    );
+  });
+
+  it('does not autoinstall packages that are already listed in package.json', async () => {
+    packageInstaller.register('a', fs, path.join(FIXTURES_DIR, 'packages/a'));
+
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () =>
+        packageManager.resolve(
+          'a',
+          path.join(FIXTURES_DIR, 'has-a-not-yet-installed/index.js'),
+          {shouldAutoInstall: true},
+        ),
+      err => {
+        invariant(err instanceof ThrowableDiagnostic);
+        assert(err.message.includes('Run your package manager'));
+        return true;
+      },
+    );
+  });
+
+  it('does not autoinstall peer dependencies that are already listed in package.json', async () => {
+    packageInstaller.register(
+      'peers',
+      fs,
+      path.join(FIXTURES_DIR, 'packages/peers'),
+    );
+
+    let spy = sinon.spy(packageInstaller, 'install');
+    await packageManager.resolve(
+      'peers',
+      path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      {shouldAutoInstall: true},
+    );
+    assert.deepEqual(spy.args, [
+      [
+        {
+          cwd: path.join(FIXTURES_DIR, 'has-foo'),
+          packagePath: path.join(FIXTURES_DIR, 'has-foo/package.json'),
+          fs,
+          saveDev: true,
+          modules: [{name: 'peers', range: undefined}],
+        },
+      ],
+    ]);
+  });
+
+  it('autoinstalls peer dependencies that are not listed in package.json', async () => {
+    packageInstaller.register(
+      'foo',
+      fs,
+      path.join(FIXTURES_DIR, 'packages/foo-2.0'),
+    );
+    packageInstaller.register(
+      'peers',
+      fs,
+      path.join(FIXTURES_DIR, 'packages/peers-2.0'),
+    );
+
+    let spy = sinon.spy(packageInstaller, 'install');
+    await packageManager.resolve(
+      'peers',
+      path.join(FIXTURES_DIR, 'empty/index.js'),
+      {shouldAutoInstall: true},
+    );
+    assert.deepEqual(spy.args, [
+      [
+        {
+          cwd: path.join(FIXTURES_DIR, 'empty'),
+          packagePath: path.join(FIXTURES_DIR, 'empty/package.json'),
+          fs,
+          saveDev: true,
+          modules: [{name: 'peers', range: undefined}],
+        },
+      ],
+      [
+        {
+          cwd: path.join(FIXTURES_DIR, 'empty'),
+          packagePath: path.join(FIXTURES_DIR, 'empty/package.json'),
+          fs,
+          saveDev: true,
+          modules: [{name: 'foo', range: '^2.0.0'}],
+        },
+      ],
+    ]);
+  });
+
+  describe('range mismatch', () => {
+    it("cannot autoinstall if there's a local requirement", async () => {
+      packageManager.invalidate(
+        'foo',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      );
+
+      // $FlowFixMe assert.rejects is Node 10+
+      await assert.rejects(
+        () =>
+          packageManager.resolve(
+            'foo',
+            path.join(FIXTURES_DIR, 'has-foo/index.js'),
+            {
+              range: '^2.0.0',
+            },
+          ),
+        err => {
+          invariant(err instanceof ThrowableDiagnostic);
+          assert.equal(
+            err.message,
+            'Could not find module "foo" satisfying ^2.0.0.',
+          );
+          return true;
+        },
+      );
+    });
+
+    it("can autoinstall into local package if there isn't a local requirement", async () => {
+      packageInstaller.register(
+        'foo',
+        fs,
+        path.join(FIXTURES_DIR, 'packages/foo-2.0'),
+      );
+
+      let spy = sinon.spy(packageInstaller, 'install');
+      assert.deepEqual(
+        await packageManager.resolve(
+          'foo',
+          path.join(FIXTURES_DIR, 'has-foo/subpackage/index.js'),
+          {
+            range: '^2.0.0',
+            shouldAutoInstall: true,
+          },
+        ),
+        {
+          pkg: {
+            name: 'foo',
+            version: '2.0.0',
+          },
+          resolved: path.join(
+            FIXTURES_DIR,
+            'has-foo/subpackage/node_modules/foo/index.js',
+          ),
+          type: 1,
+          invalidateOnFileChange: new Set([
+            path.join(
+              FIXTURES_DIR,
+              'has-foo/subpackage/node_modules/foo/package.json',
+            ),
+          ]),
+          invalidateOnFileCreate: [
+            {
+              fileName: 'node_modules/foo',
+              aboveFilePath: path.join(FIXTURES_DIR, 'has-foo/subpackage'),
+            },
+          ],
+        },
+      );
+
+      assert.deepEqual(spy.args, [
+        [
+          {
+            cwd: path.join(FIXTURES_DIR, 'has-foo/subpackage'),
+            packagePath: path.join(
+              FIXTURES_DIR,
+              'has-foo/subpackage/package.json',
+            ),
+            fs,
+            saveDev: true,
+            modules: [{name: 'foo', range: '^2.0.0'}],
+          },
+        ],
+      ]);
+    });
+
+    it("cannot autoinstall peer dependencies if there's an incompatible local requirement", async () => {
+      packageManager.invalidate(
+        'peers',
+        path.join(FIXTURES_DIR, 'has-foo/index.js'),
+      );
+      packageInstaller.register(
+        'foo',
+        fs,
+        path.join(FIXTURES_DIR, 'packages/foo-2.0'),
+      );
+      packageInstaller.register(
+        'peers',
+        fs,
+        path.join(FIXTURES_DIR, 'packages/peers-2.0'),
+      );
+
+      // $FlowFixMe assert.rejects is Node 10+
+      await assert.rejects(
+        () =>
+          packageManager.resolve(
+            'peers',
+            path.join(FIXTURES_DIR, 'has-foo/index.js'),
+            {
+              range: '^2.0.0',
+              shouldAutoInstall: true,
+            },
+          ),
+        err => {
+          assert(err instanceof ThrowableDiagnostic);
+          assert.equal(
+            err.message,
+            'Could not install the peer dependency "foo" for "peers", installed version 1.1.0 is incompatible with ^2.0.0',
+          );
+          return true;
+        },
+      );
+    });
+  });
+});

package/test/fixtures/empty/package.json

@@ -0,0 +1 @@
+{}

package/test/fixtures/has-a-not-yet-installed/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "a": "1.1.0"
+  }
+}

package/test/fixtures/has-foo/node_modules/foo/index.js

@@ -0,0 +1 @@
+module.exports = 'foobar';

package/test/fixtures/has-foo/node_modules/foo/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.1.0"
+}

package/test/fixtures/has-foo/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "foo": "1.1.0"
+  }
+}

package/test/fixtures/has-foo/subpackage/package.json

@@ -0,0 +1 @@
+{}

package/test/fixtures/packages/a/index.js

@@ -0,0 +1 @@
+module.exports = 'a';

package/test/fixtures/packages/a/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "a"
+}

package/test/fixtures/packages/foo-2.0/index.js

@@ -0,0 +1 @@
+module.exports = 'foo';

package/test/fixtures/packages/foo-2.0/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "foo",
+  "version": "2.0.0"
+}

package/test/fixtures/packages/peers/index.js

@@ -0,0 +1 @@
+module.exports = 'foo';

package/test/fixtures/packages/peers/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "peers",
+  "version": "1.0.0",
+  "peerDependencies": {
+    "foo": "^1.0.0"
+  }
+}

package/test/fixtures/packages/peers-2.0/index.js

@@ -0,0 +1 @@
+module.exports = 'foo';

package/test/fixtures/packages/peers-2.0/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "peers",
+  "version": "2.0.0",
+  "peerDependencies": {
+    "foo": "^2.0.0"
+  }
+}

package/test/validateModuleSpecifiers.test.js

@@ -0,0 +1,38 @@
+// @flow
+import assert from 'assert';
+
+import validateModuleSpecifier from '../src/validateModuleSpecifier';
+
+describe('Validate Module Specifiers', () => {
+  it('Validate Module Specifiers', () => {
+    let modules = [
+      '@parcel/transformer-posthtml/package.json',
+      '@some-org/package@v1.0.0',
+      '@org/some-package@v1.0.0-alpha.1',
+      'something.js/something/index.js',
+      '@some.org/something.js/index.js',
+      'lodash/something/index.js',
+    ];
+
+    assert.deepEqual(
+      modules.map(module => validateModuleSpecifier(module)),
+      [
+        '@parcel/transformer-posthtml',
+        '@some-org/package@v1.0.0',
+        '@org/some-package@v1.0.0-alpha.1',
+        'something.js',
+        '@some.org/something.js',
+        'lodash',
+      ],
+    );
+  });
+
+  it('Return empty on invalid modules', () => {
+    let modules = ['./somewhere.js', './hello/world.js', '~/hello/world.js'];
+
+    assert.deepEqual(
+      modules.map(module => validateModuleSpecifier(module)),
+      ['', '', ''],
+    );
+  });
+});