[infra] Add cli to extract error codes independent of build

brijeshb42 · brijeshb42 · commit 1a309e59bf40 · 2025-09-04T20:53:32.000+05:30
diff --git a/packages/babel-plugin-minify-errors/index.js b/packages/babel-plugin-minify-errors/index.js
@@ -102,6 +102,68 @@ function handleUnminifyableError(missingError, path) {
   }
 }
 
+/**
+ * @param {babel.types} t
+ * @param {babel.NodePath<babel.types.NewExpression>} newExpressionPath
+ * @param {{ detection: Options['detection']; missingError: MissingError}} param2
+ * @returns {null | { messageNode: babel.types.Expression; messagePath: babel.NodePath<babel.types.ArgumentPlaceholder | babel.types.SpreadElement | babel.types.Expression>; message: { message: string; expressions: babel.types.Expression[] } }}
+ */
+function findMessageNode(t, newExpressionPath, { detection, missingError }) {
+  if (!newExpressionPath.get('callee').isIdentifier({ name: 'Error' })) {
+    return null;
+  }
+
+  switch (detection) {
+    case 'opt-in': {
+      if (
+        !newExpressionPath.node.leadingComments?.some((comment) =>
+          comment.value.includes(COMMENT_OPT_IN_MARKER),
+        )
+      ) {
+        return null;
+      }
+      newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(
+        (comment) => !comment.value.includes(COMMENT_OPT_IN_MARKER),
+      );
+      break;
+    }
+    case 'opt-out': {
+      if (
+        newExpressionPath.node.leadingComments?.some((comment) =>
+          comment.value.includes(COMMENT_OPT_OUT_MARKER),
+        )
+      ) {
+        newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(
+          (comment) => !comment.value.includes(COMMENT_OPT_OUT_MARKER),
+        );
+        return null;
+      }
+
+      break;
+    }
+    default: {
+      throw new Error(`Unknown detection option: ${detection}`);
+    }
+  }
+
+  const messagePath = newExpressionPath.get('arguments')[0];
+  if (!messagePath) {
+    return null;
+  }
+
+  const messageNode = messagePath.node;
+  if (t.isSpreadElement(messageNode) || t.isArgumentPlaceholder(messageNode)) {
+    handleUnminifyableError(missingError, newExpressionPath);
+    return null;
+  }
+  const message = extractMessage(t, messageNode);
+  if (!message) {
+    handleUnminifyableError(missingError, newExpressionPath);
+    return null;
+  }
+  return { messagePath, messageNode, message };
+}
+
 /**
  * Transforms the error message node.
  * @param {babel.types} t
@@ -261,59 +323,15 @@ module.exports = function plugin(
     name: '@mui/internal-babel-plugin-minify-errors',
     visitor: {
       NewExpression(newExpressionPath, state) {
-        if (!newExpressionPath.get('callee').isIdentifier({ name: 'Error' })) {
-          return;
-        }
-
-        switch (detection) {
-          case 'opt-in': {
-            if (
-              !newExpressionPath.node.leadingComments?.some((comment) =>
-                comment.value.includes(COMMENT_OPT_IN_MARKER),
-              )
-            ) {
-              return;
-            }
-            newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(
-              (comment) => !comment.value.includes(COMMENT_OPT_IN_MARKER),
-            );
-            break;
-          }
-          case 'opt-out': {
-            if (
-              newExpressionPath.node.leadingComments?.some((comment) =>
-                comment.value.includes(COMMENT_OPT_OUT_MARKER),
-              )
-            ) {
-              newExpressionPath.node.leadingComments =
-                newExpressionPath.node.leadingComments.filter(
-                  (comment) => !comment.value.includes(COMMENT_OPT_OUT_MARKER),
-                );
-              return;
-            }
-
-            break;
-          }
-          default: {
-            throw new Error(`Unknown detection option: ${detection}`);
-          }
-        }
-
-        const messagePath = newExpressionPath.get('arguments')[0];
-        if (!messagePath) {
-          return;
-        }
-
-        const messageNode = messagePath.node;
-        if (t.isSpreadElement(messageNode) || t.isArgumentPlaceholder(messageNode)) {
-          handleUnminifyableError(missingError, newExpressionPath);
+        const message = findMessageNode(t, newExpressionPath, { detection, missingError });
+        if (!message) {
           return;
         }
 
         const transformedMessage = transformMessage(
           t,
           newExpressionPath,
-          messageNode,
+          message.messageNode,
           state,
           errorCodesLookup,
           missingError,
@@ -322,7 +340,7 @@ module.exports = function plugin(
         );
 
         if (transformedMessage) {
-          messagePath.replaceWith(transformedMessage);
+          message.messagePath.replaceWith(transformedMessage);
         }
       },
     },
@@ -336,3 +354,7 @@ module.exports = function plugin(
     },
   };
 };
+
+module.exports.findMessageNode = findMessageNode;
+
+exports.findMessageNode = findMessageNode;
diff --git a/packages/code-infra/package.json b/packages/code-infra/package.json
@@ -29,6 +29,7 @@
     "@argos-ci/core": "^4.1.0",
     "@babel/cli": "^7.28.3",
     "@babel/core": "^7.28.3",
+    "@babel/plugin-syntax-jsx": "^7.27.1",
     "@babel/plugin-syntax-typescript": "^7.27.1",
     "@babel/plugin-transform-runtime": "^7.28.3",
     "@babel/preset-env": "^7.28.3",
diff --git a/packages/code-infra/src/cli/babel.mjs b/packages/code-infra/src/cli/babel.mjs
@@ -6,6 +6,7 @@ import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { $ } from 'execa';
+import { BASE_IGNORES } from '../utils/build.mjs';
 
 const TO_TRANSFORM_EXTENSIONS = ['.js', '.ts', '.tsx'];
 
@@ -64,18 +65,6 @@ export async function cjsCopy({ from, to }) {
  * @property {string} [runtimeModule] - The runtime module to replace the errors with.
  */
 
