feat(jest-worker): factory pattern

Author: ayshiff

packages/jest-haste-map/src/index.ts

@@ -546,14 +546,16 @@ class HasteMap extends EventEmitter {
     if (this._options.retainAllFiles && filePath.includes(NODE_MODULES)) {
       if (computeSha1) {
         return this._getWorker(workerOptions)
-          .getSha1({
-            computeDependencies: this._options.computeDependencies,
-            computeSha1,
-            dependencyExtractor: this._options.dependencyExtractor,
-            filePath,
-            hasteImplModulePath: this._options.hasteImplModulePath,
-            rootDir,
-          })
+          .then(workerInstance =>
+            workerInstance.getSha1({
+              computeDependencies: this._options.computeDependencies,
+              computeSha1,
+              dependencyExtractor: this._options.dependencyExtractor,
+              filePath,
+              hasteImplModulePath: this._options.hasteImplModulePath,
+              rootDir,
+            }),
+          )
           .then(workerReply, workerError);
       }
 
@@ -622,14 +624,16 @@ class HasteMap extends EventEmitter {
     }
 
     return this._getWorker(workerOptions)
-      .worker({
-        computeDependencies: this._options.computeDependencies,
-        computeSha1,
-        dependencyExtractor: this._options.dependencyExtractor,
-        filePath,
-        hasteImplModulePath: this._options.hasteImplModulePath,
-        rootDir,
-      })
+      .then(workerInstance =>
+        workerInstance.worker({
+          computeDependencies: this._options.computeDependencies,
+          computeSha1,
+          dependencyExtractor: this._options.dependencyExtractor,
+          filePath,
+          hasteImplModulePath: this._options.hasteImplModulePath,
+          rootDir,
+        }),
+      )
       .then(workerReply, workerError);
   }
 
@@ -714,17 +718,19 @@ class HasteMap extends EventEmitter {
   /**
    * Creates workers or parses files and extracts metadata in-process.
    */
-  private _getWorker(options?: {forceInBand: boolean}): WorkerInterface {
+  private async _getWorker(options?: {
+    forceInBand: boolean;
+  }): Promise<WorkerInterface> {
     if (!this._worker) {
       if ((options && options.forceInBand) || this._options.maxWorkers <= 1) {
         this._worker = {getSha1, worker};
       } else {
         // @ts-expect-error: assignment of a worker with custom properties.
-        this._worker = new Worker(require.resolve('./worker'), {
+        this._worker = (await Worker.create(require.resolve('./worker'), {
           exposedMethods: ['getSha1', 'worker'],
           maxRetries: 3,
           numWorkers: this._options.maxWorkers,
-        }) as WorkerInterface;
+        })) as WorkerInterface;
       }
     }
 

packages/jest-reporters/src/CoverageReporter.ts

@@ -151,7 +151,7 @@ export default class CoverageReporter extends BaseReporter {
     if (this._globalConfig.maxWorkers <= 1) {
       worker = require('./CoverageWorker');
     } else {
-      worker = new Worker(require.resolve('./CoverageWorker'), {
+      worker = await Worker.create(require.resolve('./CoverageWorker'), {
         exposedMethods: ['worker'],
         maxRetries: 2,
         numWorkers: this._globalConfig.maxWorkers,

packages/jest-runner/src/index.ts

@@ -168,7 +168,7 @@ class TestRunner {
       }
     }
 
-    const worker = new Worker(TEST_WORKER_PATH, {
+    const worker = (await Worker.create(TEST_WORKER_PATH, {
       exposedMethods: ['worker'],
       forkOptions: {stdio: 'pipe'},
       maxRetries: 3,
@@ -178,7 +178,7 @@ class TestRunner {
           serializableResolvers: Array.from(resolvers.values()),
         },
       ],
-    }) as WorkerInterface;
+    })) as WorkerInterface;
 
     if (worker.getStdout()) worker.getStdout().pipe(process.stdout);
     if (worker.getStderr()) worker.getStderr().pipe(process.stderr);

packages/jest-worker/README.md

@@ -24,7 +24,7 @@ This example covers the minimal usage:
 import JestWorker from 'jest-worker';
 
 async function main() {
-  const worker = new JestWorker(require.resolve('./Worker'));
+  const worker = await JestWorker.create(require.resolve('./Worker'));
   const result = await worker.hello('Alice'); // "Hello, Alice"
 }
 
@@ -144,7 +144,7 @@ This example covers the standard usage:
 import JestWorker from 'jest-worker';
 
 async function main() {
-  const myWorker = new JestWorker(require.resolve('./Worker'), {
+  const myWorker = await JestWorker.create(require.resolve('./Worker'), {
     exposedMethods: ['foo', 'bar', 'getWorkerId'],
     numWorkers: 4,
   });
@@ -188,7 +188,7 @@ This example covers the usage with a `computeWorkerKey` method:
 import JestWorker from 'jest-worker';
 
 async function main() {
-  const myWorker = new JestWorker(require.resolve('./Worker'), {
+  const myWorker = await JestWorker.create(require.resolve('./Worker'), {
     computeWorkerKey: (method, filename) => filename,
   });
 

packages/jest-worker/src/__performance_tests__/test.js

@@ -93,11 +93,14 @@ function testJestWorker() {
       }
     }
 
-    const farm = new JestWorker(require.resolve('./workers/jest_worker'), {
-      exposedMethods: [method],
-      forkOptions: {execArgv: []},
-      workers: threads,
-    });
+    const farm = await JestWorker.create(
+      require.resolve('./workers/jest_worker'),
+      {
+        exposedMethods: [method],
+        forkOptions: {execArgv: []},
+        workers: threads,
+      },
+    );
 
     farm.getStdout().pipe(process.stdout);
     farm.getStderr().pipe(process.stderr);

packages/jest-worker/src/index.ts

@@ -79,8 +79,6 @@ export default class JestWorker {
     this._options = {...options};
     this._ending = false;
 
-    this._inspectorSession = this.setUpInspector();
-
     const workerPoolOptions: WorkerPoolOptions = {
       enableWorkerThreads: this._options.enableWorkerThreads ?? false,
       forkOptions: this._options.forkOptions ?? {},
@@ -111,19 +109,39 @@ export default class JestWorker {
     this._bindExposedWorkerMethods(workerPath, this._options);
   }
 
-  private setUpInspector() {
-    // Open V8 Inspector
-    inspector.open();
+  public static create = async (
+    workerPath: string,
+    options?: FarmOptions,
+  ): Promise<JestWorker> => {
+    const setUpInspector = async () => {
+      // Open V8 Inspector
+      inspector.open();
+
+      const inspectorUrl = inspector.url();
+      if (inspectorUrl) {
+        const session = new inspector.Session();
+        session.connect();
+        await new Promise((resolve, reject) => {
+          session.post('Debugger.enable', (err: Error) => {
+            if (err === null) {
+              resolve();
+            } else {
+              reject(err);
+            }
+          });
+        });
+        return session;
+      }
+      return undefined;
+    };
+
+    const jestWorker = new JestWorker(workerPath, options);
+    const inspectorSession = await setUpInspector();
 
-    const inspectorUrl = inspector.url();
-    let session;
-    if (inspectorUrl !== undefined) {
-      session = new inspector.Session();
-      session.connect();
-      session.post('Debugger.enable');
-    }
-    return session;
-  }
+    jestWorker._inspectorSession = inspectorSession;
+
+    return jestWorker;
+  };
 
   private _bindExposedWorkerMethods(
     workerPath: string,