@elliemae/ds-legacy-codemods 1.0.0-rc.1

package/bin/cli/code-mods/cli.mjs

@@ -0,0 +1,34 @@
+import arg from 'arg';
+import { promptForMissingOptions } from './inquirer-questions-prompter.mjs';
+import { executeCommandsMap } from './command-logics/execute-commands-map.mjs';
+
+function parseArgumentsIntoOptions(rawArgs) {
+  const args = arg(
+    {
+      '--cwd': String,
+      '--globPattern': String,
+      '--globPatternIgnore': String,
+      '--projectFolderPath': String,
+      '--ignorePackagesGlobPattern': String,
+      '--ignoreFilesGlobPattern': String,
+    },
+    {
+      argv: rawArgs.slice(2),
+    },
+  );
+  return {
+    cwd: args['--cwd'],
+    globPattern: args['--globPattern'],
+    globPatternIgnore: args['--globPatternIgnore'],
+    projectFolderPath: args['--projectFolderPath'],
+    ignorePackagesGlobPattern: args['--ignorePackagesGlobPattern'],
+    ignoreFilesGlobPattern: args['--ignoreFilesGlobPattern'],
+    script: args._[0],
+  };
+}
+
+export async function cli(args) {
+  let options = parseArgumentsIntoOptions(args);
+  options = await promptForMissingOptions(options);
+  executeCommandsMap(args, options);
+}

package/bin/cli/code-mods/command-arguments/promptCheckEmPackagesInconsistencies.mjs

@@ -0,0 +1,22 @@
+export const getPackagesInconsistenciesQuestions = (originalOptions) => {
+  const extraOptions = [];
+  const { globPattern, globPatternIgnore } = originalOptions;
+  if (!globPattern && globPattern !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPattern',
+      message:
+        'Please provide a comma separated list of globPatterns catching the file in which to check for inconsistencies',
+      default: './package.json', // './packages/ds-codemods/test-ables/check-packages-inconsistencies/package.json.test',
+    });
+  }
+  if (!globPatternIgnore && globPatternIgnore !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPatternIgnore',
+      message: 'Please provide a comma separated list of ignored files for your globPattern',
+      default: '**/node_modules/**/*',
+    });
+  }
+  return extraOptions;
+};

package/bin/cli/code-mods/command-arguments/promptDeprecatedPackages.mjs

@@ -0,0 +1,13 @@
+export const getDeprecatedPackagesQuestions = (originalOptions) => {
+  const extraOptions = [];
+  const { cwd } = originalOptions;
+  if (!cwd && cwd !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPatternIgnore',
+      message: 'Please provide the project root directory (where node_modules folder lives)',
+      default: './',
+    });
+  }
+  return extraOptions;
+};

package/bin/cli/code-mods/command-arguments/promptFixLegacyImports.mjs

@@ -0,0 +1,21 @@
+export const getLegacyImportsQuestions = (originalOptions) => {
+  const extraOptions = [];
+  const { globPattern, globPatternIgnore } = originalOptions;
+  if (!globPattern && globPattern !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPattern',
+      message: 'Please provide a comma separated list of globPatterns catching the file in which to fix the imports',
+      default: './**/*.js,./**/*.jsx,./**/*.ts,./**/*.tsx',
+    });
+  }
+  if (!globPatternIgnore && globPatternIgnore !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPatternIgnore',
+      message: 'Please provide a comma separated list of ignored files for your globPattern',
+      default: '**/node_modules/**/*',
+    });
+  }
+  return extraOptions;
+};

package/bin/cli/code-mods/command-arguments/promptHelpMigrateToV3.mjs