-const BASE_IGNORES = [
-  '**/*.test.js',
-  '**/*.test.ts',
-  '**/*.test.tsx',
-  '**/*.spec.js',
-  '**/*.spec.ts',
-  '**/*.spec.tsx',
-  '**/*.d.ts',
-  '**/*.test/*.*',
-  '**/test-cases/*.*',
-];
-
 /**
  * @param {Object} options
  * @param {boolean} [options.verbose=false] - Whether to enable verbose logging.
diff --git a/packages/code-infra/src/cli/cmdExtractErrorCodes.mjs b/packages/code-infra/src/cli/cmdExtractErrorCodes.mjs
@@ -0,0 +1,33 @@
+/* eslint-disable no-console */
+
+import { measurePerf } from '../utils/build.mjs';
+
+/**
+ * @typedef {import('../utils/extractErrorCodes.mjs').Args} Args
+ */
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'extract-error-codes',
+  describe: 'Extracts error codes from package(s).',
+  builder(yargs) {
+    return yargs
+      .option('errorCodeFile', {
+        type: 'string',
+        describe: 'The output path to a json file to write the extracted error codes.',
+        demandOption: true,
+      })
+      .option('skip', {
+        type: 'array',
+        describe: 'List of package names to skip.',
+        default: [],
+      });
+  },
+  async handler(args) {
+    console.log(`🔨 Extracting error codes`);
+    const duration = await measurePerf(/** @type {string} */ (args._[0]), async () => {
+      const module = await import('../utils/extractErrorCodes.mjs');
+      await module.default(args);
+    });
+    console.log(`✅ Extracted error codes in ${(duration / 1000.0).toFixed(3)}s`);
+  },
+});
diff --git a/packages/code-infra/src/cli/index.mjs b/packages/code-infra/src/cli/index.mjs
@@ -10,19 +10,21 @@ import cmdListWorkspaces from './cmdListWorkspaces.mjs';
 import cmdPublish from './cmdPublish.mjs';
 import cmdPublishCanary from './cmdPublishCanary.mjs';
 import cmdSetVersionOverrides from './cmdSetVersionOverrides.mjs';
