feat: run tasks in parallel with workers

Author: satya164

packages/react-native-builder-bob/src/index.ts

@@ -7,12 +7,8 @@ import { cosmiconfig } from 'cosmiconfig';
 import isGitDirty from 'is-git-dirty';
 import prompts, { type PromptObject } from './utils/prompts';
 import * as logger from './utils/logger';
-import buildCommonJS from './targets/commonjs';
-import buildModule from './targets/module';
-import buildTypescript from './targets/typescript';
-import buildCodegen from './targets/codegen';
-import customTarget from './targets/custom';
 import type { Options, Target } from './types';
+import { run } from './utils/workerize';
 
 type ArgName = 'target';
 
@@ -530,51 +526,36 @@ async function buildTarget(
   const targetName = Array.isArray(target) ? target[0] : target;
   const targetOptions = Array.isArray(target) ? target[1] : undefined;
 
-  const report = logger.grouped(targetName);
-
   switch (targetName) {
     case 'commonjs':
-      await buildCommonJS({
-        root,
-        source: path.resolve(root, source),
-        output: path.resolve(root, output, 'commonjs'),
-        exclude,
-        options: targetOptions,
-        report,
-      });
-      break;
     case 'module':
-      await buildModule({
+      await run(targetName, {
         root,
         source: path.resolve(root, source),
-        output: path.resolve(root, output, 'module'),
+        output: path.resolve(root, output, targetName),
         exclude,
         options: targetOptions,
-        report,
       });
       break;
     case 'typescript':
-      await buildTypescript({
+      await run('typescript', {
         root,
         source: path.resolve(root, source),
         output: path.resolve(root, output, 'typescript'),
         options: targetOptions,
-        report,
       });
       break;
     case 'codegen':
-      await buildCodegen({
+      await run('codegen', {
         root,
         source: path.resolve(root, source),
         output: path.resolve(root, output, 'typescript'),
-        report,
       });
       break;
     case 'custom':
-      await customTarget({
+      await run('custom', {
         options: targetOptions,
         source: path.resolve(root, source),
-        report,
         root,
       });
       break;

packages/react-native-builder-bob/src/targets/codegen/patches/patchCodegenAndroidPackage.ts

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import type { Report } from '../../../types';
+import kleur from 'kleur';
 
 export const CODEGEN_DOCS =
   'https://reactnative.dev/docs/the-new-architecture/using-codegen#configuring-codegen';
@@ -50,7 +51,9 @@ export async function patchCodegenAndroidPackage(
   // If this issue is ever fixed in react-native, this check will prevent the patching from running.
   if (!(await fs.pathExists(codegenJavaPath))) {
     report.info(
-      `Could not find ${codegenJavaPath}. Skipping patching codegen java files.`
+      `Could not find ${kleur.blue(
+        path.relative(projectPath, codegenJavaPath)
+      )}. Skipping patching codegen java files.`
     );
     return;
   }

packages/react-native-builder-bob/src/utils/workerize.ts

@@ -0,0 +1,98 @@
+import {
+  Worker,
+  isMainThread,
+  parentPort,
+  workerData,
+} from 'node:worker_threads';
+import type { Report, Target } from '../types';
+import * as logger from './logger';
+import commonjs from '../targets/commonjs';
+import module from '../targets/module';
+import typescript from '../targets/typescript';
+import codegen from '../targets/codegen';
+import custom from '../targets/custom';
+
+type WorkerData<T extends Target> = {
+  target: T;
+  data: Omit<Parameters<(typeof targets)[T]>[0], 'report'>;
+};
+
+const targets = {
+  commonjs,
+  module,
+  typescript,
+  codegen,
+  custom,
+} as const;
+
+export const run = async <T extends Target>(
+  target: T,
+  data: Omit<Parameters<(typeof targets)[T]>[0], 'report'>
+) => {
+  if (!isMainThread) {
+    throw new Error('Worker can only be run from the main thread');
+  }
+
+  const worker = new Worker(__filename, {
+    workerData: {
+      target,
+      data,
+    } satisfies WorkerData<T>,
+    env: {
+      ...process.env,
+      FORCE_COLOR: process.stdout.isTTY ? '1' : '0',
+    },
+  });
+
+  const report = logger.grouped(target);
+
+  worker.on('message', (message) => {
+    switch (message.type) {
+      case 'info':
+        report.info(message.message);
+        break;
+      case 'warn':
+        report.warn(message.message);
+        break;
+      case 'error':
+        report.error(message.message);
+        break;
+      case 'success':
+        report.success(message.message);
+        break;
+      default:
+        console.error('Unknown message type', message);
+    }
+  });
+
+  worker.on('error', (error) => {
+    console.log(error);
+  });
+
+  worker.on('exit', (code) => {
+    if (code !== 0) {
+      report.error(`Failed to build ${target} with code ${code}`);
+    }
+  });
+};
+
+if (!isMainThread) {
+  const { target, data } = workerData as WorkerData<Target>;
+
+  const report: Report = {
+    info: (message) => parentPort?.postMessage({ type: 'info', message }),
+    warn: (message) => parentPort?.postMessage({ type: 'warn', message }),
+    error: (message) => parentPort?.postMessage({ type: 'error', message }),
+    success: (message) => parentPort?.postMessage({ type: 'success', message }),
+  };
+
+  if (target in targets) {
+    // @ts-expect-error - typescript doesn't support correlated union types https://github.com/microsoft/TypeScript/issues/30581
+    targets[target]({ ...data, report }).catch((error) => {
+      console.log(error);
+      process.exit(1);
+    });
+  } else {
+    throw new Error(`Unknown target: ${target}`);
+  }
+}

yarn.lock

@@ -4689,9 +4689,9 @@ __metadata:
   linkType: hard
 
 "caniuse-lite@npm:^1.0.30001406, caniuse-lite@npm:^1.0.30001640":
-  version: 1.0.30001645
-  resolution: "caniuse-lite@npm:1.0.30001645"
-  checksum: a4808bac31fdcdf183ce12f8c86d101e515b2df3423ae4284b930b493809ae88b3396b52ca2a197a3de3c94046ee5384cc9f0efeff5ccfb7c8cd385229527596
+  version: 1.0.30001704
+  resolution: "caniuse-lite@npm:1.0.30001704"
+  checksum: ac8c1b625198c9fdf03f55ef631a0917d29d368ded8e8b2e6a3111cb7433c30b2ef16a6dc44077fb6176e76881a51818d55f24efd04478f5e98b6724b64a8f5c
   languageName: node
   linkType: hard