@@ -0,0 +1,21 @@
+export const getHelpMigrateToV3Questions = (originalOptions) => {
+  const extraOptions = [];
+  const { globPattern, globPatternIgnore } = originalOptions;
+  if (!globPattern && globPattern !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPattern',
+      message: 'Please provide a comma separated list of globPatterns catching the file in which to fix the imports',
+      default: './**/*.js,./**/*.jsx,./**/*.ts,./**/*.tsx',
+    });
+  }
+  if (!globPatternIgnore && globPatternIgnore !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'globPatternIgnore',
+      message: 'Please provide a comma separated list of ignored files for your globPattern',
+      default: '**/node_modules/**/*',
+    });
+  }
+  return extraOptions;
+};

package/bin/cli/code-mods/command-arguments/promptMissingPackages.mjs

@@ -0,0 +1,29 @@
+export const getMissingPackagesQuestions = (originalOptions) => {
+  const extraOptions = [];
+  const { projectFolderPath, ignorePackagesGlobPattern, ignoreFilesGlobPattern } = originalOptions;
+  if (!projectFolderPath && projectFolderPath !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'projectFolderPath',
+      message: 'path to the project folder containing package.json file',
+      default: './',
+    });
+  }
+  if (!ignorePackagesGlobPattern && ignorePackagesGlobPattern !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'ignorePackagesGlobPattern',
+      message: 'Please provide a comma separated list of globPatterns for ignored packages, if any.',
+      default: '',
+    });
+  }
+  if (!ignoreFilesGlobPattern && ignoreFilesGlobPattern !== '') {
+    extraOptions.push({
+      type: 'input',
+      name: 'ignoreFilesGlobPattern',
+      message: 'Please provide a comma separated list of globPatterns for ignored files, if any.',
+      default: '**/*.eslintrc.js',
+    });
+  }
+  return extraOptions;
+};

package/bin/cli/code-mods/command-logics/check-deprecated-packages/constants.mjs

@@ -0,0 +1,87 @@
+export const SEVERITY = {
+  NON_STARTER: ['Failing to upgrade will make the project impossible to start/use', 1],
+  KNOWN_ISSUES: [
+    'The component has unfixable known issues. Failing to upgrade means APP will have to live with those',
+    2,
+  ],
+  FRAGILE_AND_UNMANTAINED: [
+    'Failing to upgrade will make the project fragile and any error will have to be addressed by the APP team',
+    3,
+  ],
+  UNMANTAINED: ['Failing to upgrade will mean that any error will have to be addressed by the APP team', 4],
+};
+
+export const SOLUTIONS = {
+  REMOVED: 'the component has been regarded as supreflous and has hencheforth been removed in favor of examples',
+  NEW_VERSION_BREAKING: 'the component impedes further enhancments/bugfixes, a new version ex-novo has been created.',
+};
+
+export const DEPRECATED_PACKAGES = {
+  '@elliemae/ds-legacy-datagrids': {
+    name: 'data-grid',
+    solution: SOLUTIONS.NEW_VERSION_BREAKING,
+    severity: SEVERITY.KNOWN_ISSUES,
+    // TODO create relative confluence
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Breaking+changes+-+Migration+steps+and+rationale',
+  },
+  '@elliemae/ds-legacy-date-picker': {
+    name: 'date-picker',
+    solution: SOLUTIONS.NEW_VERSION_BREAKING,
+    severity: SEVERITY.KNOWN_ISSUES,
+    // TODO create relative confluence
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Breaking+changes+-+Migration+steps+and+rationale',
+  },
+  '@elliemae/ds-legacy-date-range-picker': {
+    name: 'date-range-picker',
+    solution: SOLUTIONS.NEW_VERSION_BREAKING,
+    severity: SEVERITY.KNOWN_ISSUES,
+    // TODO create relative confluence
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Breaking+changes+-+Migration+steps+and+rationale',
+  },
+  '@elliemae/ds-legacy-date-time-picker': {
+    name: 'date-time-picker',
+    solution: SOLUTIONS.NEW_VERSION_BREAKING,
+    severity: SEVERITY.KNOWN_ISSUES,
+    // TODO create relative confluence
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Breaking+changes+-+Migration+steps+and+rationale',
+  },
+  '@elliemae/ds-legacy-time-picker': {
+    name: 'time-picker',
+    solution: SOLUTIONS.NEW_VERSION_BREAKING,
+    severity: SEVERITY.KNOWN_ISSUES,
+    // TODO create relative confluence
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Breaking+changes+-+Migration+steps+and+rationale',
+  },
+  '@elliemae/ds-legacy-button-group': {
+    name: 'button-group',
+    solution: SOLUTIONS.REMOVED,
+    severity: SEVERITY.NON_STARTER,
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Button+Group+-+Dimsum+2.x',
+  },
+  '@elliemae/ds-legacy-card-array': {
+    name: 'card-array',
+    solution: SOLUTIONS.REMOVED,
+    severity: SEVERITY.NON_STARTER,
+    confluence: 'https://confluence.elliemae.io/display/FEAE/Card+Array+-+Dimsum+2.x',
+  },
+  '@elliemae/ds-legacy-form': {
+    subComponents: [
+      {
+        name: 'combobox',
+        solution: SOLUTIONS.NEW_VERSION_BREAKING,
+        severity: SEVERITY.FRAGILE_AND_UNMANTAINED,
+        confluence: 'https://confluence.elliemae.io/display/FEAE/Combo-box+-+Dimsum+2.x',
+      },
+    ],
+  },
+  '@elliemae/ds-legacy-combobox-v1': {
+    subComponents: [
+      {
+        name: 'combobox',
+        solution: SOLUTIONS.NEW_VERSION_BREAKING,
+        severity: SEVERITY.FRAGILE_AND_UNMANTAINED,
+        confluence: 'https://confluence.elliemae.io/display/FEAE/Combo-box+-+Dimsum+2.x',
+      },
+    ],
+  },
+};

