wip: fixing up errors

Author: tegefaulkes

src/WorkerPool.ts

@@ -71,21 +71,24 @@ class WorkerPool {
     });
   }
 
+  // TODO: we need to handle a worker that doesn't respond at all. Timeout should terminate and avoid re-creating
   protected addWorker() {
     const worker = this.workerFactory();
     let workerError: Error;
     let initializing = true;
-    const messageHandler = (result: WorkerResultInternal) => {
+    const messageHandler = (result: WorkerResultInternal | 'initialized') => {
       if (initializing) {
-        // @ts-ignore: ignoring type here
         if (result !== 'initialized') {
-          throw Error('TMP IMP failed to initialize properly');
+          throw new errors.ErrorWorkerInitializationFailed();
         }
         initializing = false;
         this.freeWorkers.push(worker);
         this.$workerFreed.next();
         return;
       }
+      if (result === 'initialized') {
+        throw new errors.ErrorWorkersUndefinedBehaviour();
+      }
       if (result.error != null) {
         worker[taskInfoSymbol].done(undefined, result.error);
       } else {
@@ -115,9 +118,8 @@ class WorkerPool {
       ) {
         // If the worker errored then we want to check if it was a failure to load error
         if (this.workers.size === 0 && this.terminatedError == null) {
-          this.terminatedError = new Error(
-            'TMP IMP Workers failed to load modules',
-          );
+          this.terminatedError =
+            new errors.ErrorWorkerPoolWorkerCreationFailed();
           this.cleanUp(this.terminatedError);
         }
         return;
@@ -127,13 +129,6 @@ class WorkerPool {
     worker.once('online', async () => {
       worker.postMessage({ type: 'initialize', data: undefined });
     });
-
-    // TODO: debugging
-    // worker.on('message', (...args) => console.log('DEBUG message: ', args));
-    // worker.on('messageerror', (...args) => console.log('DEBUG messageerror: ', args));
-    // worker.on('error', (...args) => console.log('DEBUG error: ', args));
-    // worker.on('exit', (...args) => console.log('DEBUG exit: ', args));
-    // worker.on('online', (...args) => console.log('DEBUG online: ', args));
     this.workers.add(worker);
     this.$workerCreated.next();
   }
@@ -158,7 +153,7 @@ class WorkerPool {
 
   public async terminate(force: boolean) {
     if (this.terminatedError != null) return;
-    this.terminatedError = Error('TMP IMP terminating');
+    this.terminatedError = new errors.ErrorWorkerPoolWorkerTerminated();
     // Prevent new tasks and wait for exising queue to drain
     if (!force) await this.settled();
     // Prevent terminations from creating new workers

src/errors.ts

@@ -1,34 +1,60 @@
 import { AbstractError } from '@matrixai/errors';
 
-class ErrorWorkerManager<T> extends AbstractError<T> {
+class ErrorWorkers<T> extends AbstractError<T> {
+  static description = 'Workers domain error';
+}
+
+class ErrorWorkersUndefinedBehaviour<T> extends ErrorWorkers<T> {
+  static description = 'You should never see this error';
+}
+
+class ErrorWorkerManager<T> extends ErrorWorkers<T> {
   static description = 'WorkerManager error';
 }
 
 class ErrorWorkerManagerDestroyed<T> extends ErrorWorkerManager<T> {
   static description = 'WorkerManager is destroyed';
 }
 
-class ErrorWorkerPool<T> extends AbstractError<T> {
+class ErrorWorkerPool<T> extends ErrorWorkers<T> {
   static description = 'WorkerPool error';
 }
 
-class ErrorWorkerPoolInvalidWorkers<T> extends ErrorWorkerManager<T> {
+class ErrorWorkerPoolInvalidWorkers<T> extends ErrorWorkerPool<T> {
   static description = 'You must have at minimum 1 worker';
 }
 
-class ErrorWorker<T> extends AbstractError<T> {
+class ErrorWorkerPoolWorkerCreationFailed<T> extends ErrorWorkerPool<T> {
+  static description = 'Failed to create workers when creating a WorkerPool';
+}
+
+class ErrorWorkerPoolWorkerTerminated<T> extends ErrorWorkerPool<T> {
+  static description = 'Worker pool is terminated';
+}
+
+class ErrorWorker<T> extends ErrorWorkers<T> {
   static description = 'Worker error';
 }
 
-class ErrorWorkerHandlerMissing<T> extends ErrorWorkerManager<T> {
+class ErrorWorkerHandlerMissing<T> extends ErrorWorker<T> {
   static description = 'Worker has not exposed a handler of this name';
 }
 
+class ErrorWorkerInitializationFailed<T> extends ErrorWorker<T> {
+  static description =
+    'Worker failed to initialize with an initialization message';
+}
+
 export {
+  ErrorWorkers,
+  ErrorWorkersUndefinedBehaviour,
   ErrorWorkerManager,
   ErrorWorkerManagerDestroyed,
   ErrorWorkerPool,
   ErrorWorkerPoolInvalidWorkers,
+  ErrorWorkerPoolWorkerCreationFailed,
+  ErrorWorkerPoolWorkerTerminated,
   ErrorWorker,
   ErrorWorkerHandlerMissing,
+  ErrorWorkerInitializationFailed,
 };

src/expose.ts

@@ -2,9 +2,9 @@ import type {
   WorkerTaskInformation,
   WorkerManifest,
   WorkerResultInternal,
-} from '#types.js';
+} from './types.js';
 import { isMainThread, parentPort } from 'node:worker_threads';
-import * as workerErrors from '#errors.js';
+import * as workerErrors from './errors.js';
 
 /**
  * Call inside a worker to set it up and expose the supported worker functions.

src/worker.ts

@@ -1,6 +1,6 @@
 // This is an example worker script
 
-import type { WorkerManifest } from '#types.js';
+import type { WorkerManifest } from './types.js';
 import { expose } from './expose.js';
 
 const worker = {