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

package/src/utils/hasPackageVersion.ts

@@ -1,459 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
-
-import { execSync } from 'child_process';
-import semver from 'semver';
-import { parse as parseYaml } from 'yaml';
-
-interface PackageJson {
-  name?: string;
-  version?: string;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  optionalDependencies?: Record<string, string>;
-  workspaces?: string[] | { packages: string[] };
-}
-
-interface CheckOptions {
-  silent: boolean;
-  limitedScope: boolean;
-  checkType?: 'dependencies' | 'nodeModules';
-}
-
-export const packageVersionCache = new Map<string, boolean>();
-
-export default function hasPackageVersion(
-  packageName: string,
-  versionRequirement: string,
-): boolean {
-  return hasPackageVersionFromPath(packageName, versionRequirement, process.cwd(), false);
-}
-
-export function hasPackageVersionFromPath(
-  packageName: string,
-  versionRequirement: string,
-  startPath: string,
-  isMonorepo = false,
-): boolean {
-  const cacheKey = `${packageName}@${versionRequirement}@${startPath}@${isMonorepo}`;
-
-  if (packageVersionCache.has(cacheKey)) {
-    return packageVersionCache.get(cacheKey)!;
-  }
-
-  let result: boolean;
-
-  if (isMonorepo) {
-    const projectRoot = findProjectRoot(startPath);
-    const allWorkspacePackages = projectRoot ? getWorkspacePackages(projectRoot) : [];
-
-    // Filter workspace packages to only include those within the target directory
-    const resolvedStartPath = path.resolve(startPath);
-    const targetWorkspacePackages = allWorkspacePackages.filter((packagePath) =>
-      path.resolve(packagePath).startsWith(resolvedStartPath),
-    );
-
-    if (targetWorkspacePackages.length > 0) {
-      result = checkWorkspacePackages(
-        projectRoot!,
-        packageName,
-        versionRequirement,
-        targetWorkspacePackages,
-      );
-    } else {
-      // Fallback to checking the target directory directly for packages
-      result = checkMonorepoPackages(startPath, packageName, versionRequirement);
-    }
-  } else {
-    result = checkSinglePackage(startPath, packageName, versionRequirement);
-  }
-
-  packageVersionCache.set(cacheKey, result);
-  return result;
-}
-
-function getWorkspacePackages(projectRoot: string): string[] {
-  return [
-    ...new Set([
-      ...extractWorkspacesFromPackageJson(projectRoot),
-      ...extractWorkspacesFromPnpmWorkspace(projectRoot),
-    ]),
-  ];
-}
-
-function extractWorkspacesFromPackageJson(projectRoot: string): string[] {
-  const packageJsonPath = path.join(projectRoot, 'package.json');
-
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as PackageJson;
-    const patterns = Array.isArray(packageJson.workspaces)
-      ? packageJson.workspaces
-      : (packageJson.workspaces?.packages ?? []);
-
-    return expandWorkspacePatterns(projectRoot, patterns);
-  } catch {
-    return [];
-  }
-}
-
-function extractWorkspacesFromPnpmWorkspace(projectRoot: string): string[] {
-  const pnpmWorkspacePath = path.join(projectRoot, 'pnpm-workspace.yaml');
-
-  try {
-    const content = readFileSync(pnpmWorkspacePath, 'utf8');
-
-    const { packages = [] } = parseYaml(content) as { packages?: string[] };
-    return expandWorkspacePatterns(projectRoot, packages);
-  } catch {
-    return [];
-  }
-}
-
-function expandWorkspacePatterns(projectRoot: string, patterns: string[]): string[] {
-  return patterns.flatMap((pattern) => {
-    if (pattern.includes('**')) {
-      return findPackagesRecursively(projectRoot, pattern);
-    }
-
-    const parts = pattern.split('/');
-    const packages: string[] = [];
-
-    function searchPath(currentPath: string, remainingParts: string[]): void {
-      if (remainingParts.length === 0) {
-        if (isPackageDirectory(currentPath)) packages.push(currentPath);
-        return;
-      }
-
-      const [part, ...rest] = remainingParts;
-
-      if (part === '*') {
-        try {
-          readdirSync(currentPath, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .forEach((entry) => searchPath(path.join(currentPath, entry.name), rest));
-        } catch {}
-      } else {
-        const nextPath = path.join(currentPath, part);
-        if (existsSync(nextPath)) searchPath(nextPath, rest);
-      }
-    }
-
-    searchPath(projectRoot, parts);
-    return packages;
-  });
-}
-
-function findPackagesRecursively(projectRoot: string, pattern: string): string[] {
-  const packages: string[] = [];
-  const prefix = pattern.split('**')[0].replace(/\/$/u, '');
-  const startPath = path.join(projectRoot, prefix);
-
-  function walk(currentPath: string, depth = 0): void {
-    if (depth > 8 || !existsSync(currentPath)) return;
-
-    try {
-      readdirSync(currentPath, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .forEach((entry) => {
-          const fullPath = path.join(currentPath, entry.name);
-          if (isPackageDirectory(fullPath)) packages.push(fullPath);
-          walk(fullPath, depth + 1);
-        });
-    } catch {}
-  }
-
-  walk(startPath);
-  return packages;
-}
-
-function isPackageDirectory(dirPath: string): boolean {
-  try {
-    return statSync(dirPath).isDirectory() && existsSync(path.join(dirPath, 'package.json'));
-  } catch {
-    return false;
-  }
-}
-
-function checkWorkspacePackages(
-  projectRoot: string,
-  packageName: string,
-  versionRequirement: string,
-  workspacePaths: string[],
-): boolean {
-  const foundPackages: string[] = [];
-  const notFoundPackages: string[] = [];
-
-  for (const workspacePath of workspacePaths) {
-    const packageDir = path.basename(workspacePath);
-    const found = checkPackageInDirectory(workspacePath, packageName, versionRequirement, {
-      silent: true,
-      limitedScope: true,
-    });
-
-    (found ? foundPackages : notFoundPackages).push(packageDir);
-  }
-
-  console.log(`📁 Found ${workspacePaths.length} packages to check`);
-
-  if (foundPackages.length > 0) {
-    console.log(
-      `✅ Found ${packageName} in ${foundPackages.length}/${workspacePaths.length} packages:`,
-    );
-    console.log(`   📦 ${foundPackages.join(', ')}`);
-
-    if (notFoundPackages.length > 0) {
-      console.log(`❌ Not found in ${notFoundPackages.length} packages:`);
-      console.log(`   📦 ${notFoundPackages.join(', ')}`);
-    }
-  } else {
-    console.log(`❌ Package ${packageName} not found in any of ${workspacePaths.length} packages`);
-    if (notFoundPackages.length > 0) {
-      console.log(`   📦 Checked: ${notFoundPackages.join(', ')}`);
-    }
-  }
-
-  return foundPackages.length > 0;
-}
-
-function checkMonorepoPackages(
-  packagesPath: string,
-  packageName: string,
-  versionRequirement: string,
-): boolean {
-  console.log(`📦 Checking monorepo packages in: ${packagesPath}`);
-  try {
-    if (!existsSync(packagesPath)) {
-      return false;
-    }
-
-    const packageDirs = readdirSync(packagesPath).filter((entry) =>
-      statSync(path.join(packagesPath, entry)).isDirectory(),
-    );
-
-    console.log(`📁 Found ${packageDirs.length} packages to check`);
-
-    const foundPackages: string[] = [];
-    const notFoundPackages: string[] = [];
-
-    for (const entry of packageDirs) {
-      const packageDir = path.join(packagesPath, entry);
-      const found = checkPackageInDirectory(packageDir, packageName, versionRequirement, {
-        silent: true,
-        limitedScope: true,
-      });
-
-      (found ? foundPackages : notFoundPackages).push(entry);
-    }
-
-    if (foundPackages.length > 0) {
-      console.log(
-        `✅ Found ${packageName} in ${foundPackages.length}/${packageDirs.length} packages:`,
-      );
-      console.log(`   📦 ${foundPackages.join(', ')}`);
-
-      if (notFoundPackages.length > 0) {
-        console.log(`❌ Not found in ${notFoundPackages.length} packages:`);
-        console.log(`   📦 ${notFoundPackages.join(', ')}`);
-      }
-    } else {
-      console.log(`❌ Package ${packageName} not found in any of ${packageDirs.length} packages`);
-      console.log(`   📦 Checked: ${notFoundPackages.join(', ')}`);
-    }
-
-    return foundPackages.length > 0;
-  } catch (error) {
-    console.log(`⚠️ Error checking monorepo packages:`, error);
-    return false;
-  }
-}
-
-function checkSinglePackage(
-  packagePath: string,
-  packageName: string,
-  versionRequirement: string,
-): boolean {
-  return checkPackageInDirectory(packagePath, packageName, versionRequirement, {
-    silent: true,
-    limitedScope: true,
-  });
-}
-
-function checkPackageInDirectory(
-  startPath: string,
-  packageName: string,
-  versionRequirement: string,
-  options: CheckOptions,
-): boolean {
-  const { checkType } = options;
-  const packageJsonResult = checkDirectDependencies(
-    startPath,
-    packageName,
-    versionRequirement,
-    options,
-  );
-
-  if (checkType === 'dependencies') return packageJsonResult;
-  if (packageJsonResult) return true;
-  if (checkType === 'nodeModules')
-    return checkNodeModules(startPath, packageName, versionRequirement, options);
-
-  return checkNodeModules(startPath, packageName, versionRequirement, options);
-}
-
-function checkDirectDependencies(
-  startPath: string,
-  packageName: string,
-  versionRequirement: string,
-  { limitedScope }: CheckOptions,
-): boolean {
-  const checker = (dir: string) =>
-    checkPackageJsonInDirectory(dir, packageName, versionRequirement);
-  return limitedScope ? checker(startPath) : walkDirectoryTree(startPath, checker);
-}
-
-function checkNodeModules(
-  startPath: string,
-  packageName: string,
-  versionRequirement: string,
-  { limitedScope }: CheckOptions,
-): boolean {
-  const checker = (dir: string) =>
-    checkStandardNodeModules(dir, packageName, versionRequirement) ||
-    checkPnpmNodeModules(dir, packageName, versionRequirement);
-
-  return limitedScope ? checker(startPath) : walkDirectoryTree(startPath, checker);
-}
-
-function walkDirectoryTree(startPath: string, checkFunction: (dir: string) => boolean): boolean {
-  let currentDir =
-    existsSync(startPath) && statSync(startPath).isFile() ? path.dirname(startPath) : startPath;
-
-  currentDir = path.resolve(currentDir);
-
-  const { root } = path.parse(currentDir);
-  let dirCount = 0;
-  let previousDir = '';
-
-  while (currentDir !== root && currentDir !== previousDir && dirCount < 10) {
-    dirCount += 1;
-
-    if (checkFunction(currentDir)) {
-      return true;
-    }
-
-    previousDir = currentDir;
-    currentDir = path.dirname(currentDir);
-  }
-
-  return false;
-}
-
-function checkPackageJsonInDirectory(
-  dir: string,
-  packageName: string,
-  versionRequirement: string,
-): boolean {
-  const packageJsonPath = path.join(dir, 'package.json');
-
-  if (!existsSync(packageJsonPath)) return false;
-
-  try {
-    const packageJson: PackageJson = JSON.parse(
-      readFileSync(packageJsonPath, 'utf8'),
-    ) as PackageJson;
-    const allDeps = {
-      ...(packageJson.dependencies ?? {}),
-      ...(packageJson.devDependencies ?? {}),
-      ...(packageJson.peerDependencies ?? {}),
-      ...(packageJson.optionalDependencies ?? {}),
-    };
-
-    const installedVersion = allDeps[packageName];
-    return installedVersion ? isVersionSatisfied(installedVersion, versionRequirement) : false;
-  } catch {
-    return false;
-  }
-}
-
-function isVersionSatisfied(installedVersion: string, versionRequirement: string): boolean {
-  if (semver.valid(installedVersion) && semver.satisfies(installedVersion, versionRequirement)) {
-    return true;
-  }
-
-  const cleanVersion = semver.coerce(installedVersion);
-  return cleanVersion ? semver.satisfies(cleanVersion.version, versionRequirement) : false;
-}
-
-function checkStandardNodeModules(
-  baseDir: string,
-  packageName: string,
-  versionRequirement: string,
-): boolean {
-  const packagePath = path.join(baseDir, 'node_modules', packageName, 'package.json');
-  if (!existsSync(packagePath)) return false;
-
-  try {
-    const packageJson: PackageJson = JSON.parse(readFileSync(packagePath, 'utf8')) as PackageJson;
-    return packageJson.version ? semver.satisfies(packageJson.version, versionRequirement) : false;
-  } catch {
-    return false;
-  }
-}
-
-function checkPnpmNodeModules(
-  baseDir: string,
-  packageName: string,
-  versionRequirement: string,
-): boolean {
-  const pnpmDir = path.join(baseDir, 'node_modules', '.pnpm');
-  if (!existsSync(pnpmDir)) return false;
-
-  try {
-    const entries = readdirSync(pnpmDir);
-
-    for (const entry of entries) {
-      if (entry.startsWith(packageName.replace('/', '+')) || entry.includes(`${packageName}@`)) {
-        const packagePath = path.join(pnpmDir, entry, 'node_modules', packageName, 'package.json');
-
-        if (existsSync(packagePath)) {
-          const packageJson: PackageJson = JSON.parse(
-            readFileSync(packagePath, 'utf8'),
-          ) as PackageJson;
-          if (packageJson.version && semver.satisfies(packageJson.version, versionRequirement)) {
-            return true;
-          }
-        }
-      }
-    }
-  } catch {
-    // Silent
-  }
-
-  return false;
-}
-
-export function findProjectRoot(startPath: string): string | null {
-  try {
-    const gitRoot = execSync('git rev-parse --show-toplevel', {
-      cwd: startPath,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-
-    return gitRoot && existsSync(gitRoot) ? gitRoot : null;
-  } catch {
-    return null;
-  }
-}
-
-export function findClosestGitignore(startPath: string): string | null {
-  const projectRoot = findProjectRoot(startPath);
-
-  if (!projectRoot) {
-    return null;
-  }
-
-  const gitignorePath = path.join(projectRoot, '.gitignore');
-  return existsSync(gitignorePath) ? gitignorePath : null;
-}