package/bin/cli/code-mods/command-logics/check-deprecated-packages/getEmDsPackagesFromNPMLS.mjs

@@ -0,0 +1,18 @@
+/* eslint-disable max-statements */
+export function getEmDsPackagesFromNPMLS(npmLsStdout = '') {
+  const dsPackageRegExp = /@elliemae\/ds-.*?@(.*)/gm;
+  const matches = [];
+  if (npmLsStdout) {
+    const npmLsMatches = [...npmLsStdout.matchAll(dsPackageRegExp)];
+    npmLsMatches.forEach(([fullMatch, version]) => {
+      const matchObj = {
+        fullMatch,
+        version,
+        package: fullMatch.split(version)[0].slice(0, -1),
+      };
+      matches.push(matchObj);
+    });
+  }
+
+  return matches;
+}

package/bin/cli/code-mods/command-logics/check-deprecated-packages/index.mjs

@@ -0,0 +1,19 @@
+import { exec } from 'child_process';
+import { getEmDsPackagesFromNPMLS } from './getEmDsPackagesFromNPMLS.mjs';
+import { logResults, logCyanQuestion } from './logResults.mjs';
+
+const npmLs = async ({ cwd }) => {
+  const [, stdout] = await new Promise((resolve) => {
+    exec('npm ls', { cwd }, (...cbRes) => resolve(cbRes));
+  });
+  if (stdout) return getEmDsPackagesFromNPMLS(stdout);
+  return [];
+};
+
+export const checkDeprecatedPackages = async (options) => {
+  const installedPackages = await npmLs(options);
+  if (installedPackages.length === 0) logCyanQuestion('no dimsum packages found... did you specify the correct cwd?');
+  logResults(installedPackages);
+};
+
+export default checkDeprecatedPackages;

package/bin/cli/code-mods/command-logics/check-deprecated-packages/logResults.mjs

