@wise/wds-codemods 0.0.1-experimental-2eb5228 → 0.0.1-experimental-0d8d466

package/src/transforms/helpers/createTestTransform.ts

@@ -1,59 +1,18 @@
 import type { Options, Transform } from 'jscodeshift';
 import { applyTransform, type TestOptions } from 'jscodeshift/src/testUtils';
 
-interface PackageRequirement {
-  name: string;
-  version: string;
-  found?: boolean; // Optional - defaults to true
-}
-
 /**
  * This function creates a test transform function that applies a given transformer to the input code.
  * It uses the 'tsx' parser to support both TypeScript and JSX syntax.
  *
  * The transform function is used to modify the input code based on the provided transformer.
- *
- * @param transformer - The jscodeshift transformer function
- * @param packageRequirements - Array of package requirements to mock (defaults to empty array)
  */
-function createTestTransform(
-  transformer: Transform,
-  packageRequirements: PackageRequirement[] = [],
-) {
-  // Create mock package results from requirements
-  const packageResults: Record<string, boolean> = {};
-  packageRequirements.forEach((pkg) => {
-    const key = `${pkg.name}@${pkg.version}`;
-    packageResults[key] = pkg.found ?? true; // Default to found unless explicitly set to false
-  });
-
-  const options: Options = {
-    // Only add packageResults if we have package requirements
-    ...(packageRequirements.length > 0 ? { packageResults: JSON.stringify(packageResults) } : {}),
-  };
-
+function createTestTransform(transformer: Transform) {
+  const options: Options = {};
   // Use 'tsx' parser to support both TypeScript and JSX syntax
   const testOptions: TestOptions = { parser: 'tsx' };
-
   return (input: { path?: string; source: string }) =>
     applyTransform(transformer, options, input, testOptions);
 }
 
-// Convenience functions for common use cases
-export const createTestTransformWithPackage = (
-  transformer: Transform,
-  packageName: string,
-  version: string,
-) => {
-  return createTestTransform(transformer, [{ name: packageName, version }]);
-};
-
-export const createTestTransformWithoutPackage = (
-  transformer: Transform,
-  packageName: string,
-  version: string,
-) => {
-  return createTestTransform(transformer, [{ name: packageName, version, found: false }]);
-};
-
 export default createTestTransform;

package/src/transforms/helpers/index.ts

@@ -1,5 +1,5 @@
+export { default as createTestTransform } from './createTestTransform';
 export { default as hasImport } from './hasImport';
 export { default as processIconChildren } from './iconUtils';
 export * from './jsxElementUtils';
 export * from './jsxReportingUtils';
-export * from './packageValidation';

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

@@ -30,7 +30,6 @@ describe('getOptions', () => {
       print: true,
       gitignore: true,
       ignorePattern: undefined,
-      isMonorepo: false,
     });
   });
 
