feat(plugin-js-packages): introduce yarn v1 outdated, unify type

Author: Tlacenka

.eslintrc.json

@@ -63,6 +63,12 @@
               }
             ]
           }
+        ],
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          {
+            "argsIgnorePattern": "^_"
+          }
         ]
       }
     },

packages/plugin-js-packages/README.md

@@ -159,6 +159,15 @@ Each dependency group has its own audit. If you want to check only a subset of d
      ],
 ```
 
+## Adding new package managers
+
+In order to add a support for a new package manager, one needs to do the following.
+
+1. Expand `packageManagerSchema` in `config.ts`.
+2. Expand `<command>Args` in `runner/<command>/constants.ts` with a set of arguments to be run for a given package manager command.
+3. Create a custom type in `runner/<command>/types.ts` with relevant properties based on expected command JSON output.
+4. Create a function in `runner/<command>/unify-type.ts` that will transform JSON output into a normalized type `OutdatedResult` or `AuditResult` and add it to `normalized<command>Mapper` in `runner/<command>/constants.ts`.
+
 ## Score calculation
 
 Audit output score is a numeric value in the range 0-1.

packages/plugin-js-packages/src/lib/runner/index.ts

@@ -22,8 +22,8 @@ import {
 import { auditResultToAuditOutput } from './audit/transform';
 import { NpmAuditResultJson } from './audit/types';
 import { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants';
+import { normalizeOutdatedMapper, outdatedArgs } from './outdated/constants';
 import { outdatedResultToAuditOutput } from './outdated/transform';
-import { NpmOutdatedResultJson } from './outdated/types';
 
 export async function createRunnerConfig(
   scriptPath: string,
@@ -59,13 +59,14 @@ export async function executeRunner(): Promise<void> {
 async function processOutdated(packageManager: PackageManager) {
   const { stdout } = await executeProcess({
     command: packageManager,
-    args: ['outdated', '--json', '--long'],
+    args: outdatedArgs[packageManager],
+    cwd: process.cwd(),
     alwaysResolve: true, // npm outdated returns exit code 1 when outdated dependencies are found
   });
 
-  const outdatedResult = JSON.parse(stdout) as NpmOutdatedResultJson;
+  const normalizedResult = normalizeOutdatedMapper[packageManager](stdout);
   return dependencyGroups.map(dep =>
-    outdatedResultToAuditOutput(outdatedResult, dep),
+    outdatedResultToAuditOutput(normalizedResult, dep),
   );
 }
 

packages/plugin-js-packages/src/lib/runner/outdated/constants.ts

@@ -1,8 +1,28 @@
 import { IssueSeverity } from '@code-pushup/models';
-import { VersionType } from './types';
+import { PackageManager } from '../../config';
+import { OutdatedResult, VersionType } from './types';
+import { npmToOutdatedResult, yarnv1ToOutdatedResult } from './unify-type';
 
 export const outdatedSeverity: Record<VersionType, IssueSeverity> = {
   major: 'error',
   minor: 'warning',
   patch: 'info',
 };
+
+export const outdatedArgs: Record<PackageManager, string[]> = {
+  npm: ['outdated', '--json', '--long'],
+  'yarn-classic': ['outdated', '--json', '|', 'jq', '-s'],
+  'yarn-modern': [],
+  pnpm: [],
+};
+
+export const normalizeOutdatedMapper: Record<
+  PackageManager,
+  (_: string) => OutdatedResult
+> = {
+  npm: npmToOutdatedResult,
+  'yarn-classic': yarnv1ToOutdatedResult,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  'yarn-modern': _ => [],
+  pnpm: _ => [],
+};

packages/plugin-js-packages/src/lib/runner/outdated/transform.ts

@@ -1,56 +1,50 @@
 import { Issue } from '@code-pushup/models';
-import { objectToEntries } from '@code-pushup/utils';
+import { pluralize } from '@code-pushup/utils';
 import { DependencyGroup } from '../../config';
 import { outdatedSeverity } from './constants';
 import {
-  NormalizedOutdatedEntries,
-  NormalizedVersionOverview,
-  NpmOutdatedResultJson,
+  OutdatedResult,
   PackageVersion,
   VersionType,
+  versionType,
 } from './types';
 
 export function outdatedResultToAuditOutput(
-  result: NpmOutdatedResultJson,
-  dependenciesType: DependencyGroup,
+  result: OutdatedResult,
+  dependencyGroup: DependencyGroup,
 ) {
   // current might be missing in some cases
   // https://stackoverflow.com/questions/42267101/npm-outdated-command-shows-missing-in-current-version
-  const validDependencies: NormalizedOutdatedEntries = objectToEntries(result)
-    .filter(
-      (entry): entry is [string, NormalizedVersionOverview] =>
-        entry[1].current != null,
-    )
-    .filter(([, detail]) =>
-      dependenciesType === 'prod'
-        ? detail.type === 'dependencies'
-        : detail.type === `${dependenciesType}Dependencies`,
-    );
-  const outdatedDependencies = validDependencies.filter(
-    ([, versions]) => versions.current !== versions.wanted,
+  const relevantDependencies: OutdatedResult = result.filter(dep =>
+    dependencyGroup === 'prod'
+      ? dep.type === 'dependencies'
+      : dep.type === `${dependencyGroup}Dependencies`,
+  );
+  const outdatedDependencies = relevantDependencies.filter(
+    dep => dep.current !== dep.latest,
   );
 
-  const majorOutdatedAmount = outdatedDependencies.filter(
-    ([, versions]) =>
-      getOutdatedLevel(versions.current, versions.wanted) === 'major',
-  ).length;
+  const outdatedStats = outdatedDependencies.reduce(
+    (acc, dep) => {
+      const outdatedLevel = getOutdatedLevel(dep.current, dep.latest);
+      return { ...acc, [outdatedLevel]: acc[outdatedLevel] + 1 };
+    },
+    { major: 0, minor: 0, patch: 0 },
+  );
 
   const issues =
     outdatedDependencies.length === 0
       ? []
       : outdatedToIssues(outdatedDependencies);
 
   return {
-    slug: `npm-outdated-${dependenciesType}`,
+    slug: `npm-outdated-${dependencyGroup}`,
     score: calculateOutdatedScore(
-      majorOutdatedAmount,
-      validDependencies.length,
+      outdatedStats.major,
+      relevantDependencies.length,
     ),
     value: outdatedDependencies.length,
-    displayValue: outdatedToDisplayValue(
-      majorOutdatedAmount,
-      outdatedDependencies.length,
-    ),
+    displayValue: outdatedToDisplayValue(outdatedStats),
     ...(issues.length > 0 && { details: { issues } }),
   };
 }
@@ -62,52 +56,59 @@ export function calculateOutdatedScore(
   return totalDeps > 0 ? (totalDeps - majorOutdated) / totalDeps : 1;
 }
 
-export function outdatedToDisplayValue(
-  majorOutdated: number,
-  totalOutdated: number,
-) {
-  return totalOutdated === 0
-    ? 'all dependencies are up to date'
-    : majorOutdated > 0
-    ? `${majorOutdated} out of ${totalOutdated} outdated dependencies require major update`
-    : `${totalOutdated} outdated ${
-        totalOutdated === 1 ? 'dependency' : 'dependencies'
-      }`;
+export function outdatedToDisplayValue(stats: Record<VersionType, number>) {
+  const total = stats.major + stats.minor + stats.patch;
+
+  const versionBreakdown = versionType
+    .map(version => (stats[version] > 0 ? `${stats[version]} ${version}` : ''))
+    .filter(text => text !== '');
+
+  if (versionBreakdown.length === 0) {
+    return 'all dependencies are up to date';
+  }
+
+  if (versionBreakdown.length > 1) {
+    return `${total} outdated package versions (${versionBreakdown.join(
+      ', ',
+    )})`;
+  }
+
+  return `${versionBreakdown[0]} outdated package ${pluralize(
+    'version',
+    total,
+  )}`;
 }
 
-export function outdatedToIssues(
-  dependencies: NormalizedOutdatedEntries,
-): Issue[] {
-  return dependencies.map<Issue>(([name, versions]) => {
-    const outdatedLevel = getOutdatedLevel(versions.current, versions.wanted);
+export function outdatedToIssues(dependencies: OutdatedResult): Issue[] {
+  return dependencies.map<Issue>(dep => {
+    const { name, current, latest, url, project } = dep;
+    const outdatedLevel = getOutdatedLevel(current, latest);
     const packageReference =
-      versions.homepage == null
-        ? `\`${name}\``
-        : `[\`${name}\`](${versions.homepage})`;
+      url == null ? `\`${name}\`` : `[\`${name}\`](${url})`;
 
     return {
-      message: `Package ${packageReference} requires a **${outdatedLevel}** update from **${versions.current}** to **${versions.wanted}**.`,
+      message: `${project}'s dependency ${packageReference} requires a **${outdatedLevel}** update from **${current}** to **${latest}**.`,
       severity: outdatedSeverity[outdatedLevel],
     };
   });
 }
 
 export function getOutdatedLevel(
   currentFullVersion: string,
-  wantedFullVersion: string,
+  latestFullVersion: string,
 ): VersionType {
   const current = splitPackageVersion(currentFullVersion);
-  const wanted = splitPackageVersion(wantedFullVersion);
+  const latest = splitPackageVersion(latestFullVersion);
 
-  if (current.major < wanted.major) {
+  if (current.major < latest.major) {
     return 'major';
   }
 
-  if (current.minor < wanted.minor) {
+  if (current.minor < latest.minor) {
     return 'minor';
   }
 
-  if (current.patch < wanted.patch) {
+  if (current.patch < latest.patch) {
     return 'patch';
   }