@@ -0,0 +1,35 @@
+import {
+  severityLoggingMap,
+  yellowStr,
+  boldCyanStr,
+  boldGreenStr,
+  brightCyanStr,
+  whiteStr,
+} from '../../../utils/CLI_COLORS.mjs';
+import { DEPRECATED_PACKAGES } from './constants.mjs';
+
+const logDeprecatedComponent = ({ name, solution, severity, confluence }) => {
+  const [sevDesc, sevLevel] = severity;
+  const chalkLog = severityLoggingMap[sevLevel];
+  console.log(yellowStr('--------------------------------'));
+  console.log(boldCyanStr(`${name} deprecation!`));
+  console.log(chalkLog(sevDesc));
+  console.log(boldGreenStr(solution));
+  console.log(whiteStr(confluence));
+  console.log(yellowStr('--------------------------------'));
+};
+
+export function logCyanQuestion(question) {
+  console.log(brightCyanStr(question));
+}
+
+export function logResults(detectedPackages) {
+  detectedPackages.forEach((pack) => {
+    const deprecatedMetaInfo = DEPRECATED_PACKAGES[pack.package];
+    if (deprecatedMetaInfo) {
+      const { subComponents, ...metainfo } = deprecatedMetaInfo;
+      if (JSON.stringify(metainfo) !== '{}') logDeprecatedComponent(metainfo);
+      if (subComponents) subComponents.forEach(logDeprecatedComponent);
+    }
+  });
+}

package/bin/cli/code-mods/command-logics/check-missing-packages/index.mjs

@@ -0,0 +1,113 @@
+/* eslint-disable no-console */
+import fs from 'fs';
+import fse from 'fs-extra';
+import path from 'path';
+import depcheck from 'depcheck';
+import {
+  brightYellowStr,
+  brightRedStr,
+  brightMagentaStr,
+  boldBrightCyanStr,
+  greenStr,
+} from '../../../utils/CLI_COLORS.mjs';
+import { generatePathFromCurrentFolder } from '../../../utils/index.mjs';
+
+function generateFolderIfNotExistSync(finalDir) {
+  if (!fs.existsSync(finalDir)) {
+    fs.mkdirSync(finalDir, { recursive: true });
+  }
+}
+
+const overWriteFile = fse.outputFileSync;
+const getPackageName = () => process.cwd().split('/').pop();
+const getRoot = () => process.cwd().split('/packages')[0];
+// everything beetween "root" and "package name" is the "taxonomy" (including the "package name")
+const getTaxonomy = () => process.cwd().split('/packages')[1];
+
+const logUnusedDep = (unused) => {
+  console.log(brightYellowStr('### Found unused dependencies :>>'));
+  console.log('```');
+  console.log(unused.dependencies);
+  console.log('```');
+};
+const logUnusedDevDep = (unused) => {
+  console.log(brightMagentaStr('### Found unused dev dependencies :>>'));
+  console.log('```');
+  console.log(unused.devDependencies);
+  console.log('```');
+};
+const logMissing = (unused) => {
+  const missingString = [...Object.keys(unused.missing)].map((pack) => `\t${pack}`).join(',\n');
+  console.log(brightRedStr('### Found missing dependencies :>>'));
+  console.log('```');
+  console.log('{');
+  console.log(missingString);
+  console.log('}');
+  console.log('```');
+  const root = getRoot();
+  const pck = getPackageName();
+  const taxonomy = getTaxonomy();
+  const folder = `${root}/checkdeps`;
+  try {
+    generateFolderIfNotExistSync(folder);
+    overWriteFile(`${folder}/${pck}.txt`, `${taxonomy}/\n${missingString}`);
+  } catch {
+    console.error('error generating files');
+  }
+};
+
+export const checkMissingPackages = async (options) => {
+  const { projectFolderPath, ignorePackagesGlobPattern, ignoreFilesGlobPattern } = options;
+  const ignorePatterns = ignorePackagesGlobPattern
+    .split(',')
+    .map((pattern) => (pattern && pattern !== '' ? generatePathFromCurrentFolder(pattern) : ''));
+  const ignoreMatches = ignoreFilesGlobPattern
+    .split(',')
+    .map((pattern) => (pattern && pattern !== '' ? generatePathFromCurrentFolder(pattern) : ''));
+  const depCheckOptions = {
+    ignoreBinPackage: false, // ignore the packages with bin entry
+    skipMissing: false, // skip calculation of missing dependencies
+    parsers: {
+      // the target parsers
+      '**/*.js': depcheck.parser.jsx,
+      '**/*.jsx': depcheck.parser.jsx,
+      '**/*.ts': depcheck.parser.typescript,
+      '**/*.tsx': depcheck.parser.typescript,
+    },
+    detectors: [
+      depcheck.detector.requireCallExpression,
+      depcheck.detector.requireResolveCallExpression,
+      depcheck.detector.importDeclaration,
+      depcheck.detector.typescriptImportType,
+      depcheck.detector.exportDeclaration,
+    ],
+    specials: [
+      // the target special parsers
+      depcheck.special.babel,
+      depcheck.special.bin,
+      depcheck.special.eslint,
+      depcheck.special.husky,
+      depcheck.special.jest,
+      depcheck.special.mocha,
+      depcheck.special.prettier,
+      depcheck.special.tslint,
+      depcheck.special.webpack,
+    ],
+    ignorePatterns,
+    ignoreMatches,
+  };
+  const pathToRoot = generatePathFromCurrentFolder(projectFolderPath);
+
+  depcheck(pathToRoot, depCheckOptions).then((unused) => {
+    const unusedDep = Array.isArray(unused.dependencies) && unused.dependencies.length > 0;
+    const unusedDevDep = Array.isArray(unused.devDependencies) && unused.devDependencies.length > 0;
+    const missing = Object.keys(unused.missing).length > 0;
+    const hasErrors = unusedDep || unusedDevDep || missing;
+    console.log(boldBrightCyanStr(`# Dependencies results for ${getPackageName()}`));
+    // console.log(boldBrightCyanStr(`[${pathToRoot}](${pathToRoot}package.json)`));
+    // if (unusedDep) logUnusedDep(unused);
+    // if (unusedDevDep) logUnusedDevDep(unused);
+    if (missing) logMissing(unused, pathToRoot);
+    if (!hasErrors) console.log(greenStr(`no problems found!`));
+  });
+};