+import cmdExtractErrorCodes from './cmdExtractErrorCodes.mjs';
 
 const pkgJson = createRequire(import.meta.url)('../../package.json');
 
 yargs()
   .scriptName('code-infra')
+  .command(cmdArgosPush)
+  .command(cmdBuild)
+  .command(cmdCopyFiles)
+  .command(cmdExtractErrorCodes)
+  .command(cmdJsonLint)
+  .command(cmdListWorkspaces)
   .command(cmdPublish)
   .command(cmdPublishCanary)
-  .command(cmdListWorkspaces)
-  .command(cmdJsonLint)
-  .command(cmdArgosPush)
   .command(cmdSetVersionOverrides)
-  .command(cmdCopyFiles)
-  .command(cmdBuild)
   .demandCommand(1, 'You need at least one command before moving on')
   .strict()
   .help()
diff --git a/packages/code-infra/src/untyped-plugins.d.ts b/packages/code-infra/src/untyped-plugins.d.ts
@@ -102,6 +102,13 @@ declare module '@babel/plugin-transform-runtime' {
   export default plugin;
 }
 
+declare module '@babel/plugin-syntax-jsx' {
+  import type { PluginItem } from '@babel/core';
+
+  declare const plugin: PluginItem;
+  export default plugin;
+}
+
 declare module '@babel/plugin-syntax-typescript' {
   import type { PluginItem } from '@babel/core';
 
diff --git a/packages/code-infra/src/utils/build.mjs b/packages/code-infra/src/utils/build.mjs
@@ -68,3 +68,60 @@ export function validatePkgJson(packageJson, options = {}) {
     throw error;
   }
 }
+
+/**
+ * Measures the performance of a function.
+ * @param {string} label - The label for the performance measurement.
+ * @param {Function} fn - The function to measure.
+ * @returns {Promise<number>} - The duration of the function execution in milliseconds.
+ */
+export async function measurePerf(label, fn) {
+  performance.mark(`${label}-start`);
+  await Promise.resolve(fn());
+  performance.mark(`${label}-end`);
+  const measurement = performance.measure(label, `${label}-start`, `${label}-end`);
+  return measurement.duration;
+}
+
+export const BASE_IGNORES = [
+  '**/*.test.js',
+  '**/*.test.ts',
+  '**/*.test.tsx',
+  '**/*.spec.js',
+  '**/*.spec.ts',
+  '**/*.spec.tsx',
+  '**/*.d.ts',
+  '**/*.test/*.*',
+  '**/test-cases/*.*',
+];
+
+/**
+ * @function
+ * @template T
+ * @param {(item: T) => Promise<void>} fn
+ * @param {Object} options
+ * @param {number} options.defaultConcurrency
+ * @param {T[]} options.items
+ * @returns {Promise<void>}
+ */
+export async function wrapInWorker(
+  fn,
+  { defaultConcurrency, items } = { defaultConcurrency: 20, items: [] },
+) {
+  if (items.length === 0) {
+    return;
+  }
+  const itemIterator = items[Symbol.iterator]();
+  const concurrency = Math.min(defaultConcurrency, items.length);
+  const workers = [];
+  for (let i = 0; i < concurrency; i += 1) {
+    const worker = Promise.resolve().then(async () => {
+      for (const item of itemIterator) {
+        // eslint-disable-next-line no-await-in-loop
+        await fn(item);
+      }
+    });
+    workers.push(worker);
+  }
+  await Promise.all(workers);
+}
diff --git a/packages/code-infra/src/utils/extractErrorCodes.mjs b/packages/code-infra/src/utils/extractErrorCodes.mjs
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
