fix: worker process termination and logging

This commit refactors the code in compileTypesAsync.ts to improve the termination of the worker process and enhance the logging. The worker process termination now includes sending an 'exit' message to the worker and setting the worker variable to null. Additionally, the logging messages now include the specific run number of the worker process. This change improves the overall reliability and clarity of the code.

Author: steven-pribilinskiy

src/compileTypes/compileTypesAsync.ts

@@ -16,10 +16,11 @@ export function compileTypesAsync(
 ): Promise<void> {
   const logger = getLogger();
   workerIndex++;
+  const innerWorkerIndex = workerIndex;
 
   return new Promise((resolve, reject) => {
     if (worker) {
-      logger.log(`Terminating existing worker process #${workerIndex}`);
+      logger.log(`Terminating existing worker process #${innerWorkerIndex}`);
       worker.postMessage({ type: 'exit' });
     }
 
@@ -29,43 +30,43 @@ export function compileTypesAsync(
     worker.on('message', (result: CompileTypesWorkerResultMessage) => {
       switch (result.status) {
         case 'log':
-          logger[result.level](`[Worker #${workerIndex}]:`, result.message);
+          logger[result.level](`[Worker] run #${innerWorkerIndex}:`, result.message);
           return;
         case 'success':
           resolve();
           break;
         case 'failure':
           logger.warn(
-            `[Worker #${workerIndex}]: Failed to compile types for exposed modules.`,
+            `[Worker] run #${innerWorkerIndex}: Failed to compile types for exposed modules.`,
             loggerHint,
           );
           reject(new Error('Failed to compile types for exposed modules.'));
           break;
         case 'error':
           logger.warn(
-            `[Worker #${workerIndex}]: Error compiling types for exposed modules.`,
+            `[Worker] run #${innerWorkerIndex}: Error compiling types for exposed modules.`,
             loggerHint,
           );
           reject(result.error);
           break;
       }
-      worker?.terminate();
+      worker?.postMessage({ type: 'exit' });
       worker = null;
     });
 
     worker.on('error', error => {
-      logger.warn(`[Worker #${workerIndex}]: Unexpected error.`, loggerHint);
+      logger.warn(`[Worker] run #${innerWorkerIndex}: Unexpected error.`, loggerHint);
       logger.log(error);
       reject(error);
-      worker?.terminate();
+      worker?.postMessage({ type: 'exit' });
       worker = null;
     });
 
     worker.on('exit', code => {
       if (code === null || code === 0) {
         resolve();
       } else {
-        reject(new Error(`[Worker #${workerIndex}]: Process exited with code ${code}`));
+        reject(new Error(`[Worker] run #${innerWorkerIndex}: Process exited with code ${code}`));
       }
       worker = null;
     });