package/bin/cli/code-mods/command-logics/check-packages-inconsistencies/getPackageJsonEmDsVersions.mjs

@@ -0,0 +1,43 @@
+/* eslint-disable max-statements */
+export function getPackageJsonEmDsVersions(packageJsonAsString = '') {
+  const dependenciesRegExp = /"dependencies": {(.*?)},?/gs;
+  const devDependenciesRegExp = /"devDependencies": {(.*?)},?/gs;
+  const peerDependenciesRegExp = /"peerDependencies": {(.*?)},?/gs;
+  const dsPackageRegExp = /"@elliemae\/ds-.*?": "(.*?)",?/gm;
+
+  const [dependenciesString] = packageJsonAsString.match(dependenciesRegExp) || [];
+  const [devDependenciesString] = packageJsonAsString.match(devDependenciesRegExp) || [];
+  const [peerDependenciesString] = packageJsonAsString.match(peerDependenciesRegExp) || [];
+
+  const matches = [];
+  const dependenciesMatches = [];
+  const devDependenciesMatches = [];
+  const peerDependenciesMatches = [];
+
+  if (dependenciesString) {
+    const depMatches = [...dependenciesString.matchAll(dsPackageRegExp)];
+    depMatches.forEach(([fullMatch, version]) => {
+      const matchObj = { fullMatch, version, dependencyType: 'dependency' };
+      matches.push(matchObj);
+      dependenciesMatches.push(matchObj);
+    });
+  }
+  if (devDependenciesString) {
+    const devDepMatches = [...devDependenciesString.matchAll(dsPackageRegExp)];
+    devDepMatches.forEach(([fullMatch, version]) => {
+      const matchObj = { fullMatch, version, dependencyType: 'devDependency' };
+      matches.push(matchObj);
+      devDependenciesMatches.push(matchObj);
+    });
+  }
+  if (peerDependenciesString) {
+    const peerDepMatches = [...peerDependenciesString.matchAll(dsPackageRegExp)];
+    peerDepMatches.forEach(([fullMatch, version]) => {
+      const matchObj = { fullMatch, version, dependencyType: 'peerDependency' };
+      matches.push(matchObj);
+      peerDependenciesMatches.push(matchObj);
+    });
+  }
+
+  return { matches, dependenciesMatches, devDependenciesMatches, peerDependenciesMatches };
+}

