@travetto/worker 4.1.0 → 5.0.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/worker",
-  "version": "4.1.0",
+  "version": "5.0.0-rc.0",
   "description": "Process management utilities, with a focus on inter-process communication",
   "keywords": [
     "exec",
@@ -25,7 +25,7 @@
     "directory": "module/worker"
   },
   "dependencies": {
-    "@travetto/base": "^4.1.0",
+    "@travetto/base": "^5.0.0-rc.0",
     "generic-pool": "^3.9.0"
   },
   "travetto": {

package/src/pool.ts

@@ -48,7 +48,7 @@ export class WorkPool {
         try {
           pendingAcquires += 1;
           const res = isWorkerFactory(worker) ? await worker() : { execute: worker };
-          res.id ??= Util.shortHash(`${Math.random()}`);
+          res.id ??= Util.uuid();
 
           if (res.init) {
             await res.init();

package/src/queue.ts

@@ -32,7 +32,7 @@ export class WorkQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
    */
   async next(): Promise<IteratorResult<X>> {
     while (!this.#done && !this.#queue.length) {
-      await this.#ready;
+      await this.#ready.promise;
       this.#ready = Util.resolvablePromise();
     }
     return { value: (this.#queue.length ? this.#queue.shift() : undefined)!, done: this.#done };

package/src/support/barrier.ts

@@ -14,22 +14,17 @@ export class Barrier {
   /**
    * Listen for an unhandled event, as a promise
    */
-  static listenForUnhandled(): Promise<never> & { cancel: () => void } {
-    const uncaught = Util.resolvablePromise<never>();
-    const uncaughtWithCancel: typeof uncaught & { cancel?: () => void } = uncaught;
+  static listenForUnhandled(): Promise<unknown> & { cancel: () => void } {
+    const uncaught = Util.resolvablePromise<unknown>();
     const onError = (err: Error): void => { Util.queueMacroTask().then(() => uncaught.reject(err)); };
     process.on('unhandledRejection', onError).on('uncaughtException', onError);
     const cancel = (): void => {
       process.off('unhandledRejection', onError).off('unhandledException', onError);
+      uncaught.resolve(undefined); // Close the promise
     };
-    uncaughtWithCancel.cancel = (): void => {
-      cancel(); // Remove the handler
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      uncaughtWithCancel.resolve(undefined as never); // Close the promise
-    };
-
+    Object.defineProperty(uncaught.promise, 'cancel', { value: cancel });
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return uncaughtWithCancel as (Promise<never> & { cancel: () => void });
+    return uncaught.promise as unknown as ReturnType<(typeof Barrier)['listenForUnhandled']>;
   }
 
   #support: string[] = [];

package/src/support/error.ts

@@ -3,8 +3,4 @@ import { AppError } from '@travetto/base';
 /**
  * Represents an execution error
  */
-export class ExecutionError extends AppError {
-  constructor(message: string, stack?: string) {
-    super(message, 'general', {}, stack);
-  }
-}
+export class ExecutionError extends AppError { }

package/src/support/timeout.ts

@@ -8,12 +8,12 @@ import { ExecutionError } from './error';
 export class Timeout extends ExecutionError {
 
   #timeout?: AbortController;
-  #promise = Util.resolvablePromise();
+  #resolver = Util.resolvablePromise();
   #duration: number;
 
   constructor(duration: number | TimeSpan, op: string = 'Operation') {
     super(`${op} timed out after ${duration}${typeof duration === 'number' ? 'ms' : ''}`);
-    this.#duration = TimeUtil.timeToMs(duration);
+    this.#duration = TimeUtil.asMillis(duration);
   }
 
   /**
@@ -21,7 +21,7 @@ export class Timeout extends ExecutionError {
    */
   cancel(): void {
     if (this.#timeout) {
-      this.#promise.resolve();
+      this.#resolver.resolve();
       this.#timeout.abort();
       this.#timeout = undefined;
     }
@@ -34,9 +34,9 @@ export class Timeout extends ExecutionError {
     if (!this.#timeout) {
       this.#timeout = new AbortController();
       timers.setTimeout(this.#duration, undefined, { ref: false, signal: this.#timeout.signal })
-        .then(() => this.#promise.reject(this))
+        .then(() => this.#resolver.reject(this))
         .catch(() => false);
     }
-    return this.#promise;
+    return this.#resolver.promise;
   }
 }