@@ -45,13 +44,6 @@ describe('getOptions', () => {
     ];
     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 () => {
@@ -68,12 +60,12 @@ describe('getOptions', () => {
     (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);
+    const optionsPromise = getOptions(transformFiles);
+    const options = await optionsPromise;
 
     expect(input).toHaveBeenCalledWith({
       message: 'Enter ignore pattern(s) (comma separated) or leave empty:',
@@ -85,35 +77,22 @@ describe('getOptions', () => {
     });
     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);
+  it('should throw an error if transform file is invalid via command line', async () => {
+    process.argv = ['node', 'script.js', 'invalid.js', './dist'];
+    await expect(getOptions(transformFiles)).rejects.toThrow('Invalid transform file specified.');
+  });
 
-    expect(confirm).toHaveBeenCalledWith({
-      message: 'Are you targeting a monorepo packages/apps directory?',
-      default: true,
-    });
-    expect(options.isMonorepo).toBe(true);
+  it('should throw an error if target path is empty via command line', async () => {
+    process.argv = ['node', 'script.js', 'fileA.js', ''];
+    await expect(getOptions(transformFiles)).rejects.toThrow('Target path cannot be empty.');
   });
 
   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);
+    (input as jest.Mock).mockResolvedValue('./output');
+    (confirm as jest.Mock).mockResolvedValueOnce(true).mockResolvedValueOnce(false);
 
     const options = await getOptions(transformFiles);
 
@@ -138,20 +117,15 @@ describe('getOptions', () => {
       targetPath: './output',
       dry: true,
       print: false,
-      gitignore: true,
-      ignorePattern: '',
-      isMonorepo: false,
+      gitignore: undefined,
+      ignorePattern: './output',
     });
   });
 
   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);
+    (input as jest.Mock).mockResolvedValueOnce('   ');
+    (confirm as jest.Mock).mockResolvedValue(true);
 
     await getOptions(transformFiles);
 
@@ -159,7 +133,7 @@ describe('getOptions', () => {
     // 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(validateFn('./valid-path')).toBe(true); // Ensure valid input passes validation
     expect(input).toHaveBeenCalledWith({
       message: 'Enter the target directory or file path to run codemod on:',
       validate: expect.any(Function),
@@ -168,12 +142,8 @@ describe('getOptions', () => {
 
   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);
+    (input as jest.Mock).mockResolvedValue('./another-path');
+    (confirm as jest.Mock).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
     const options = await getOptions(transformFiles);
 
@@ -186,12 +156,8 @@ describe('getOptions', () => {
 
   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);
+    (input as jest.Mock).mockResolvedValue('./yet-another-path');
+    (confirm as jest.Mock).mockResolvedValueOnce(true).mockResolvedValueOnce(true);
 
     const options = await getOptions(transformFiles);
 
@@ -201,19 +167,4 @@ describe('getOptions', () => {
     });
     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/getOptions.ts

@@ -1,5 +1,4 @@
 import { confirm, input, select as list } from '@inquirer/prompts';
-import path from 'path';
 
 async function getOptions(transformFiles: string[]) {
   const args = process.argv.slice(2);
@@ -14,7 +13,6 @@ async function getOptions(transformFiles: string[]) {
     }
     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.');
@@ -26,15 +24,7 @@ async function getOptions(transformFiles: string[]) {
     // If both --gitignore and --no-gitignore are specified, prioritize --gitignore
     const useGitignore = !!(gitignore || (!gitignore && !noGitignore));
 
-    return {
-      transformFile,
-      targetPath,
-      dry,
-      print,
-      ignorePattern,
-      gitignore: useGitignore,
-      isMonorepo,
-    };
+    return { transformFile, targetPath, dry, print, ignorePattern, gitignore: useGitignore };
   }
 
   const transformFile = await list({
@@ -47,11 +37,6 @@ async function getOptions(transformFiles: string[]) {
     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,
@@ -72,7 +57,7 @@ async function getOptions(transformFiles: string[]) {
     default: true,
   });
 
-  return { transformFile, targetPath, dry, print, ignorePattern, gitignore, isMonorepo };
+  return { transformFile, targetPath, dry, print, ignorePattern, gitignore };
 }
 
 export default getOptions;

package/src/transforms/helpers/__tests__/packageValidation.test.ts

@@ -1,45 +0,0 @@
-import type { Options } from 'jscodeshift';
-
-import { validatePackageRequirements } from '../packageValidation';
-
-describe('validatePackageRequirements', () => {
-  const requirements = [{ name: '@transferwise/components', version: '>=46.5.0' }];
-
-  beforeEach(() => {
-    jest.spyOn(console, 'debug').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('returns true when package is found (object format)', () => {
-    const options: Options = {
-      packageResults: { '@transferwise/components@>=46.5.0': true },
-    };
-
-    expect(validatePackageRequirements(options, requirements)).toBe(true);
-  });
-
-  it('returns true when package is found (JSON string format)', () => {
-    const options: Options = {
-      packageResults: '{"@transferwise/components@>=46.5.0":true}',
-    };
-
-    expect(validatePackageRequirements(options, requirements)).toBe(true);
-  });
-
-  it('returns false when package is missing', () => {
-    const options: Options = {
-      packageResults: { '@transferwise/components@>=46.5.0': false },
-    };
-
-    expect(validatePackageRequirements(options, requirements)).toBe(false);
-  });
-
-  it('returns false when no packageResults provided', () => {
-    const options: Options = {};
-
-    expect(validatePackageRequirements(options, requirements)).toBe(false);
-  });
-});

package/src/transforms/helpers/packageValidation.ts

@@ -1,53 +0,0 @@
-import type { Options } from 'jscodeshift';
-
-interface PackageRequirement {
-  name: string;
-  version: string;
-}
-
-/**
- * Check if package requirements are met
- * Returns true if all packages are found, false otherwise
- */
-export function validatePackageRequirements(
-  options: Options,
-  requirements: PackageRequirement[],
-): boolean {
-  let packageResults: Record<string, boolean> = {};
-
-  // Handle both string and object cases
-  if (options.packageResults) {
-    if (typeof options.packageResults === 'string') {
-      // Parse JSON string
-      try {
-        if (options.packageResults.trim() && options.packageResults.trim().startsWith('{')) {
-          packageResults = JSON.parse(options.packageResults) as Record<string, boolean>;
-        }
-      } catch (error) {
-        console.debug('Failed to parse packageResults:', error);
-        return false;
-      }
-    } else if (typeof options.packageResults === 'object') {
-      // Already an object, use directly
-      packageResults = options.packageResults as Record<string, boolean>;
-    }
-  }
-
-  // Check if all requirements are met
-  const allRequirementsMet = requirements.every((req) => {
-    const key = `${req.name}@${req.version}`;
-    return packageResults[key];
-  });
-
-  if (!allRequirementsMet) {
-    const missing = requirements.filter((req) => {
-      const key = `${req.name}@${req.version}`;
-      return !packageResults[key];
-    });
-
-    const missingPackages = missing.map((pkg) => `${pkg.name}@${pkg.version}`).join(', ');
-    console.debug(`Skipping transform - missing required packages: ${missingPackages}`);
-  }
-
-  return allRequirementsMet;
-}

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

@@ -1,190 +0,0 @@
-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(mockReadFileSync).toHaveBeenCalledTimes(1);
-  });
-});