@wise/wds-codemods 0.0.1-experimental-6c2101b

package/src/utils/__tests__/getOptions.test.ts

@@ -0,0 +1,219 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { confirm, input, select as list } from '@inquirer/prompts';
+
+import getOptions from '../getOptions';
+
+jest.mock('@inquirer/prompts', () => ({
+  select: jest.fn(),
+  input: jest.fn(),
+  confirm: jest.fn(),
+}));
+
+describe('getOptions', () => {
+  const transformFiles = ['fileA.js', 'fileB.ts', 'fileC.tsx'];
+
+  beforeEach(() => {
+    process.argv = ['node', 'script.js'];
+    (list as jest.Mock).mockClear();
+    (input as jest.Mock).mockClear();
+    (confirm as jest.Mock).mockClear();
+  });
+
+  it('should return options from command line arguments when provided', async () => {
+    process.argv = ['node', 'script.js', 'fileB.ts', './src', '--dry', '--print'];
+    const options = await getOptions(transformFiles);
+    expect(options).toEqual({
+      transformFile: 'fileB.ts',
+      targetPath: './src',
+      dry: true,
+      print: true,
+      gitignore: true,
+      ignorePattern: undefined,
+      isMonorepo: false,
+    });
+  });
+
+  it('should parse --ignore-pattern argument from CLI', async () => {
+    process.argv = [
+      'node',
+      'script.js',
+      'fileA.js',
+      './src',
+      '--ignore-pattern',
+      'node_modules/**',
+    ];
+    const options = await getOptions(transformFiles);
+    expect(options.ignorePattern).toBe('node_modules/**');
+    expect(options.isMonorepo).toBe(false);
+  });
+
+  it('should parse --monorepo argument from CLI', async () => {
+    process.argv = ['node', 'script.js', 'fileA.js', './packages', '--monorepo'];
+    const options = await getOptions(transformFiles);
+    expect(options.isMonorepo).toBe(true);
+  });
+
+  it('should parse --gitignore and --no-gitignore arguments from CLI and prioritize --gitignore', async () => {
+    process.argv = ['node', 'script.js', 'fileA.js', './src', '--gitignore', '--no-gitignore'];
+    const options = await getOptions(transformFiles);
+    expect(options.gitignore).toBe(true);
+
+    process.argv = ['node', 'script.js', 'fileA.js', './src', '--no-gitignore'];
+    const optionsNo = await getOptions(transformFiles);
+    expect(optionsNo.gitignore).toBe(false);
+  });
+
+  it('should prompt for ignorePattern and gitignore when no CLI args', async () => {
+    (list as jest.Mock).mockResolvedValue('fileB.ts');
+    (input as jest.Mock).mockResolvedValueOnce('./output').mockResolvedValueOnce('node_modules/**');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const options = await getOptions(transformFiles);
+
+    expect(input).toHaveBeenCalledWith({
+      message: 'Enter ignore pattern(s) (comma separated) or leave empty:',
+      validate: expect.any(Function),
+    });
+    expect(confirm).toHaveBeenCalledWith({
+      message: 'Respect .gitignore files?',
+      default: true,
+    });
+    expect(options.ignorePattern).toBe('node_modules/**');
+    expect(options.gitignore).toBe(true);
+    expect(options.isMonorepo).toBe(true);
+  });
+
+  it('should prompt for monorepo when target path looks like monorepo directory', async () => {
+    (list as jest.Mock).mockResolvedValue('fileB.ts');
+    (input as jest.Mock).mockResolvedValueOnce('./packages').mockResolvedValueOnce('');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const options = await getOptions(transformFiles);
+
+    expect(confirm).toHaveBeenCalledWith({
+      message: 'Are you targeting a monorepo packages/apps directory?',
+      default: true,
+    });
+    expect(options.isMonorepo).toBe(true);
+  });
+
+  it('should prompt for transform file, target path, dry mode, and print when no arguments are provided', async () => {
+    (list as jest.Mock).mockResolvedValue('fileB.ts');
+    (input as jest.Mock).mockResolvedValueOnce('./output').mockResolvedValueOnce('');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const options = await getOptions(transformFiles);
+
+    expect(list).toHaveBeenCalledWith({
+      message: 'Select a codemod transform to run:',
+      choices: transformFiles.map((file) => ({ name: file, value: file })),
+    });
+    expect(input).toHaveBeenCalledWith({
+      message: 'Enter the target directory or file path to run codemod on:',
+      validate: expect.any(Function),
+    });
+    expect(confirm).toHaveBeenCalledWith({
+      message: 'Run in dry mode (no changes written to files)?',
+      default: true,
+    });
+    expect(confirm).toHaveBeenCalledWith({
+      message: 'Print transformed source to console?',
+      default: false,
+    });
+    expect(options).toEqual({
+      transformFile: 'fileB.ts',
+      targetPath: './output',
+      dry: true,
+      print: false,
+      gitignore: true,
+      ignorePattern: '',
+      isMonorepo: false,
+    });
+  });
+
+  it('should handle target path validation error', async () => {
+    (list as jest.Mock).mockResolvedValue('fileA.js');
+    (input as jest.Mock).mockResolvedValueOnce('./valid-path').mockResolvedValueOnce('');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    await getOptions(transformFiles);
+
+    expect(input).toHaveBeenCalledTimes(2);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const validateFn = (input as jest.Mock).mock.calls[0][0].validate!;
+    expect(validateFn('   ')).toBe('Target path cannot be empty');
+    expect(validateFn('./valid-path')).toBe(true);
+    expect(input).toHaveBeenCalledWith({
+      message: 'Enter the target directory or file path to run codemod on:',
+      validate: expect.any(Function),
+    });
+  });
+
+  it('should allow changing the default dry mode', async () => {
+    (list as jest.Mock).mockResolvedValue('fileC.tsx');
+    (input as jest.Mock).mockResolvedValueOnce('./another-path').mockResolvedValueOnce('');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const options = await getOptions(transformFiles);
+
+    expect(confirm).toHaveBeenCalledWith({
+      message: 'Run in dry mode (no changes written to files)?',
+      default: true,
+    });
+    expect(options.dry).toBe(false);
+  });
+
+  it('should allow changing the default print mode', async () => {
+    (list as jest.Mock).mockResolvedValue('fileA.js');
+    (input as jest.Mock).mockResolvedValueOnce('./yet-another-path').mockResolvedValueOnce('');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const options = await getOptions(transformFiles);
+
+    expect(confirm).toHaveBeenCalledWith({
+      message: 'Print transformed source to console?',
+      default: false,
+    });
+    expect(options.print).toBe(true);
+  });
+
+  it('should not prompt for monorepo when target path does not look like monorepo directory', async () => {
+    (list as jest.Mock).mockResolvedValue('fileA.js');
+    (input as jest.Mock).mockResolvedValueOnce('./src').mockResolvedValueOnce('');
+    (confirm as jest.Mock)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const options = await getOptions(transformFiles);
+
+    expect(confirm).toHaveBeenCalledTimes(4);
+    expect(options.isMonorepo).toBe(false);
+  });
+});

