feat(app-builder): support bun

apps/app-builder/src/commands/upgrade/getComposerPackageVersion.ts → apps/app-builder/src/commands/upgrade/composer/getComposerPackageVersion.ts

@@ -1,6 +1,6 @@
-import {executeCommand} from '../../utils';
-import {type ParsedEntry, type UpgradeSubContext} from './types';
-import {parseGitHubUrl} from './parseGitHubUrl';
+import {type ParsedEntry, type UpgradeSubContext} from '../types';
+import {parseGitHubUrl} from '../parseGitHubUrl';
+import {executeCommand} from '../../../utils';
 
 export const getComposerPackageVersion = async (context: UpgradeSubContext): Promise<ParsedEntry[]> => {
   const {config, packageName} = context;

apps/app-builder/src/commands/upgrade/composer/index.ts

@@ -0,0 +1,2 @@
+export * from './getComposerPackageVersion';
+export * from './upgradeComposerPackage';

apps/app-builder/src/commands/upgrade/upgradeComposerPackage.ts → apps/app-builder/src/commands/upgrade/composer/upgradeComposerPackage.ts

@@ -1,5 +1,5 @@
-import {executeCommand} from '../../utils';
-import {type UpgradeSubMethod} from './types';
+import {type UpgradeSubMethod} from '../types';
+import {executeCommand} from '../../../utils';
 import {getComposerPackageVersion} from './getComposerPackageVersion';
 
 export const upgradeComposerPackage: UpgradeSubMethod = async (context) => {

apps/app-builder/src/commands/upgrade/determineUpgradeMode.ts

@@ -3,5 +3,5 @@ import {UpgradeMode} from './types';
 export const determineUpgradeMode = (packageName: string): UpgradeMode => {
   const isComposerPackage = /^\w+\/\w+$/.exec(packageName);
 
-  return isComposerPackage ? UpgradeMode.Composer : UpgradeMode.Yarn;
+  return isComposerPackage ? UpgradeMode.Composer : UpgradeMode.Node;
 };

apps/app-builder/src/commands/upgrade/getRepositoryUrl.ts

@@ -2,7 +2,7 @@
 import {executeCommand} from '../../utils';
 import {type NpmInfo} from '../../types';
 import {VerbosityLevel} from '../../constants';
-import {type ParsedEntry, UpgradeMode, type UpgradeSubContext} from './types';
+import {NodePackageManager, type ParsedEntry, UpgradeMode, type UpgradeSubContext} from './types';
 import {parseGitHubUrl} from './parseGitHubUrl';
 
 export const getRepositoryUrl = async (entry: ParsedEntry, context: UpgradeSubContext): Promise<undefined | string> => {
@@ -17,8 +17,24 @@ export const getRepositoryUrl = async (entry: ParsedEntry, context: UpgradeSubCo
   const {config, mode} = context;
 
   switch (mode) {
-    case UpgradeMode.Yarn:
-      const stdout = await executeCommand(context, config.yarnCommand, ['npm', 'info', entry.name, '--json'], {});
+    case UpgradeMode.Node:
+      let stdout: string;
+
+      switch (config.nodePackageManager) {
+        case NodePackageManager.Yarn:
+          stdout = await executeCommand(
+            context,
+            config.nodePackageManagerCommand,
+            ['npm', 'info', entry.name, '--json'],
+            {},
+          );
+          break;
+
+        case NodePackageManager.Bun:
+          // TODO: Change this when bun has a command that can do this
+          stdout = await executeCommand(context, 'npm', ['info', entry.name, '--json'], {});
+          break;
+      }
 
       if (!stdout) {
         return;

apps/app-builder/src/commands/upgrade/node/executeNodeUpgrade.ts

@@ -0,0 +1,20 @@
+import {NodePackageManager, type UpgradeSubContextWithLockfile} from '../types';
+import {executeCommand} from '../../../utils';
+
+export const executeNodeUpgrade = async (context: UpgradeSubContextWithLockfile): Promise<void> => {
+  const {config, packageName} = context;
+
+  const upgradeArgs = [];
+
+  switch (config.nodePackageManager) {
+    case NodePackageManager.Bun:
+      upgradeArgs.push('update', packageName);
+      break;
+
+    case NodePackageManager.Yarn:
+      upgradeArgs.push('up', packageName);
+      break;
+  }
+
+  await executeCommand(context, config.nodePackageManagerCommand, upgradeArgs);
+};

apps/app-builder/src/commands/upgrade/node/getDefaultNodeLockfilePath.ts

@@ -0,0 +1,11 @@
+import {NodePackageManager, type UpgradeSubContext} from '../types';
+
+export const getDefaultNodeLockfilePath = (context: UpgradeSubContext): string => {
+  switch (context.config.nodePackageManager) {
+    case NodePackageManager.Yarn:
+      return 'yarn.lock';
+
+    case NodePackageManager.Bun:
+      return 'bun.lockb';
+  }
+};

apps/app-builder/src/commands/upgrade/node/getNodePackageVersion.spec.ts

@@ -0,0 +1,84 @@
+/* eslint-disable max-nested-callbacks */
+import {describe, expect, it, vi} from 'vitest';
+import {toArray} from '@myparcel/ts-utils';
+import {NodePackageManager, UpgradeMode, type UpgradeSubContextWithLockfile} from '../types';
+import {createTestContext} from '../../../__tests__/createTestContext';
+import {getNodePackageVersion} from './getNodePackageVersion';
+
+const mockStdout = vi.fn(() => '');
+
+// mock spawnSync
+vi.mock('child_process', () => ({
+  spawnSync: () => ({
+    status: 0,
+    stdout: mockStdout(),
+  }),
+}));
+
+type TestInput = {
+  packageManager: NodePackageManager;
+  stdout: string | string[];
+};
+
+describe('getNodePackageVersion', () => {
+  it.each([
+    {
+      packageManager: NodePackageManager.Yarn,
+      stdout: [
+        '"@myparcel-eslint/eslint-config-node@npm:1.3.1"',
+        '"@myparcel-pdk/admin@npm:1.0.0-alpha.109"',
+        '"@myparcel-pdk/app-builder@npm:1.0.0-alpha.36"',
+        '"@myparcel-pdk/checkout@npm:1.0.0-alpha.67"',
+        '"@myparcel/ts-utils@npm:1.0.0"',
+        '"eslint@npm:8.0.0"',
+      ],
+    },
+    {
+      packageManager: NodePackageManager.Bun,
+      stdout: [
+        '/path/to/project node_modules',
+        '├── @myparcel-eslint/[email protected]',
+        '├── @myparcel-pdk/[email protected]',
+        '├── @myparcel-pdk/[email protected]',
+        '├── @myparcel-pdk/[email protected]',
+        '├── @myparcel/[email protected]',
+        '└── [email protected]',
+      ],
+    },
+  ] satisfies TestInput[])(
+    'should return the correct package version for $packageManager',
+    async ({packageManager, stdout}) => {
+      const testContext = createTestContext();
+
+      const context = {
+        ...testContext,
+        config: {
+          ...testContext.config,
+          nodePackageManager: packageManager,
+        },
+        lockfilePath: 'yarn.lock',
+        mode: UpgradeMode.Node,
+        packageName: '@myparcel-pdk/*',
+      } satisfies UpgradeSubContextWithLockfile;
+
+      mockStdout.mockImplementationOnce(() => toArray(stdout).join('\n'));
+
+      const res = await getNodePackageVersion(context);
+
+      expect(res).toEqual([
+        {
+          name: '@myparcel-pdk/admin',
+          version: '1.0.0-alpha.109',
+        },
+        {
+          name: '@myparcel-pdk/app-builder',
+          version: '1.0.0-alpha.36',
+        },
+        {
+          name: '@myparcel-pdk/checkout',
+          version: '1.0.0-alpha.67',
+        },
+      ]);
+    },
+  );
+});

apps/app-builder/src/commands/upgrade/node/getNodePackageVersion.ts

@@ -0,0 +1,29 @@
+import {NodePackageManager, type ParsedEntry, type UpgradeSubContextWithLockfile} from '../types';
+import {getPackageEntriesForYarn} from './getPackageEntriesForYarn';
+import {getPackageEntriesForBun} from './getPackageEntriesForBun';
+
+export const getNodePackageVersion = async (context: UpgradeSubContextWithLockfile): Promise<ParsedEntry[]> => {
+  const {lockfilePath, packageName, config} = context;
+
+  const matches: ParsedEntry[] = [];
+
+  const resolvedPackageName = packageName.replace(/\*/g, '.*').replace(/\//g, '\\/');
+
+  switch (config.nodePackageManager) {
+    case NodePackageManager.Yarn:
+      matches.push(...(await getPackageEntriesForYarn(context, resolvedPackageName)));
+
+      break;
+
+    case NodePackageManager.Bun:
+      matches.push(...(await getPackageEntriesForBun(context, resolvedPackageName)));
+
+      break;
+  }
+
+  if (matches.length === 0) {
+    throw new Error(`Package ${packageName} not found in lockfile ${lockfilePath}`);
+  }
+
+  return matches;
+};

apps/app-builder/src/commands/upgrade/node/getPackageEntriesForBun.ts

@@ -0,0 +1,23 @@
+import {type ParsedEntry, type UpgradeSubContextWithLockfile} from '../types';
+import {executeCommand} from '../../../utils';
+
+export async function getPackageEntriesForBun(
+  context: UpgradeSubContextWithLockfile,
+  resolvedPackageName: string,
+): Promise<ParsedEntry[]> {
+  const content = await executeCommand(context, context.config.nodePackageManagerCommand, ['pm', 'ls', '--all']);
+
+  return content
+    .split('\n')
+    .filter((line) => line.includes('@') && new RegExp(resolvedPackageName).test(line))
+    .map((line) => {
+      const regex = new RegExp(`\\s(${resolvedPackageName})@(.*)`);
+
+      const [, name, version] = regex.exec(line) ?? [];
+
+      return {
+        name,
+        version,
+      };
+    });
+}

apps/app-builder/src/commands/upgrade/node/getPackageEntriesForYarn.ts

@@ -0,0 +1,26 @@
+import {type ParsedEntry, type UpgradeSubContextWithLockfile} from '../types';
+import {executeCommand} from '../../../utils';
+
+export async function getPackageEntriesForYarn(
+  context: UpgradeSubContextWithLockfile,
+  resolvedPackageName: string,
+): Promise<ParsedEntry[]> {
+  const {config} = context;
+
+  const content = await executeCommand(context, config.nodePackageManagerCommand, [
+    'info',
+    '--all',
+    '--name-only',
+    '--json',
+  ]);
+
+  return content
+    .split('\n')
+    .map((line) => line.replace(/^"(.*)"$/, '$1'))
+    .filter((line) => new RegExp(`^${resolvedPackageName}@npm:`).exec(line))
+    .map((line) => {
+      const [name, version] = line.split('@npm:');
+
+      return {name, version};
+    });
+}

apps/app-builder/src/commands/upgrade/node/index.ts

@@ -0,0 +1,6 @@
+export * from './executeNodeUpgrade';
+export * from './getDefaultNodeLockfilePath';
+export * from './getNodePackageVersion';
+export * from './getPackageEntriesForBun';
+export * from './getPackageEntriesForYarn';
+export * from './upgradeNodePackage';

apps/app-builder/src/commands/upgrade/node/upgradeNodePackage.ts

@@ -0,0 +1,20 @@
+import {type UpgradeSubMethod} from '../types';
+import {getNodePackageVersion} from './getNodePackageVersion';
+import {executeNodeUpgrade} from './executeNodeUpgrade';
+
+export const upgradeNodePackage: UpgradeSubMethod = async (context) => {
+  const {args} = context;
+
+  const oldVersions = await getNodePackageVersion(context);
+
+  if (!args.dryRun) {
+    await executeNodeUpgrade(context);
+  }
+
+  const newVersions = await getNodePackageVersion(context);
+
+  return {
+    oldVersions,
+    newVersions,
+  };
+};

apps/app-builder/src/commands/upgrade/types.ts

@@ -1,18 +1,6 @@
 import {type LiftoffEnv} from 'liftoff';
-import {type Debugger} from 'debug';
 import {type MakeOptional, type PromiseOr} from '@myparcel/ts-utils';
-import {type CommandArgs, type ResolvedPdkBuilderConfig} from '../../types';
-
-export type YarnLockfileEntry = [
-  string,
-  {
-    version: string;
-    resolution: string;
-    checksum: string;
-    languageName: string;
-    linkType: string;
-  },
-];
+import {type CommandArgs, type PdkDebugger, type ResolvedPdkBuilderConfig} from '../../types';
 
 export interface ParsedEntry {
   name: string;
@@ -37,7 +25,7 @@ export type InputUpgradeCommandArgs = MakeOptional<UpgradeCommandArgs, 'composer
 export interface UpgradeSubContext {
   args: UpgradeCommandArgs;
   config: ResolvedPdkBuilderConfig;
-  debug: Debugger;
+  debug: PdkDebugger;
   env: LiftoffEnv;
   mode: UpgradeMode;
   packageName: string;
@@ -54,7 +42,12 @@ export interface UpgradeSubResult {
 
 export type UpgradeSubMethod = (context: UpgradeSubContextWithLockfile) => PromiseOr<UpgradeSubResult>;
 
-export enum UpgradeMode {
+export enum NodePackageManager {
+  Bun = 'bun',
   Yarn = 'yarn',
+}
+
+export enum UpgradeMode {
+  Node = 'node',
   Composer = 'composer',
 }