Keep versioning utilities internal to CLI migrate module

Signed-off-by: Patrik Oldsberg <poldsberg@gmail.com>

packages/cli/src/modules/migrate/commands/versions/bump.test.ts

@@ -19,7 +19,7 @@ import * as runObj from '@backstage/cli-common';
 import { overrideTargetPaths } from '@backstage/cli-common/testUtils';
 import bump, { bumpBackstageJsonVersion, createVersionFinder } from './bump';
 import { registerMswTestHooks, withLogCollector } from '@backstage/test-utils';
-import { YarnInfoInspectData } from '@backstage/cli-node';
+import { YarnInfoInspectData } from '../../lib/versioning/packages';
 import { setupServer } from 'msw/node';
 import { rest } from 'msw';
 import { NotFoundError } from '@backstage/errors';
@@ -69,8 +69,8 @@ jest.mock('@backstage/cli-common', () => {
 });
 
 const mockFetchPackageInfo = jest.fn();
-jest.mock('@backstage/cli-node', () => {
-  const actual = jest.requireActual('@backstage/cli-node');
+jest.mock('../../lib/versioning/packages', () => {
+  const actual = jest.requireActual('../../lib/versioning/packages');
   return {
     ...actual,
     fetchPackageInfo: (name: string) => mockFetchPackageInfo(name),

packages/cli/src/modules/migrate/commands/versions/bump.ts

@@ -31,13 +31,12 @@ import { isError, NotFoundError } from '@backstage/errors';
 import { resolve as resolvePath } from 'node:path';
 
 import { getHasYarnPlugin } from '../../../../lib/yarnPlugin';
+import { Lockfile, runConcurrentTasks } from '@backstage/cli-node';
 import {
   fetchPackageInfo,
-  Lockfile,
   mapDependencies,
-  runConcurrentTasks,
   YarnInfoInspectData,
-} from '@backstage/cli-node';
+} from '../../lib/versioning/packages';
 import {
   getManifestByReleaseLine,
   getManifestByVersion,

packages/cli/src/modules/migrate/lib/versioning/packages.test.ts

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2020 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as runObj from '@backstage/cli-common';
+import * as yarn from './yarn';
+import { fetchPackageInfo, mapDependencies } from './packages';
+import { createMockDirectory } from '@backstage/backend-test-utils';
+import { NotFoundError } from '@backstage/errors';
+
+jest.mock('@backstage/cli-common', () => {
+  const actual = jest.requireActual('@backstage/cli-common');
+  return {
+    ...actual,
+    runOutput: jest.fn(),
+  };
+});
+
+jest.mock('./yarn', () => {
+  return {
+    detectYarnVersion: jest.fn(),
+  };
+});
+
+describe('fetchPackageInfo', () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should forward info for yarn classic', async () => {
+    jest
+      .spyOn(runObj, 'runOutput')
+      .mockResolvedValue(`{"type":"inspect","data":{"the":"data"}}`);
+    jest.spyOn(yarn, 'detectYarnVersion').mockResolvedValue('classic');
+
+    await expect(fetchPackageInfo('my-package')).resolves.toEqual({
+      the: 'data',
+    });
+    expect(runObj.runOutput).toHaveBeenCalledWith([
+      'yarn',
+      'info',
+      '--json',
+      'my-package',
+    ]);
+  });
+
+  it('should forward info for yarn berry', async () => {
+    jest.spyOn(runObj, 'runOutput').mockResolvedValue(`{"the":"data"}`);
+    jest.spyOn(yarn, 'detectYarnVersion').mockResolvedValue('berry');
+
+    await expect(fetchPackageInfo('my-package')).resolves.toEqual({
+      the: 'data',
+    });
+    expect(runObj.runOutput).toHaveBeenCalledWith([
+      'yarn',
+      'npm',
+      'info',
+      '--json',
+      'my-package',
+    ]);
+  });
+
+  it('should throw if no info with yarn classic', async () => {
+    jest.spyOn(runObj, 'runOutput').mockResolvedValue('');
+    jest.spyOn(yarn, 'detectYarnVersion').mockResolvedValue('classic');
+
+    await expect(fetchPackageInfo('my-package')).rejects.toThrow(
+      new NotFoundError(`No package information found for package my-package`),
+    );
+  });
+
+  it('should throw if no info with yarn berry', async () => {
+    const error = new Error('Command failed');
+    (error as Error & { stdout?: string }).stdout =
+      'bla bla bla Response Code: 404 bla bla';
+    jest.spyOn(runObj, 'runOutput').mockRejectedValue(error);
+    jest.spyOn(yarn, 'detectYarnVersion').mockResolvedValue('berry');
+
+    await expect(fetchPackageInfo('my-package')).rejects.toThrow(
+      new NotFoundError(`No package information found for package my-package`),
+    );
+  });
+});
+
+describe('mapDependencies', () => {
+  const mockDir = createMockDirectory();
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should read dependencies', async () => {
+    mockDir.setContent({
+      'package.json': JSON.stringify({
+        workspaces: {
+          packages: ['pkgs/*'],
+        },
+      }),
+      pkgs: {
+        a: {
+          'package.json': JSON.stringify({
+            name: 'a',
+            dependencies: {
+              '@backstage/core': '1 || 2',
+            },
+          }),
+        },
+        b: {
+          'package.json': JSON.stringify({
+            name: 'b',
+            dependencies: {
+              '@backstage/core': '3',
+              '@backstage/cli': '^0',
+            },
+          }),
+        },
+      },
+    });
+
+    const dependencyMap = await mapDependencies(mockDir.path, '@backstage/*');
+    expect(Array.from(dependencyMap)).toEqual([
+      [
+        '@backstage/core',
+        [
+          {
+            name: 'a',
+            range: '1 || 2',
+            location: mockDir.resolve('pkgs/a'),
+          },
+          {
+            name: 'b',
+            range: '3',
+            location: mockDir.resolve('pkgs/b'),
+          },
+        ],
+      ],
+      [
+        '@backstage/cli',
+        [
+          {
+            name: 'b',
+            range: '^0',
+            location: mockDir.resolve('pkgs/b'),
+          },
+        ],
+      ],
+    ]);
+  });
+});