package/src/utils/__tests__/handleError.test.ts

@@ -0,0 +1,18 @@
+import handleError from '../handleError';
+
+describe('handleError', () => {
+  beforeEach(() => {
+    jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit called');
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should throw an error with the given message', () => {
+    const errorMessage = 'Test error message';
+    expect(() => handleError(errorMessage)).toThrow(new Error('process.exit called'));
+  });
+});

package/src/utils/__tests__/hasPackageVersion.test.ts

@@ -0,0 +1,191 @@
+import { existsSync, readdirSync, readFileSync, type Stats, statSync } from 'node:fs';
+
+import hasPackageVersion, { packageVersionCache } from '../hasPackageVersion';
+
+jest.mock('node:fs');
+
+const mockExistsSync = existsSync as jest.MockedFunction<typeof existsSync>;
+const mockReadFileSync = readFileSync as jest.MockedFunction<typeof readFileSync>;
+const mockReaddirSync = readdirSync as jest.MockedFunction<typeof readdirSync>;
+const mockStatSync = statSync as jest.MockedFunction<typeof statSync>;
+const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+describe('hasPackageVersion', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockExistsSync.mockReturnValue(false);
+
+    const mockStats: Partial<Stats> = {
+      isFile: jest.fn(() => false),
+      isDirectory: jest.fn(() => true),
+      isBlockDevice: jest.fn(() => false),
+      isCharacterDevice: jest.fn(() => false),
+      isFIFO: jest.fn(() => false),
+      isSocket: jest.fn(() => false),
+      isSymbolicLink: jest.fn(() => false),
+    };
+
+    mockStatSync.mockReturnValue(mockStats as Stats);
+    packageVersionCache.clear();
+    consoleSpy.mockClear();
+  });
+
+  afterAll(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it('finds package in package.json dependencies', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        dependencies: {
+          '@transferwise/components': '46.5.0',
+        },
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+  });
+
+  it('finds package in standard node_modules directory', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return (
+        pathStr.includes('node_modules/@transferwise/components/package.json') &&
+        !pathStr.includes('.pnpm')
+      );
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        version: '46.5.0',
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+  });
+
+  it('finds package in pnpm node_modules structure', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return (
+        pathStr.includes('node_modules/.pnpm') ||
+        pathStr.includes(
+          '@transferwise+components@46.5.0/node_modules/@transferwise/components/package.json',
+        )
+      );
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    mockReaddirSync.mockReturnValue([
+      '@transferwise+components@46.5.0',
+      'other-package@1.0.0',
+    ] as any);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        version: '46.5.0',
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+  });
+
+  it('returns false when package is not found', () => {
+    mockExistsSync.mockReturnValue(false);
+
+    expect(hasPackageVersion('@nonexistent/package', '>=1.0.0')).toBe(false);
+  });
+
+  it('returns false when version does not satisfy requirement', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        dependencies: {
+          '@transferwise/components': '40.0.0',
+        },
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(false);
+  });
+
+  it('handles malformed JSON gracefully', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue('invalid json');
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(false);
+  });
+
+  it('finds package in devDependencies', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        devDependencies: {
+          '@transferwise/components': '46.5.0',
+        },
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+  });
+
+  it('finds package in peerDependencies', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        peerDependencies: {
+          '@transferwise/components': '>=46.5.0',
+        },
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+  });
+
+  it('handles complex version ranges', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        dependencies: {
+          '@transferwise/components': '^46.5.0',
+        },
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+  });
+
+  it('uses cache for repeated calls', () => {
+    mockExistsSync.mockImplementation((path) => {
+      const pathStr = String(path);
+      return pathStr.endsWith('package.json') && !pathStr.includes('node_modules');
+    });
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        dependencies: {
+          '@transferwise/components': '46.5.0',
+        },
+      }),
+    );
+
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+    expect(hasPackageVersion('@transferwise/components', '>=46.5.0')).toBe(true);
+    expect(mockReadFileSync).toHaveBeenCalledTimes(2);
+  });
+});

