feat: Optional codemod for migrating enums (#2543)

packages/codemod/bin/vibe-codemod.ts

@@ -12,7 +12,8 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
 const mapMigrationType: { [key: string]: string } = {
-  v3: "v2-to-v3"
+  v3: "v2-to-v3",
+  enums: "v2-to-v3/enums"
 };
 
 const migrations = Object.keys(mapMigrationType);
@@ -21,7 +22,7 @@ const argv = yargs(hideBin(process.argv))
   .option("migration", {
     alias: "m",
     type: "string",
-    description: "Migration type to run (e.g., v3)",
+    description: "Migration type to run (e.g., v3, enums)",
     choices: migrations
   })
   .option("target", {
@@ -112,6 +113,15 @@ async function main() {
     }
   }
 
+  const isVibeCoreInstalled = checkIfPackageExists("@vibe/core");
+  if (migrationType === "v3" && !isVibeCoreInstalled) {
+    console.log(chalk.yellow("Warning: You need to install @vibe/core package to fully apply the v3 migration."));
+  }
+  if (migrationType === "enums" && !isVibeCoreInstalled) {
+    console.log(chalk.red("Error: Please install @vibe/core to run the enum migration."));
+    process.exit(1);
+  }
+
   if (!isGitClean()) {
     console.warn(
       chalk.yellow(
@@ -126,6 +136,34 @@ async function main() {
     }
   }
 
+  async function processTransformations(transformationFiles: string[], type = "Transformation") {
+    for (let index = 0; index < transformationFiles.length; index++) {
+      const transform = transformationFiles[index];
+      const transformName = path.basename(transform, path.extname(transform));
+
+      spinner.text = `Processing ${type.toLowerCase()} (${index + 1}/${transformationFiles.length}): ${transformName}`;
+
+      try {
+        const result = await runSingleTransformation(transform);
+
+        if (result) {
+          successCount++;
+          spinner.succeed(chalk.green(`${type} completed: ${transformName}`));
+        } else {
+          failureCount++;
+          spinner.fail(chalk.red(`${type} finished with errors: ${transformName}`));
+        }
+      } catch (error) {
+        failureCount++;
+        spinner.fail(chalk.red(`${type} failed: ${transformName}`));
+      }
+
+      if (index < transformationFiles.length - 1) {
+        spinner.start();
+      }
+    }
+  }
+
   const verbosityLevel: number = verbose ? 2 : 0;
   const outputTarget: string = verbose ? `>> "${logFile}"` : "";
 
@@ -204,40 +242,19 @@ async function main() {
     process.exit(1);
   }
 
-  const filesToProcessLast = [
-    resolve(transformationsDir, "type-imports-migration.js"),
-    resolve(transformationsDir, "packages-rename-migration.js")
-  ];
+  const filesToProcessLast =
+    migrationType === "v3"
+      ? [
+          resolve(transformationsDir, "type-imports-migration.js"),
+          resolve(transformationsDir, "packages-rename-migration.js")
+        ]
+      : [];
   const orderedTransformationFiles = [
     ...transformationFiles.filter(file => !filesToProcessLast.includes(file)),
     ...filesToProcessLast
   ];
 
-  for (let index = 0; index < orderedTransformationFiles.length; index++) {
-    const transform = orderedTransformationFiles[index];
-    const transformName = path.basename(transform, path.extname(transform));
-
-    spinner.text = `Processing transformation (${index + 1}/${orderedTransformationFiles.length}): ${transformName}`;
-
-    try {
-      const result = await runSingleTransformation(transform);
-
-      if (result) {
-        successCount++;
-        spinner.succeed(chalk.green(`Transformation completed: ${transformName}`));
-      } else {
-        failureCount++;
-        spinner.fail(chalk.red(`Transformation finished with errors: ${transformName}`));
-      }
-    } catch (error) {
-      failureCount++;
-      spinner.fail(chalk.red(`Transformation failed: ${transformName}`));
-    }
-
-    if (index < orderedTransformationFiles.length - 1) {
-      spinner.start();
-    }
-  }
+  await processTransformations(orderedTransformationFiles);
 
   spinner.stop();
 
@@ -250,4 +267,16 @@ async function main() {
   }
 }
 
+function checkIfPackageExists(packageName: string): boolean {
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    console.error(chalk.red(`Error: package.json not found at ${packageJsonPath}`));
+    process.exit(1);
+  }
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  const dependencies = packageJson.dependencies || {};
+  const version = dependencies[packageName];
+  return !!version;
+}
+
 main();

packages/codemod/src/utils/import-utils.ts

@@ -15,8 +15,8 @@ export function getImports(root: Collection, path: string): Collection<ImportDec
 /**
  * Retrieves all "monday-ui-react-core" import declarations for a root.
  */
-export function getCoreImportsForFile(root: Collection): Collection<ImportDeclaration> {
-  return getImports(root, CORE_IMPORT_PATH);
+export function getCoreImportsForFile(root: Collection, path = CORE_IMPORT_PATH): Collection<ImportDeclaration> {
+  return getImports(root, path);
 }
 
 /**

packages/codemod/transformations/core/v2-to-v3/enums/Enums-migration.ts

@@ -0,0 +1,49 @@
+import { TransformationContext } from "../../../../types";
+import { getCoreImportsForFile, getPropValue, setPropValue, wrap } from "../../../../src/utils";
+import enumToStringMapping from "./enumMappings.json";
+import { NEW_CORE_IMPORT_PATH } from "../../../../src/consts";
+
+const enumToString: Record<string, string> = enumToStringMapping;
+
+/**
+ * Replace enums with string equivalent
+ */
+function transform({ j, root }: TransformationContext) {
+  // Since it runs after the imports are updated need to get the new import path
+  const coreImports = getCoreImportsForFile(root, NEW_CORE_IMPORT_PATH);
+
+  const importedComponents = coreImports
+    .find(j.ImportSpecifier)
+    .nodes()
+    .map(importSpecifier => {
+      if (importSpecifier.local && importSpecifier.local.name) {
+        return importSpecifier.local.name;
+      }
+      return null;
+    })
+    .filter(Boolean);
+
+  const allElements = root.find(j.JSXElement).nodes();
+
+  const elements = allElements.filter(path => {
+    const openingElement = path.openingElement;
+    const elementName = openingElement.name.type === "JSXIdentifier" ? openingElement.name.name : null;
+    return elementName && importedComponents.includes(elementName);
+  });
+
+  if (!elements.length) return;
+  elements.forEach(elementPath => {
+    const props = j(elementPath).find(j.JSXOpeningElement).find(j.JSXAttribute);
+    props.forEach(prop => {
+      const propValue = getPropValue(j, prop.node) as string;
+      if (enumToString[propValue]) {
+        setPropValue(j, prop, {
+          value: enumToString[propValue],
+          type: "Literal"
+        });
+      }
+    });
+  });
+}
+
+export default wrap(transform);

packages/codemod/transformations/core/v2-to-v3/enums/__tests__/Enums-migration.test.ts

@@ -0,0 +1,41 @@
+import transform from "../Enums-migration";
+import { defineInlineTest } from "jscodeshift/src/testUtils";
+
+function prependImport(source: string): string {
+  return `
+    import { Button } from "@vibe/core";
+    ${source}
+  `;
+}
+
+describe("Enums migration", () => {
+  defineInlineTest(
+    transform,
+    {},
+    prependImport(`<Button kind={Button.kinds.PRIMARY}/>`),
+    prependImport(`<Button kind="primary"/>`),
+    "should update enum"
+  );
+
+  defineInlineTest(
+    transform,
+    {},
+    prependImport(`<Button kind={Button.kinds.SECONDARY} size={Button.sizes.SMALL} />`),
+    prependImport(`<Button kind="secondary" size="small" />`),
+    "should update enum"
+  );
+
+  defineInlineTest(
+    transform,
+    {},
+    `
+      import { Button } from "another-library";
+      <Button size={Button.sizes.SMALL} />
+    `,
+    `
+      import { Button } from "another-library";
+      <Button size={Button.sizes.SMALL} />
+    `,
+    "should not change component is not imported from vibe"
+  );
+});