packages/cli/src/modules/migrate/lib/versioning/packages.ts

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2020 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { minimatch } from 'minimatch';
+import { getPackages } from '@manypkg/get-packages';
+import { detectYarnVersion } from './yarn';
+import { runOutput } from '@backstage/cli-common';
+import { NotFoundError } from '@backstage/errors';
+
+const DEP_TYPES = [
+  'dependencies',
+  'devDependencies',
+  'peerDependencies',
+  'optionalDependencies',
+] as const;
+
+// Package data as returned by `yarn info`
+export type YarnInfoInspectData = {
+  name: string;
+  'dist-tags': Record<string, string>;
+  versions: string[];
+  time: { [version: string]: string };
+};
+
+// Possible `yarn info` output
+type YarnInfo = {
+  type: 'inspect';
+  data: YarnInfoInspectData | { type: string; data: unknown };
+};
+
+type PkgVersionInfo = {
+  range: string;
+  name: string;
+  location: string;
+};
+
+export async function fetchPackageInfo(
+  name: string,
+): Promise<YarnInfoInspectData> {
+  const yarnVersion = await detectYarnVersion();
+
+  const cmd = yarnVersion === 'classic' ? ['info'] : ['npm', 'info'];
+  try {
+    const output = await runOutput(['yarn', ...cmd, '--json', name]);
+
+    if (!output) {
+      throw new NotFoundError(
+        `No package information found for package ${name}`,
+      );
+    }
+
+    if (yarnVersion === 'berry') {
+      return JSON.parse(output) as YarnInfoInspectData;
+    }
+
+    const info = JSON.parse(output) as YarnInfo;
+    if (info.type !== 'inspect') {
+      throw new Error(`Received unknown yarn info for ${name}, ${output}`);
+    }
+
+    return info.data as YarnInfoInspectData;
+  } catch (error) {
+    if (yarnVersion === 'classic') {
+      throw error;
+    }
+
+    if (
+      error instanceof Error &&
+      'stdout' in error &&
+      typeof error.stdout === 'string' &&
+      error.stdout.includes('Response Code: 404')
+    ) {
+      throw new NotFoundError(
+        `No package information found for package ${name}`,
+      );
+    }
+
+    throw error;
+  }
+}
+
+/** Map all dependencies in the repo as dependency => dependents */
+export async function mapDependencies(
+  targetDir: string,
+  pattern: string,
+): Promise<Map<string, PkgVersionInfo[]>> {
+  const { packages, root } = await getPackages(targetDir);
+
+  // Include root package.json too
+  packages.push(root);
+
+  const dependencyMap = new Map<string, PkgVersionInfo[]>();
+  for (const pkg of packages) {
+    const deps = DEP_TYPES.flatMap(
+      t => Object.entries(pkg.packageJson[t] ?? {}) as [string, string][],
+    );
+
+    for (const [name, range] of deps) {
+      if (minimatch(name, pattern)) {
+        dependencyMap.set(
+          name,
+          (dependencyMap.get(name) ?? []).concat({
+            range,
+            name: pkg.packageJson.name,
+            location: pkg.dir,
+          }),
+        );
+      }
+    }
+  }
+
+  return dependencyMap;
+}

packages/cli/src/modules/migrate/lib/versioning/yarn.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2022 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { assertError, ForwardedError } from '@backstage/errors';
+import { runOutput } from '@backstage/cli-common';
+
+const versions = new Map<string, Promise<'classic' | 'berry'>>();
+
+export function detectYarnVersion(dir?: string): Promise<'classic' | 'berry'> {
+  const cwd = dir ?? process.cwd();
+  if (versions.has(cwd)) {
+    return versions.get(cwd)!;
+  }
+
+  const promise = Promise.resolve().then(async () => {
+    try {
+      const stdout = await runOutput(['yarn', '--version'], {
+        cwd,
+      });
+      return stdout.trim().startsWith('1.') ? 'classic' : 'berry';
+    } catch (error) {
+      assertError(error);
+      throw new ForwardedError('Failed to determine yarn version', error);
+    }
+  });
+
+  versions.set(cwd, promise);
+  return promise;
+}