package/src/utils/__tests__/loadTransformModules.test.ts

@@ -0,0 +1,51 @@
+import { promises as fs } from 'fs';
+
+import loadTransformModules from '../loadTransformModules';
+
+jest.mock('fs', () => ({
+  promises: {
+    readdir: jest.fn(),
+  },
+}));
+
+jest.mock('path', () => ({
+  join: jest.fn((...args) => args.join('/')),
+}));
+
+jest.mock(
+  '/mock/transforms/transformA.js',
+  () => ({
+    default: { default: 'transformA' },
+  }),
+  { virtual: true },
+);
+
+jest.mock(
+  '/mock/transforms/transformB.js',
+  () => ({
+    default: { default: 'transformB' },
+  }),
+  { virtual: true },
+);
+
+describe('loadTransformModules - simplified test', () => {
+  it('should return transformModules and transformFiles correctly', async () => {
+    const mockTransformsDir = '/mock/transforms';
+
+    const mockFiles = ['transformA.js', 'transformB.js'];
+    (fs.readdir as jest.Mock).mockResolvedValue(mockFiles);
+
+    const { transformModules, transformFiles } = await loadTransformModules(mockTransformsDir);
+
+    expect(transformModules).toEqual({
+      'transformA.js': {
+        default: 'transformA',
+      },
+      'transformB.js': {
+        default: 'transformB',
+      },
+    });
+
+    expect(transformFiles).toEqual(['transformA', 'transformB']);
+  });
+});

package/src/utils/__tests__/reportManualReview.test.ts