package/bin/cli/code-mods/command-logics/check-packages-inconsistencies/index.mjs

@@ -0,0 +1,96 @@
+/* eslint-disable max-len */
+/* eslint-disable complexity */
+/* eslint-disable max-statements */
+import fs from 'fs';
+import {
+  yellowStr,
+  boldBrightYellowBgRedStr,
+  brightYellowStr,
+  boldRedStr,
+  boldBrightCyanStr,
+  brightCyanStr,
+  brightGreenStr,
+  redStr,
+} from '../../../utils/CLI_COLORS.mjs';
+import { getPackageJsonEmDsVersions } from './getPackageJsonEmDsVersions.mjs';
+import {
+  generatePathFromCurrentFolder,
+  globArray,
+  getHighestMatchVersion,
+  getLatestDimsumVersion,
+} from '../../../utils/index.mjs';
+
+const getErrors = (highestVersion, matches = []) => {
+  const errors = [];
+  let hasErrors = false;
+  matches.forEach((match) => {
+    const { version } = match;
+    if (version !== highestVersion.fullVersion) {
+      hasErrors = true;
+      errors.push({ ...match, suggestedVersion: highestVersion.fullVersion });
+    }
+  });
+  return { errors, hasErrors };
+};
+export const checkPackagesInconsistencies = async (options) => {
+  const csvGlobs = options.globPattern.split(',').map((pattern) => generatePathFromCurrentFolder(pattern));
+
+  const ignoredPatterns = options.globPatternIgnore.split(',');
+  const globOptions = { ignore: ignoredPatterns };
+
+  const pathToFileToProcess = globArray(csvGlobs, globOptions);
+  const { latestVersionParsed } = await getLatestDimsumVersion();
+
+  console.log(
+    brightCyanStr(
+      `detected latest dimsum version: ${yellowStr(`${latestVersionParsed.major}.${latestVersionParsed.minor}.X`)}`,
+    ),
+  );
+  pathToFileToProcess.forEach((path) => {
+    console.log(`checking ${path} for incosistencies...`);
+    const fileContent = fs.readFileSync(path, {
+      encoding: 'utf8',
+      flag: 'r',
+    });
+    if (fileContent && typeof fileContent === 'string') {
+      const { matches } = getPackageJsonEmDsVersions(fileContent);
+      if (matches) {
+        console.log(brightCyanStr(`Found dimsum dependencies:`), matches);
+        const highestVersion = getHighestMatchVersion(matches);
+        console.log(`checking for incosistencies...`);
+        const { errors, hasErrors } = getErrors(highestVersion, matches);
+
+        if (hasErrors) {
+          console.log(yellowStr('Your Package json has some Elliemae dimsum inconsistencies'));
+          console.log(errors);
+          console.log(yellowStr('Please solve them as soon as possible to avoid unexpected errors'));
+        } else {
+          console.log(yellowStr('no dimsum incosistencies detected!'));
+        }
+        console.log(`checking for outdated version...`);
+        const shouldUpdateToNewest =
+          highestVersion.major < latestVersionParsed.major ||
+          (highestVersion.major === latestVersionParsed.major && highestVersion.minor < latestVersionParsed.minor - 6);
+        if (shouldUpdateToNewest) {
+          console.log(boldBrightYellowBgRedStr('We detected that you are using a version that is too outdated'));
+          console.log(brightYellowStr(`Detected (highest) version:`, boldRedStr(highestVersion.fullVersion)));
+          console.log(brightYellowStr(`Latest version:`, boldBrightCyanStr(latestVersionParsed.fullVersion)));
+          console.log(boldBrightYellowBgRedStr('Please update to the newest version release as soon as possible!'));
+        } else {
+          console.log(yellowStr('you are using an aceptable dimsum version!'));
+        }
+        if (!hasErrors && !shouldUpdateToNewest) console.log(brightGreenStr('no immediate action is required!'));
+        if (highestVersion.minor !== latestVersionParsed.minor)
+          console.log(
+            brightYellowStr(
+              '\tstill, please consider updating to latest version as soon as possible to avoid more difficult updates in the future!',
+            ),
+          );
+      }
+    } else {
+      console.log(redStr(`failed to load package.json file, are you executing this in the right directory?`));
+    }
+  });
+};
+
+export default checkPackagesInconsistencies;

