Integrated @matrixai/errors and setup error chaining and using @matrixai/async-init

Author: CMCDragonkai

package-lock.json

@@ -20,9 +20,10 @@
     "bench": "ts-node -r tsconfig-paths/register ./benches"
   },
   "dependencies": {
+    "@matrixai/async-init": "^1.7.0",
     "@matrixai/logger": "^2.1.0",
-    "threads": "^1.6.5",
-    "ts-custom-error": "^3.2.0"
+    "@matrixai/errors": "^1.0.1",
+    "threads": "^1.6.5"
   },
   "devDependencies": {
     "@types/jest": "^26.0.20",

package.json

@@ -1,12 +1,13 @@
 import type { ModuleThread } from 'threads';
 import type { ModuleMethods } from 'threads/dist/types/master';
 import type { QueuedTask } from 'threads/dist/master/pool-types';
-
 import { Pool } from 'threads';
 import Logger from '@matrixai/logger';
+import { CreateDestroy, ready } from '@matrixai/async-init/dist/CreateDestroy';
 import WorkerManagerInterface from './WorkerManagerInterface';
 import * as errors from './errors';
 
+@CreateDestroy()
 class WorkerManager<W extends ModuleMethods>
   implements WorkerManagerInterface<W>
 {
@@ -43,10 +44,8 @@ class WorkerManager<W extends ModuleMethods>
 
   protected pool: Pool<ModuleThread<W>>;
   protected logger: Logger;
-  protected _running: boolean = false;
-  protected _destroyed: boolean = false;
 
-  protected constructor({
+  public constructor({
     workerFactory,
     cores,
     logger,
@@ -57,57 +56,35 @@ class WorkerManager<W extends ModuleMethods>
   }) {
     this.logger = logger;
     this.pool = Pool(workerFactory, cores);
-    this._running = true;
-  }
-
-  get running(): boolean {
-    return this._running;
-  }
-
-  get destroyed(): boolean {
-    return this._destroyed;
   }
 
   public async destroy({
     force = false,
   }: { force?: boolean } = {}): Promise<void> {
-    if (this._destroyed) {
-      return;
-    }
     this.logger.info('Destroying WorkerManager');
     await this.pool.terminate(force);
-    this._running = false;
-    this._destroyed = true;
     this.logger.info('Destroyed WorkerManager');
   }
 
+  @ready(new errors.ErrorWorkerManagerDestroyed())
   public async call<T>(f: (worker: ModuleThread<W>) => Promise<T>): Promise<T> {
-    if (!this._running) {
-      throw new errors.ErrorWorkerManagerNotRunning();
-    }
     return await this.pool.queue(f);
   }
 
+  @ready(new errors.ErrorWorkerManagerDestroyed())
   public queue<T>(
     f: (worker: ModuleThread<W>) => Promise<T>,
   ): QueuedTask<ModuleThread<W>, T> {
-    if (!this._running) {
-      throw new errors.ErrorWorkerManagerNotRunning();
-    }
     return this.pool.queue(f);
   }
 
+  @ready(new errors.ErrorWorkerManagerDestroyed())
   public async completed(): Promise<void> {
-    if (!this._running) {
-      throw new errors.ErrorWorkerManagerNotRunning();
-    }
     return await this.pool.completed();
   }
 
+  @ready(new errors.ErrorWorkerManagerDestroyed())
   public async settled() {
-    if (!this._running) {
-      throw new errors.ErrorWorkerManagerNotRunning();
-    }
     return await this.pool.settled();
   }
 }

src/WorkerManager.ts

@@ -3,7 +3,7 @@ import type { ModuleMethods } from 'threads/dist/types/master';
 import type { QueuedTask } from 'threads/dist/master/pool-types';
 
 interface WorkerManagerInterface<W extends ModuleMethods> {
-  destroy(): Promise<void>;
+  destroy(options: { force?: boolean }): Promise<void>;
   call<T>(f: (worker: ModuleThread<W>) => Promise<T>): Promise<T>;
   queue<T>(
     f: (worker: ModuleThread<W>) => Promise<T>,

src/WorkerManagerInterface.ts

@@ -1,7 +1,11 @@
-import { CustomError } from 'ts-custom-error';
+import { AbstractError } from '@matrixai/errors';
 
-class ErrorWorkerManager extends CustomError {}
+class ErrorWorkerManager<T> extends AbstractError<T> {
+  static description = 'WorkerManager error';
+}
 
-class ErrorWorkerManagerNotRunning extends ErrorWorkerManager {}
+class ErrorWorkerManagerDestroyed<T> extends ErrorWorkerManager<T> {
+  static description = 'WorkerManager is destroyed';
+}
 
-export { ErrorWorkerManager, ErrorWorkerManagerNotRunning };
+export { ErrorWorkerManager, ErrorWorkerManagerDestroyed };

src/errors.ts

@@ -1,6 +1,7 @@
 import type { WorkerModule } from '@/worker';
 import { spawn, Worker, Transfer } from 'threads';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
+import { destroyed } from '@matrixai/async-init';
 import WorkerManager from '@/WorkerManager';
 import * as errors from '@/errors';
 import * as testUtils from './utils';
@@ -16,14 +17,12 @@ describe('WorkerManager', () => {
         logger,
       },
     );
-    expect(workerManager.running).toBe(true);
-    expect(workerManager.destroyed).toBe(false);
+    expect(workerManager[destroyed]).toBe(false);
     expect(await workerManager.call(async () => 1)).toBe(1);
     await workerManager.destroy();
-    expect(workerManager.running).toBe(false);
-    expect(workerManager.destroyed).toBe(true);
+    expect(workerManager[destroyed]).toBe(true);
     expect(workerManager.call(async () => 1)).rejects.toThrow(
-      errors.ErrorWorkerManagerNotRunning,
+      errors.ErrorWorkerManagerDestroyed,
     );
   });
   test('starting with 0 worker cores is useless', async () => {

tests/WorkerManager.test.ts

@@ -6,6 +6,7 @@
     "allowJs": true,
     "strictNullChecks": true,
     "noImplicitAny": false,
+    "experimentalDecorators": true,
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
     "resolveJsonModule": true,