@@ -0,0 +1,42 @@
+import fs from 'node:fs/promises';
+
+import path from 'path';
+
+import reportManualReview from '../reportManualReview';
+
+const REPORT_PATH = path.resolve(process.cwd(), 'codemod-report.txt');
+
+describe('reportManualReview', () => {
+  beforeEach(async () => {
+    try {
+      await fs.access(REPORT_PATH);
+      await fs.unlink(REPORT_PATH);
+    } catch {
+      // File doesn't exist, that's fine
+    }
+    await fs.writeFile(REPORT_PATH, '', 'utf8');
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.access(REPORT_PATH);
+      await fs.unlink(REPORT_PATH);
+    } catch {
+      // File doesn't exist, that's fine
+    }
+  });
+
+  it('writes a manual review entry to the report file', async () => {
+    await reportManualReview('src/file.tsx', 'Manual review required: something at line 10');
+    const content = await fs.readFile(REPORT_PATH, 'utf8');
+    expect(content).toContain('[src/file.tsx:10] Manual review required: something');
+  });
+
+  it('appends multiple manual review entries', async () => {
+    await reportManualReview('src/file1.tsx', 'Manual review required: issue 1');
+    await reportManualReview('src/file2.tsx', 'Manual review required: issue 2');
+    const content = await fs.readFile(REPORT_PATH, 'utf8');
+    expect(content).toContain('[src/file1.tsx] Manual review required: issue 1');
+    expect(content).toContain('[src/file2.tsx] Manual review required: issue 2');
+  });
+});

package/src/utils/getOptions.ts

@@ -0,0 +1,78 @@
+import { confirm, input, select as list } from '@inquirer/prompts';
+import path from 'path';
+
+async function getOptions(transformFiles: string[]) {
+  const args = process.argv.slice(2);
+  if (args.length > 0) {
+    const [transformFile, targetPath] = args;
+    const dry = args.includes('--dry') || args.includes('--dry-run');
+    const print = args.includes('--print');
+    const ignorePatternIndex = args.findIndex((arg) => arg === '--ignore-pattern');
+    let ignorePattern: string | undefined;
+    if (ignorePatternIndex !== -1 && args.length > ignorePatternIndex + 1) {
+      ignorePattern = args[ignorePatternIndex + 1];
+    }
+    const gitignore = args.includes('--gitignore');
+    const noGitignore = args.includes('--no-gitignore');
+    const isMonorepo = args.includes('--monorepo');
+
+    if (!transformFile || !transformFiles.includes(transformFile)) {
+      throw new Error('Invalid transform file specified.');
+    }
+    if (!targetPath) {
+      throw new Error('Target path cannot be empty.');
+    }
+
+    // If both --gitignore and --no-gitignore are specified, prioritize --gitignore
+    const useGitignore = !!(gitignore || (!gitignore && !noGitignore));
+
+    return {
+      transformFile,
+      targetPath,
+      dry,
+      print,
+      ignorePattern,
+      gitignore: useGitignore,
+      isMonorepo,
+    };
+  }
+
+  const transformFile = await list({
+    message: 'Select a codemod transform to run:',
+    choices: transformFiles.map((file) => ({ name: file, value: file })),
+  });
+
+  const targetPath = await input({
+    message: 'Enter the target directory or file path to run codemod on:',
+    validate: (value) => value.trim() !== '' || 'Target path cannot be empty',
+  });
+
+  const isMonorepo = await confirm({
+    message: 'Are you targeting a monorepo packages/apps directory?',
+    default: true,
+  });
+
+  const dry = await confirm({
+    message: 'Run in dry mode (no changes written to files)?',
+    default: true,
+  });
+
+  const print = await confirm({
+    message: 'Print transformed source to console?',
+    default: false,
+  });
+
+  const ignorePattern = await input({
+    message: 'Enter ignore pattern(s) (comma separated) or leave empty:',
+    validate: (value) => true,
+  });
+
+  const gitignore = await confirm({
+    message: 'Respect .gitignore files?',
+    default: true,
+  });
+
+  return { transformFile, targetPath, dry, print, ignorePattern, gitignore, isMonorepo };
+}
+
+export default getOptions;

package/src/utils/handleError.ts

@@ -0,0 +1,6 @@
+function handleError(message: string): void {
+  console.error(message);
+  process.exit(1);
+}
+
+export default handleError;