@optimizely/ocp-cli 1.2.6 → 1.2.8

package/src/lib/packageManagerHandler.ts

@@ -0,0 +1,178 @@
+import { TerminalOutput } from './TerminalOutput';
+
+class PackageManagerHandler {
+  public static isLegacyYarnAvailable(): boolean {
+    const [success, output] =
+      PackageManagerHandler.executeCommand('yarn --version');
+    return success && output.startsWith('1.');
+  }
+
+  /**
+   * Retrieves package dependencies based on a scope pattern and production flag.
+   *
+   * @param scope - Regular expression pattern to filter package names
+   * @param prod - When true, only returns production dependencies. Defaults to false
+   * @returns A tuple where:
+   *          - First element is a boolean indicating success/failure
+   *          - Second element is either:
+   *            - On success: An object containing dependency tree data
+   *            - On failure: An error message string
+   *
+   * @remarks
+   * - It uses NPM `ls` and transforms the dependency tree to match Yarn's format
+   *
+   * @throws Will not throw errors directly, but catches and returns them as failure results
+   *
+   * @example
+   * ```typescript
+   * const [success, dependencies] = getPackageDependencies(/^@scope\//, true);
+   * if (success) {
+   *   // Process dependency tree
+   * }
+   * ```
+   */
+  public static getPackageDependencies(
+    scope: RegExp,
+    prod: boolean = false
+  ): [boolean, any] {
+    const command = `npm ls --json ${prod ? '--prod ' : ''}`;
+    try {
+      const [success, output] = PackageManagerHandler.executeCommand(command);
+      if (!success) {
+        return [false, output];
+      }
+
+      // if we're using npm, then we need to parse the tree to have a similar output to yarn
+      const tree = JSON.parse(output);
+      const trees: any[] = [];
+      function collect(deps: Record<string, any> = {}, depth = 0) {
+        for (const [name, info] of Object.entries(deps)) {
+          if (scope.test(name)) {
+            trees.push({
+              name: `${name}@${info.version ?? 'unknown'}`,
+              children: [],
+              hint: null,
+              color: depth === 0 ? 'bold' : null,
+              depth,
+            });
+          }
+          if (info.dependencies) {
+            collect(info.dependencies, depth + 1);
+          }
+        }
+      }
+
+      collect(tree.dependencies);
+
+      return [
+        true,
+        {
+          type: 'tree',
+          data: {
+            type: 'list',
+            trees,
+          },
+        },
+      ];
+    } catch (e) {
+      console.error('Unable to get package dependencies:', e);
+      return [false, 'Unable to get package dependencies.'];
+    }
+  }
+
+  private static executeCommand(command: string): [boolean, string] {
+    const result = TerminalOutput.exec(command);
+    if (result.status === 0) {
+      const output = result.stdout.trim();
+      return [true, output];
+    } else {
+      return [false, result.stderr.trim()];
+    }
+  }
+
+  private targetPackageManager: 'yarn' | 'npm' | 'none' = 'none';
+  constructor(private packageName: string, cli: string) {
+    this.targetPackageManager = this.cliInstalledWith(cli);
+  }
+
+  public getPackageUpgradeCommand(): [boolean, string] {
+    const [possible, error] = this.isUpgradePossible();
+    if (!possible) {
+      return [false, error];
+    }
+
+    return [
+      true,
+      this.useYarn()
+        ? `yarn global upgrade ${this.packageName} --latest`
+        : `npm install --global ${this.packageName}@latest`,
+    ];
+  }
+
+  /**
+   * Upgrades the specified package to its latest version globally.
+   * The function determines whether to use Yarn or NPM based on internal configuration.
+   *
+   * @returns {[boolean, string]} A tuple where:
+   *   - First element (boolean) indicates if the upgrade was successful
+   *   - Second element (string) contains error message if upgrade failed, or success message if upgrade succeeded
+   *
+   * @example
+   * const [success, message] = packageManager.upgradeGlobalPackageToLatest();
+   * if (!success) {
+   *   console.error(`Failed to upgrade package: ${message}`);
+   * }
+   */
+  public upgradeGlobalPackageToLatest(): [boolean, string] {
+    const [possible, error] = this.isUpgradePossible();
+    if (!possible) {
+      return [false, error];
+    }
+
+    const command = this.useYarn()
+      ? `yarn global upgrade ${this.packageName} --latest`
+      : `npm install --global ${this.packageName}@latest`;
+    return PackageManagerHandler.executeCommand(command);
+  }
+
+  public fetchLatestPackage(): [boolean, string] {
+    return PackageManagerHandler.executeCommand(
+      `npm show ${this.packageName} dist-tags.latest`
+    );
+  }
+
+  private isUpgradePossible(): [boolean, string] {
+    if (this.useYarn() && !PackageManagerHandler.isLegacyYarnAvailable()) {
+      return [
+        false,
+        `${this.packageName} is installed using yarn 1.x, but the current version of yarn is not compatible with the upgrade command. Please use npm to install ${this.packageName} instead`,
+      ];
+    }
+    return [true, ''];
+  }
+
+  private cliInstalledWith(cli: string): 'yarn' | 'npm' | 'none' {
+    const whichCommand = process.platform === 'win32' ? 'where' : 'which';
+    const [success, output] = PackageManagerHandler.executeCommand(
+      `${whichCommand} ${cli}`
+    );
+    if (success) {
+      // just in case we have multiple paths, we just take the first one
+      const cliPath = output.split('\n')[0].trim();
+      if (cliPath.includes('yarn')) {
+        // assuming only legacy yarn (1.x) is able to install the cli globally
+        return 'yarn';
+      } else {
+        // else we assume it's npm as this is how we recommend installing the cli
+        return 'npm';
+      }
+    }
+    return 'none';
+  }
+
+  private useYarn(): boolean {
+    return this.targetPackageManager === 'yarn';
+  }
+}
+
+export default PackageManagerHandler;

