Merge pull request #39 from hellivan/feat/dedicated_error

feat: throw dedicated errors instead of generic ones

Author: hellivan

src/data-structures/limited-observable-queue.ts

@@ -1,3 +1,4 @@
+import { QueueError } from '../errors';
 import { ObservableQueue } from './observable-queue';
 
 export class LimitedObservableQueue<T> extends ObservableQueue<T> {
@@ -25,7 +26,7 @@ export class LimitedObservableQueue<T> extends ObservableQueue<T> {
     }
 
     public enqueue(item: T): void {
-        if (this.full) throw new Error('Queue full! Cannot enqueue any more items!');
+        if (this.full) throw new QueueError('Queue full! Cannot enqueue any more items!');
         super.enqueue(item);
     }
 }

src/errors/execution-timeout-error.ts

@@ -0,0 +1,8 @@
+export class ExecutionTimeoutError extends Error {
+    public readonly code = 'NTSU_EXEC_TIMEOUT';
+
+    constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, ExecutionTimeoutError.prototype);
+    }
+}

src/errors/index.ts

@@ -0,0 +1,4 @@
+export { ExecutionTimeoutError } from './execution-timeout-error';
+export { QueueError } from './queue-error';
+export { WorkerError } from './worker-error';
+export { WorkerPoolError } from './worker-pool-error';

src/errors/queue-error.ts

@@ -0,0 +1,8 @@
+export class QueueError extends Error {
+    public readonly code = 'NTSU_QUEUE_ERROR';
+
+    constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, QueueError.prototype);
+    }
+}

src/errors/worker-error.ts

@@ -0,0 +1,8 @@
+export class WorkerError extends Error {
+    public readonly code = 'NTSU_WORKER_ERROR';
+
+    constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, WorkerError.prototype);
+    }
+}

src/errors/worker-pool-error.ts

@@ -0,0 +1,8 @@
+export class WorkerPoolError extends Error {
+    public readonly code = 'NTSU_WORKER_POOL_ERROR';
+
+    constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, WorkerPoolError.prototype);
+    }
+}

src/index.spec.ts

@@ -1,8 +1,12 @@
 import {
+    ExecutionTimeoutError,
     DynamicWorkerPool,
     DynamicWorkerPoolWorker,
+    QueueError,
+    WorkerError,
     WorkerFactory,
     WorkerPool,
+    WorkerPoolError,
     WorkerThreadTask,
     WorkerThreadWorker,
     QdScheduler
@@ -15,6 +19,14 @@ describe('exports', () => {
         expect(WorkerThreadWorker).toBeDefined();
 
         expect(QdScheduler).toBeDefined();
+
+        expect(ExecutionTimeoutError).toBeDefined();
+
+        expect(QueueError).toBeDefined();
+
+        expect(WorkerError).toBeDefined();
+
+        expect(WorkerPoolError).toBeDefined();
     });
 
     test('interfaces must be exported', () => {

src/index.ts

@@ -1,3 +1,4 @@
+export { ExecutionTimeoutError, QueueError, WorkerError, WorkerPoolError } from './errors';
 export { WorkerThreadTask, WorkerThreadWorker } from './workers';
 export { WorkerFactory } from './worker-factory';
 export { DynamicWorkerPool, DynamicWorkerPoolWorker, WorkerPool } from './worker-pool';

src/worker-pool/dynamic-worker-pool.ts

@@ -1,6 +1,7 @@
 import { BehaviorSubject, distinctUntilChanged, filter, firstValueFrom, Observable, Subject } from 'rxjs';
 
 import { ObservableQueue } from '../data-structures';
+import { WorkerPoolError } from '../errors';
 import { WorkerFactory } from '../worker-factory';
 import { AbstractWorkerPool, AbstractWorkerPoolWorker } from './abstract-worker-pool';
 import { IdleWorkerDescription } from './idle-worker-description';
@@ -78,7 +79,7 @@ export class DynamicWorkerPool<
 
     protected aquireWorker(): TWorker {
         if (this.stopped) {
-            throw new Error('Cannot aquire worker from stopped worker pool!');
+            throw new WorkerPoolError('Cannot aquire worker from stopped worker pool!');
         } else if (this.idleWorkersQueue.size > 0) {
             const workerDescription = this.idleWorkersQueue.dequeue();
             workerDescription.cancelIdleTimeout();
@@ -93,7 +94,7 @@ export class DynamicWorkerPool<
             this.updateAvailableWorkers();
             return worker;
         } else {
-            throw new Error(`No free workers available in worker pool of max-size ${this.maxSize}`);
+            throw new WorkerPoolError(`No free workers available in worker pool of max-size ${this.maxSize}`);
         }
     }
 
@@ -133,7 +134,7 @@ export class DynamicWorkerPool<
         try {
             await worker.dispose();
         } catch (err) {
-            this.errorSubject.next(new Error(`Error while disposing worker-pool worker: ${err.message}`));
+            this.errorSubject.next(new WorkerPoolError(`Error while disposing worker-pool worker: ${err.message}`));
         }
     }
 

src/workers/worker-thread-worker.spec.ts

@@ -290,7 +290,7 @@ describe('WorkerThreadWorker', () => {
 
         const emittedError = await errorEmitterPromise;
         expect(emittedError).toMatchObject({
-            message: 'Worker terminated gracefully. This hould not happen in a WorkerThreadWorker!'
+            message: 'Worker terminated gracefully. This should not happen in a WorkerThreadWorker!'
         });
     });