Merge pull request #177 from bmish/autofix

Implement autofixing

Author: bmish

README.md

@@ -40,6 +40,7 @@ sinon has more than one version: ^1.17.7 (1 usage), ^9.0.3 (3 usages)
 
 | Name | Description |
 | --- | --- |
+| `--fix` | Whether to autofix inconsistencies (using highest version present). |
 | `--ignore-dep` | Dependency to ignore mismatches for (option can be repeated). |
 
 ## Related

bin/check-dependency-version-consistency.ts

@@ -7,6 +7,7 @@ import {
   calculateVersionsForEachDependency,
   calculateMismatchingVersions,
   filterOutIgnoredDependencies,
+  fixMismatchingVersions,
 } from '../lib/dependency-versions.js';
 import { mismatchingVersionsToOutputLines } from '../lib/output.js';
 import { join, dirname } from 'node:path';
@@ -35,20 +36,29 @@ const program = new Command();
 program
   .version(getCurrentPackageVersion())
   .argument('<path>', 'path to workspace root')
+  .option(
+    '--fix',
+    'Whether to autofix inconsistencies (using highest version present)',
+    false
+  )
   .option(
     '--ignore-dep <dependency>',
     'Dependency to ignore (option can be repeated)',
     collect,
     []
   )
-  .action(function (path, options: { ignoreDep: string[] }) {
+  .action(function (path, options: { ignoreDep: string[]; fix: boolean }) {
     // Calculate.
     const dependencyVersions = calculateVersionsForEachDependency(path);
-    const mismatchingVersions = filterOutIgnoredDependencies(
+    let mismatchingVersions = filterOutIgnoredDependencies(
       calculateMismatchingVersions(dependencyVersions),
       options.ignoreDep
     );
 
+    if (options.fix) {
+      mismatchingVersions = fixMismatchingVersions(path, mismatchingVersions);
+    }
+
     // Show output.
     if (mismatchingVersions.length > 0) {
       const outputLines = mismatchingVersionsToOutputLines(mismatchingVersions);

lib/dependency-versions.ts

@@ -1,6 +1,8 @@
 import { readFileSync, existsSync } from 'node:fs';
 import type { PackageJson } from 'type-fest';
 import { getPackageJsonPaths } from './workspace.js';
+import semver from 'semver';
+import editJsonFile from 'edit-json-file';
 
 export type DependenciesToVersionsSeen = Map<
   string,
@@ -158,3 +160,93 @@ export function filterOutIgnoredDependencies(
       !ignoredDependencies.includes(mismatchingVersion.dependency)
   );
 }
+
+export function fixMismatchingVersions(
+  root: string,
+  mismatchingVersions: MismatchingDependencyVersions
+): MismatchingDependencyVersions {
+  const packageJsonPaths = getPackageJsonPaths(root);
+
+  // Return any mismatching versions that are still present after attempting fixes.
+  return mismatchingVersions
+    .map((mismatchingVersion) => {
+      const versions = mismatchingVersion.versions.map(
+        (versionAndCount) => versionAndCount.version
+      );
+      let sortedVersions;
+      try {
+        sortedVersions = versions.sort(compareRanges);
+      } catch {
+        // Unable to sort so skip this dependency (return it to indicate it was not fixed).
+        return mismatchingVersion;
+      }
+      const fixedVersion = sortedVersions[sortedVersions.length - 1]; // Highest version will be sorted to end of list.
+
+      for (const packageJsonPath of packageJsonPaths) {
+        const packageJson: PackageJson = JSON.parse(
+          readFileSync(packageJsonPath, 'utf-8')
+        );
+
+        if (
+          packageJson.devDependencies &&
+          packageJson.devDependencies[mismatchingVersion.dependency] &&
+          packageJson.devDependencies[mismatchingVersion.dependency] !==
+            fixedVersion
+        ) {
+          const packageJson = editJsonFile(packageJsonPath, { autosave: true });
+          packageJson.set(
+            `devDependencies.${mismatchingVersion.dependency}`,
+            fixedVersion
+          );
+        }
+
+        if (
+          packageJson.dependencies &&
+          packageJson.dependencies[mismatchingVersion.dependency] &&
+          packageJson.dependencies[mismatchingVersion.dependency] !==
+            fixedVersion
+        ) {
+          const packageJson = editJsonFile(packageJsonPath, { autosave: true });
+          packageJson.set(
+            `dependencies.${mismatchingVersion.dependency}`,
+            fixedVersion
+          );
+        }
+      }
+
+      // Fixed successfully.
+      return undefined;
+    })
+    .filter((item) => item !== undefined) as MismatchingDependencyVersions;
+}
+
+export function compareRanges(a: string, b: string): 0 | -1 | 1 {
+  // Strip range and coerce to normalized version.
+  const aVersion = semver.coerce(a.replace(/^[\^~]/, ''));
+  const bVersion = semver.coerce(b.replace(/^[\^~]/, ''));
+  if (!aVersion) {
+    throw new Error(`Invalid Version: ${a}`);
+  }
+  if (!bVersion) {
+    throw new Error(`Invalid Version: ${b}`);
+  }
+
+  if (semver.eq(aVersion, bVersion)) {
+    // Same version, but wider range considered higher.
+    if (a.startsWith('^') && !b.startsWith('^')) {
+      return 1;
+    } else if (!a.startsWith('^') && b.startsWith('^')) {
+      return -1;
+    } else if (a.startsWith('~') && !b.startsWith('~')) {
+      return 1;
+    } else if (!a.startsWith('~') && b.startsWith('~')) {
+      return -1;
+    }
+
+    // Same version, same range.
+    return 0;
+  }
+
+  // Greater version considered higher.
+  return semver.gt(aVersion, bVersion) ? 1 : -1;
+}

package.json

@@ -40,18 +40,24 @@
   },
   "dependencies": {
     "commander": "^8.1.0",
+    "edit-json-file": "^1.6.0",
+    "semver": "^7.3.5",
     "type-fest": "^2.1.0"
   },
   "devDependencies": {
+    "@types/edit-json-file": "^1.6.0",
     "@types/mocha": "^9.0.0",
+    "@types/mock-fs": "^4.13.1",
     "@types/node": "^16.0.0",
+    "@types/semver": "^7.3.8",
     "@typescript-eslint/eslint-plugin": "^4.0.1",
     "@typescript-eslint/parser": "^4.0.1",
     "eslint": "^7.0.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-square": "^20.0.2",
     "markdownlint-cli": "^0.28.1",
     "mocha": "^9.1.1",
+    "mock-fs": "^5.0.0",
     "npm-package-json-lint": "^5.2.3",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",

test/lib/dependency-versions.ts

@@ -3,15 +3,20 @@ import {
   calculateVersionsForEachDependency,
   calculateMismatchingVersions,
   filterOutIgnoredDependencies,
+  fixMismatchingVersions,
+  compareRanges,
 } from '../../lib/dependency-versions.js';
-import { deepStrictEqual, throws } from 'node:assert';
+import { strictEqual, deepStrictEqual, throws } from 'node:assert';
 import {
   FIXTURE_PATH_VALID,
   FIXTURE_PATH_INCONSISTENT_VERSIONS,
   FIXTURE_PATH_NO_PACKAGES,
   FIXTURE_PATH_NO_DEPENDENCIES,
   FIXTURE_PATH_PACKAGE_MISSING_PACKAGE_JSON,
 } from '../fixtures/index.js';
+import mockFs from 'mock-fs';
+import { readFileSync } from 'node:fs';
+import type { PackageJson } from 'type-fest';
 
 describe('Utils | dependency-versions', function () {
   describe('#calculateMismatchingVersions', function () {
@@ -115,4 +120,124 @@ describe('Utils | dependency-versions', function () {
       );
     });
   });
+
+  describe('#fixMismatchingVersions', function () {
+    beforeEach(function () {
+      // Create a mock workspace filesystem for temporary usage in this test because changes will be written to some files.
+      mockFs({
+        'package.json': '{"workspaces": ["scope1/*"]}',
+        'scope1/package1': {
+          'package.json':
+            '{"dependencies": {"foo": "^1.0.0", "bar": "^3.0.0" }}',
+        },
+        'scope1/package2': {
+          'package.json':
+            '{"dependencies": {"foo": "^2.0.0", "bar": "invalidVersion" }}',
+        },
+      });
+    });
+
+    afterEach(function () {
+      mockFs.restore();
+    });
+
+    it('fixes the fixable inconsistencies', function () {
+      const mismatchingVersions = calculateMismatchingVersions(
+        calculateVersionsForEachDependency('.')
+      );
+      const fixedMismatchingVersions = fixMismatchingVersions(
+        '.',
+        mismatchingVersions
+      );
+
+      const packageJson1: PackageJson = JSON.parse(
+        readFileSync('scope1/package1/package.json', 'utf-8')
+      );
+      const packageJson2: PackageJson = JSON.parse(
+        readFileSync('scope1/package2/package.json', 'utf-8')
+      );
+
+      strictEqual(
+        packageJson1.dependencies && packageJson1.dependencies.foo,
+        '^2.0.0',
+        'updates the package1 `foo` version to the highest version'
+      );
+      strictEqual(
+        packageJson1.dependencies && packageJson1.dependencies.bar,
+        '^3.0.0',
+        'does not change package1 `bar` version due to abnormal version present'
+      );
+      strictEqual(
+        packageJson2.dependencies && packageJson2.dependencies.foo,
+        '^2.0.0',
+        'does not change package1 `foo` version since already at highest version'
+      );
+      strictEqual(
+        packageJson2.dependencies && packageJson2.dependencies.bar,
+        'invalidVersion',
+        'does not change package1 `bar` version due to abnormal version present'
+      );
+
+      deepStrictEqual(
+        fixedMismatchingVersions,
+        [
+          {
+            dependency: 'bar',
+            versions: [
+              {
+                count: 1,
+                version: '^3.0.0',
+              },
+              {
+                count: 1,
+                version: 'invalidVersion',
+              },
+            ],
+          },
+        ],
+        'should return only the dependency that could not be fixed due to the abnormal version present'
+      );
+    });
+  });
+
+  describe('#compareRanges', function () {
+    it('correctly chooses the higher range', function () {
+      // 1 (greater than)
+      strictEqual(compareRanges('1.2.3', '1.2.2'), 1);
+      strictEqual(compareRanges('5.0.0', '4.0.0'), 1);
+      strictEqual(compareRanges('8.0.0-beta.1', '^7'), 1);
+      strictEqual(compareRanges('^5.0.0', '4.0.0'), 1);
+      strictEqual(compareRanges('^5.0.0', '^4.0.0'), 1);
+      strictEqual(compareRanges('^5.0.0', '~4.0.0'), 1);
+      strictEqual(compareRanges('^5.0.0', '~5.0.0'), 1);
+      strictEqual(compareRanges('~5.0.0', '5.0.0'), 1);
+      strictEqual(compareRanges('~5.0.0', '~4.0.0'), 1);
+
+      // -1 (less than)
+      strictEqual(compareRanges('4.0.0', '5.0.0'), -1);
+      strictEqual(compareRanges('5.0.0', '~5.0.0'), -1);
+      strictEqual(compareRanges('^4.0.0', '^5.0.0'), -1);
+      strictEqual(compareRanges('~4.0.0', '~5.0.0'), -1);
+      strictEqual(compareRanges('~5.0.0', '^5.0.0'), -1);
+
+      // 0 (equal)
+      strictEqual(compareRanges('6', '6'), 0);
+      strictEqual(compareRanges('6.0', '6.0'), 0);
+      strictEqual(compareRanges('6.0.0', '6.0.0'), 0);
+      strictEqual(compareRanges('^6.0.0', '^6.0.0'), 0);
+      strictEqual(compareRanges('v6', '6'), 0);
+      strictEqual(compareRanges('~6.0.0', '~6.0.0'), 0);
+    });
+
+    it('throws with invalid ranges', function () {
+      throws(
+        () => compareRanges('foo', '~6.0.0'),
+        new Error('Invalid Version: foo')
+      );
+      throws(
+        () => compareRanges('~6.0.0', 'foo'),
+        new Error('Invalid Version: foo')
+      );
+    });
+  });
 });