package/src/test/AppUpdater.test.ts

@@ -0,0 +1,196 @@
+import { AppUpdater } from '../lib/AppUpdater';
+import PackageManagerHandler from '../lib/packageManagerHandler';
+
+jest.mock('../lib/packageManagerHandler');
+
+describe('AppUpdater', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+  describe('getPackageDependencies', () => {
+    it('should parse dependencies correctly', () => {
+      const mockDeps = {
+        type: 'tree',
+        data: {
+          type: 'list',
+          trees: [
+            {
+              name: '@zaiusinc/package1@1.0.0',
+              children: [],
+              hint: null,
+              color: 'bold',
+              depth: 0,
+            },
+            {
+              name: '@zaiusinc/package2@2.0.0',
+              children: [],
+              hint: null,
+              color: 'bold',
+              depth: 0,
+            },
+          ],
+        },
+      };
+
+      (
+        PackageManagerHandler.getPackageDependencies as jest.Mock
+      ).mockReturnValueOnce([true, mockDeps]);
+
+      const result = AppUpdater.getPackageDependencies();
+
+      expect(result).toEqual({
+        '@zaiusinc/package1': '1.0.0',
+        '@zaiusinc/package2': '2.0.0',
+      });
+    });
+
+    it('should handle prod dependencies flag', () => {
+      const mockDeps = {
+        type: 'tree',
+        data: {
+          type: 'list',
+          trees: [
+            {
+              name: '@zaiusinc/package1@1.0.0',
+              children: [],
+              hint: null,
+              color: 'bold',
+              depth: 0,
+            },
+          ],
+        },
+      };
+
+      const mockHandler = (
+        PackageManagerHandler.getPackageDependencies as jest.Mock
+      ).mockReturnValueOnce([true, mockDeps]);
+
+      AppUpdater.getPackageDependencies(true);
+
+      expect(mockHandler).toHaveBeenCalledWith(/@zaiusinc\//, true);
+    });
+
+    describe('error handling', () => {
+      let mockExit: jest.SpyInstance;
+      let mockConsole: jest.SpyInstance;
+      let mockConsoleError: jest.SpyInstance;
+      beforeEach(() => {
+        mockExit = jest
+          .spyOn(process, 'exit')
+          .mockImplementation(() => undefined as never);
+        mockConsole = jest
+          .spyOn(console, 'log')
+          .mockImplementation(() => undefined as never);
+        mockConsoleError = jest
+          .spyOn(console, 'error')
+          .mockImplementation(() => undefined as never);
+      });
+
+      afterEach(() => {
+        mockExit.mockRestore();
+        mockConsole.mockRestore();
+        mockConsoleError.mockRestore();
+      });
+
+      it('should exit with error on package manager failure', () => {
+        (
+          PackageManagerHandler.getPackageDependencies as jest.Mock
+        ).mockReturnValueOnce([false, 'error']);
+
+        AppUpdater.getPackageDependencies();
+
+        expect(mockExit).toHaveBeenCalledWith(1);
+        expect(mockConsoleError).toHaveBeenCalledWith('error');
+      });
+
+      it('should exit with error on exception', () => {
+        (
+          PackageManagerHandler.getPackageDependencies as jest.Mock
+        ).mockImplementation(() => {
+          throw new Error('test error');
+        });
+
+        AppUpdater.getPackageDependencies();
+
+        expect(mockExit).toHaveBeenCalledWith(1);
+        expect(mockConsoleError).toHaveBeenCalledWith(new Error('test error'));
+      });
+    });
+  });
+
+  describe('ensurePublicPackageUsage', () => {
+    let mockExit: jest.SpyInstance;
+    let mockConsoleLog: jest.SpyInstance;
+    let mockConsoleError: jest.SpyInstance;
+
+    beforeEach(() => {
+      mockExit = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => undefined as never);
+      mockConsoleLog = jest
+        .spyOn(console, 'log')
+        .mockImplementation(() => undefined as never);
+      mockConsoleError = jest
+        .spyOn(console, 'error')
+        .mockImplementation(() => undefined as never);
+    });
+
+    afterEach(() => {
+      mockExit.mockRestore();
+      mockConsoleLog.mockRestore();
+      mockConsoleError.mockRestore();
+    });
+
+    it('should allow execution when no deprecated packages are found', () => {
+      const mockDeps = {
+        type: 'tree',
+        data: {
+          type: 'list',
+          trees: [],
+        },
+      };
+
+      (
+        PackageManagerHandler.getPackageDependencies as jest.Mock
+      ).mockReturnValueOnce([true, mockDeps]);
+
+      AppUpdater.ensurePublicPackageUsage();
+
+      expect(mockExit).not.toHaveBeenCalled();
+    });
+
+    it('should exit when deprecated @zaius packages are found', () => {
+      const mockDeps = {
+        type: 'tree',
+        data: {
+          type: 'list',
+          trees: [
+            {
+              name: '@zaius/app-sdk@1.0.0',
+              children: [],
+              hint: null,
+              color: 'bold',
+              depth: 0,
+            },
+          ],
+        },
+      };
+
+      (
+        PackageManagerHandler.getPackageDependencies as jest.Mock
+      ).mockReturnValueOnce([true, mockDeps]);
+
+      AppUpdater.ensurePublicPackageUsage();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        expect.stringContaining(
+          '@zaius/app-sdk & @zaius/node-sdk are no longer supported'
+        )
+      );
+    });
+  });
+});