package/bin/cli/code-mods/command-logics/execute-commands-map.mjs

@@ -0,0 +1,31 @@
+import { fixLegacyImports } from './fix-legacy-imports/index.mjs';
+import { checkPackagesInconsistencies } from './check-packages-inconsistencies/index.mjs';
+import { checkMissingPackages } from './check-missing-packages/index.mjs';
+import { checkDeprecatedPackages } from './check-deprecated-packages/index.mjs';
+import { helpMigrateToV3 } from './help-migrate-to-v3/index.mjs';
+import { COMMANDS } from '../commands.mjs';
+
+export async function executeCommandsMap(args, options) {
+  switch (options.script) {
+    case COMMANDS.FIX_LEGACY_IMPORTS:
+      fixLegacyImports(options);
+      break;
+    case COMMANDS.FIX_LEGACY_IMPORTS_REVERT:
+      fixLegacyImports(options, true);
+      break;
+    case COMMANDS.CHECK_PACKAGES_INCONSISTENCIES:
+      checkPackagesInconsistencies(options);
+      break;
+    case COMMANDS.CHECK_MISSING_PACKAGES:
+      checkMissingPackages(options);
+      break;
+    case COMMANDS.CHECK_DEPRECATED_PACKAGES:
+      checkDeprecatedPackages(options);
+      break;
+    case COMMANDS.HELP_MIGRATE_TO_V3:
+      helpMigrateToV3(options);
+      break;
+    default:
+      break;
+  }
+}

package/bin/cli/code-mods/command-logics/fix-legacy-imports/index.mjs

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import fse from 'fs-extra';
+import { generatePathFromCurrentFolder, replaceFromMap, globArray } from '../../../utils/index.mjs';
+import { legacyImportMap, legacyImportMapRevert } from './legacyImportMap.mjs';
+
+export const fixLegacyImports = (options, isRevert = false) => {
+  const csvGlobs = options.globPattern.split(',').map((pattern) => generatePathFromCurrentFolder(pattern));
+
+  const ignoredPatterns = options.globPatternIgnore.split(',');
+  const globOptions = { ignore: ignoredPatterns };
+
+  const pathToFileToProcess = globArray(csvGlobs, globOptions);
+
+  const replaceMap = isRevert ? legacyImportMapRevert : legacyImportMap;
+  console.log('replaceMap :>> ', replaceMap);
+  pathToFileToProcess.forEach((path) => {
+    console.log('path :>> ', path);
+    const fileContent = fs.readFileSync(path, {
+      encoding: 'utf8',
+      flag: 'r',
+    });
+    if (fileContent && typeof fileContent === 'string') {
+      const newContent = replaceFromMap(fileContent, replaceMap);
+      fse.outputFileSync(path, newContent);
+    }
+  });
+};
+
+export default fixLegacyImports;