package/src/test/packageManagerHandler.test.ts

@@ -0,0 +1,190 @@
+/* tslint:disable:max-line-length */
+import PackageManagerHandler from '../lib/packageManagerHandler';
+import { TerminalOutput } from '../lib/TerminalOutput';
+
+jest.mock('../lib/TerminalOutput', () => ({
+  TerminalOutput: {
+    exec: jest.fn(),
+  },
+}));
+
+describe('PackageManagerHandler', () => {
+  let packageManager: PackageManagerHandler;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('isLegacyYarnAvailable', () => {
+    it('should return true when yarn 1.x is available', () => {
+      (TerminalOutput.exec as jest.Mock).mockReturnValue({
+        status: 0,
+        stdout: '1.22.19\n',
+        stderr: '',
+      });
+      expect(PackageManagerHandler.isLegacyYarnAvailable()).toBe(true);
+    });
+
+    it('should return false when yarn 2.x is available', () => {
+      (TerminalOutput.exec as jest.Mock).mockReturnValue({
+        status: 0,
+        stdout: '2.0.0\n',
+        stderr: '',
+      });
+      expect(PackageManagerHandler.isLegacyYarnAvailable()).toBe(false);
+    });
+  });
+
+  describe('upgradeGlobalPackageToLatest', () => {
+    it('should use yarn when the cli is installed using yarn', () => {
+      (TerminalOutput.exec as jest.Mock)
+        .mockReturnValueOnce({
+          status: 0,
+          stdout: '/foo/bar/yarn/bin/test-cli\n',
+          stderr: '',
+        }) // yarn check
+        .mockReturnValueOnce({ status: 0, stdout: '1.22.0', stderr: '' }) // check for yarn 1.x
+        .mockReturnValueOnce({ status: 0, stdout: 'success', stderr: '' }); // upgrade command
+
+      packageManager = new PackageManagerHandler('test-package', 'test-cli');
+      const [success, _] = packageManager.upgradeGlobalPackageToLatest();
+      expect(success).toBe(true);
+      expect(TerminalOutput.exec).toHaveBeenCalledWith(
+        'yarn global upgrade test-package --latest'
+      );
+    });
+
+    it('should notify failure when the cli is installed using yarn 1.x but current yarn version is newer than 1.x', () => {
+      (TerminalOutput.exec as jest.Mock)
+        .mockReturnValueOnce({
+          status: 0,
+          stdout: '/foo/bar/yarn/bin/test-cli\n',
+          stderr: '',
+        }) // yarn check
+        .mockReturnValueOnce({ status: 0, stdout: '2.22.0', stderr: '' }); // check for yarn 1.x
+
+      packageManager = new PackageManagerHandler('test-package', 'test-cli');
+      const [success, message] = packageManager.upgradeGlobalPackageToLatest();
+      expect(success).toBe(false);
+      expect(message).toContain('not compatible');
+    });
+  });
+
+  describe('fetchLatestPackage', () => {
+    it('should fetch latest version using yarn when cli is installed with it', () => {
+      (TerminalOutput.exec as jest.Mock)
+        .mockReturnValueOnce({
+          status: 0,
+          stdout: '/foo/bar/yarn/bin/test-cli\n',
+          stderr: '',
+        }) // yarn check
+        .mockReturnValueOnce({ status: 0, stdout: '1.0.0', stderr: '' }); // fetch command
+
+      packageManager = new PackageManagerHandler('test-package', 'test-cli');
+      const [success, version] = packageManager.fetchLatestPackage();
+      expect(success).toBe(true);
+      expect(version).toBe('1.0.0');
+    });
+  });
+
+  describe('getPackageDependencies', () => {
+    it('should parse npm dependencies into yarn-like format', () => {
+      const mockNpmOutput = JSON.stringify({
+        dependencies: {
+          'test-pkg': {
+            version: '1.0.0',
+            dependencies: {
+              'nested-test': {
+                version: '2.0.0',
+              },
+            },
+          },
+          'other-pkg': {
+            version: '3.0.0',
+          },
+        },
+      });
+
+      (TerminalOutput.exec as jest.Mock).mockReturnValueOnce({
+        status: 0,
+        stdout: mockNpmOutput,
+        stderr: '',
+      }); // list command
+
+      const [success, deps] =
+        PackageManagerHandler.getPackageDependencies(/test/);
+
+      expect(success).toBe(true);
+      expect(deps).toEqual({
+        type: 'tree',
+        data: {
+          type: 'list',
+          trees: [
+            {
+              name: 'test-pkg@1.0.0',
+              children: [],
+              hint: null,
+              color: 'bold',
+              depth: 0,
+            },
+            {
+              name: 'nested-test@2.0.0',
+              children: [],
+              hint: null,
+              color: null,
+              depth: 1,
+            },
+          ],
+        },
+      });
+    });
+  });
+  describe('getPackageUpgradeCommand', () => {
+    it('should return yarn upgrade command when cli is installed with yarn', () => {
+      (TerminalOutput.exec as jest.Mock)
+        .mockReturnValueOnce({
+          status: 0,
+          stdout: '/foo/bar/yarn/bin/test-cli\n',
+          stderr: '',
+        }) // yarn check
+        .mockReturnValueOnce({ status: 0, stdout: '1.22.0', stderr: '' }); // check for yarn 1.x
+
+      packageManager = new PackageManagerHandler('test-package', 'test-cli');
+      const [success, command] = packageManager.getPackageUpgradeCommand();
+      expect(success).toBe(true);
+      expect(command).toBe('yarn global upgrade test-package --latest');
+    });
+
+    it('should return npm upgrade command when cli is installed with npm', () => {
+      (TerminalOutput.exec as jest.Mock).mockReturnValueOnce({
+        status: 0,
+        stdout: '/usr/local/bin/test-cli\n',
+        stderr: '',
+      }); // npm check
+
+      packageManager = new PackageManagerHandler('test-package', 'test-cli');
+      const [success, command] = packageManager.getPackageUpgradeCommand();
+      expect(success).toBe(true);
+      expect(command).toBe('npm install --global test-package@latest');
+    });
+
+    it('should return error when yarn version is not 1.x', () => {
+      (TerminalOutput.exec as jest.Mock)
+        .mockReturnValueOnce({
+          status: 0,
+          stdout: '/foo/bar/yarn/bin/test-cli\n',
+          stderr: '',
+        }) // yarn check
+        .mockReturnValueOnce({ status: 0, stdout: '2.22.0', stderr: '' }); // check for yarn 1.x
+
+      packageManager = new PackageManagerHandler('test-package', 'test-cli');
+      const [success, message] = packageManager.getPackageUpgradeCommand();
+      expect(success).toBe(false);
+      expect(message).toContain('not compatible');
+    });
+  });
+});