@travetto/worker 8.0.0-alpha.19 → 8.0.0-alpha.20

package/README.md

@@ -13,10 +13,10 @@ npm install @travetto/worker
 yarn add @travetto/worker
 ```
 
-This module provides the necessary primitives for handling dependent workers.  A worker can be an individual actor or could be a pool of workers. Node provides ipc (inter-process communication) functionality out of the box. This module builds upon that by providing enhanced event management, richer process management, as well as constructs for orchestrating a conversation between two processes.
+This module provides the necessary primitives for handling dependent workers. A worker can be an individual actor or could be a pool of workers. Node provides ipc (inter-process communication) functionality out of the box. This module builds upon that by providing enhanced event management, richer process management, as well as constructs for orchestrating a conversation between two processes.
 
 ## Execution Pools
-With respect to managing multiple executions, [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L14) is provided to allow for concurrent operation, and processing of jobs concurrently.  To manage the flow of jobs, [AsyncQueue](https://github.com/travetto/travetto/tree/main/module/runtime/src/queue.ts#L4) is used to support a wide range of use cases. [AsyncQueue](https://github.com/travetto/travetto/tree/main/module/runtime/src/queue.ts#L4) allows for manual control of iteration, which is useful for event driven work loads. 
+With respect to managing multiple executions, [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L21) is provided to allow for concurrent operation, and processing of jobs concurrently. To manage the flow of jobs, [AsyncQueue](https://github.com/travetto/travetto/tree/main/module/runtime/src/queue.ts#L4) is used to support a wide range of use cases. [AsyncQueue](https://github.com/travetto/travetto/tree/main/module/runtime/src/queue.ts#L4) allows for manual control of iteration, which is useful for event driven work loads. 
 
 ## IPC Support
 To handle communication between processes, [IpcChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc.ts#L9) is provided. This class abstracts the underlying IPC mechanism and provides a simple interface for sending and receiving messages. It also includes event management capabilities, allowing for easy handling of different message types. By default the class assumes it is running in a child process, but it can also be used in a parent process (by passing in the child process) to communicate with child processes.

package/__index__.ts

@@ -1,3 +1,3 @@
 export * from './src/ipc.ts';
 export * from './src/pool.ts';
-export * from './src/types.ts';
+export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/worker",
-  "version": "8.0.0-alpha.19",
+  "version": "8.0.0-alpha.20",
   "type": "module",
   "description": "Process management utilities, with a focus on inter-process communication",
   "keywords": [
@@ -26,7 +26,7 @@
     "directory": "module/worker"
   },
   "dependencies": {
-    "@travetto/runtime": "^8.0.0-alpha.19",
+    "@travetto/runtime": "^8.0.0-alpha.20",
     "generic-pool": "^3.9.0"
   },
   "travetto": {

package/src/ipc.ts

@@ -7,7 +7,6 @@ import { ShutdownManager, Util } from '@travetto/runtime';
  * Channel that represents ipc communication
  */
 export class IpcChannel<V = unknown> {
-
   #emitter = new EventEmitter();
   subProcess: NodeJS.Process | ChildProcess;
   parentId: number;
@@ -37,7 +36,7 @@ export class IpcChannel<V = unknown> {
    * Determines if channel is active
    */
   get active(): boolean {
-    return (this.subProcess instanceof ChildProcess) ? !this.subProcess.killed : !!this.subProcess.connected;
+    return this.subProcess instanceof ChildProcess ? !this.subProcess.killed : !!this.subProcess.connected;
   }
 
   /**
@@ -48,7 +47,7 @@ export class IpcChannel<V = unknown> {
     if (!this.active) {
       throw new Error('Cannot send message to inactive process');
     } else if (this.subProcess.send && this.subProcess.connected) {
-      this.subProcess.send({ ...(data ?? {}), type: eventType }, undefined, undefined, (error) => error && console.error(error));
+      this.subProcess.send({ ...(data ?? {}), type: eventType }, undefined, undefined, error => error && console.error(error));
     } else {
       throw new Error('this.subProcess.send was not defined');
     }
@@ -88,7 +87,7 @@ export class IpcChannel<V = unknown> {
           this.subProcess.kill();
           await Promise.race([complete, Util.nonBlockingTimeout(1000)]);
         }
-      } catch { }
+      } catch {}
     }
     this.release();
   }
@@ -101,4 +100,4 @@ export class IpcChannel<V = unknown> {
     this.subProcess.removeAllListeners();
     this.#emitter.removeAllListeners();
   }
-}
+}

package/src/pool.ts

@@ -1,20 +1,26 @@
 import os from 'node:os';
-import { type Pool, createPool } from 'generic-pool';
 
-import { Env, Util, AsyncQueue } from '@travetto/runtime';
+import { createPool, type Pool } from 'generic-pool';
+
+import { AsyncQueue, Env, Util } from '@travetto/runtime';
 
 import {
-  isWorkerFactory, WorkPoolResultError, type IterableSource, type Worker, type WorkerInput,
-  type WorkPoolCompleteEvent, type WorkPoolConfig, type WorkPoolProgress
+  type IterableSource,
+  isWorkerFactory,
+  type Worker,
+  type WorkerInput,
+  type WorkPoolCompleteEvent,
+  type WorkPoolConfig,
+  type WorkPoolProgress,
+  WorkPoolResultError
 } from './types.ts';
 
 /**
  * Work pool support
  */
 export class WorkPool {
-
   static MAX_SIZE = os.availableParallelism();
-  static DEFAULT_SIZE = Math.max(Math.trunc(WorkPool.MAX_SIZE * .75), 4);
+  static DEFAULT_SIZE = Math.max(Math.trunc(WorkPool.MAX_SIZE * 0.75), 4);
 
   static #shouldTrace(): boolean {
     return (Env.DEBUG.value ?? '').includes('@travetto/worker');
@@ -27,35 +33,38 @@ export class WorkPool {
     const trace = this.#shouldTrace();
 
     // Create the pool
-    const pool = createPool({
-      async create() {
-        try {
-          pendingAcquires += 1;
-          const factoryInput = isWorkerFactory(input) ? await input() : { execute: input };
-          const worker: Worker<I, O> = {
-            id: Util.uuid(),
-            active: true,
-            ...factoryInput,
-          };
-          await worker.init?.();
-          return worker;
-        } finally {
-          pendingAcquires -= 1;
-        }
-      },
-      async destroy(worker) {
-        if (trace) {
-          console.debug('Destroying', { pid: process.pid, worker: worker.id });
-        }
-        return worker.destroy?.();
+    const pool = createPool(
+      {
+        async create() {
+          try {
+            pendingAcquires += 1;
+            const factoryInput = isWorkerFactory(input) ? await input() : { execute: input };
+            const worker: Worker<I, O> = {
+              id: Util.uuid(),
+              active: true,
+              ...factoryInput
+            };
+            await worker.init?.();
+            return worker;
+          } finally {
+            pendingAcquires -= 1;
+          }
+        },
+        async destroy(worker) {
+          if (trace) {
+            console.debug('Destroying', { pid: process.pid, worker: worker.id });
+          }
+          return worker.destroy?.();
+        },
+        validate: async (worker: Worker<I, O>) => worker.active
       },
-      validate: async (worker: Worker<I, O>) => worker.active
-    }, {
-      evictionRunIntervalMillis: 5000,
-      ...(options ?? {}),
-      max: options?.max ?? WorkPool.DEFAULT_SIZE,
-      min: options?.min ?? 1,
-    });
+      {
+        evictionRunIntervalMillis: 5000,
+        ...(options ?? {}),
+        max: options?.max ?? WorkPool.DEFAULT_SIZE,
+        min: options?.min ?? 1
+      }
+    );
 
     // Listen for shutdown
     options?.shutdown?.addEventListener('abort', async () => {
@@ -73,7 +82,6 @@ export class WorkPool {
    * Process a given input source and worker, and fire on completion
    */
   static async run<I, O>(workerFactory: WorkerInput<I, O>, source: IterableSource<I>, options: WorkPoolConfig<I, O> = {}): Promise<void> {
-
     const trace = this.#shouldTrace();
     const pending = new Set<Promise<unknown>>();
     const errors: Error[] = [];
@@ -84,7 +92,7 @@ export class WorkPool {
     const progress: WorkPoolProgress = {
       completed: 0,
       total: options.total ?? 0,
-      failed: 0,
+      failed: 0
     };
 
     for await (const nextInput of source) {
@@ -97,7 +105,8 @@ export class WorkPool {
         progress.total = inputIdx + 1;
       }
 
-      const completion = worker.execute(nextInput, inputIdx += 1)
+      const completion = worker
+        .execute(nextInput, (inputIdx += 1))
         .then(output => {
           const success = options.isSuccess?.(output) ?? true;
           progress.failed += +!success;
@@ -118,12 +127,12 @@ export class WorkPool {
             if (worker.active) {
               try {
                 await worker.release?.();
-              } catch { }
+              } catch {}
               await pool.release(worker);
             } else {
               await pool.destroy(worker);
             }
-          } catch { }
+          } catch {}
         });
 
       completion.finally(() => pending.delete(completion));
@@ -140,11 +149,15 @@ export class WorkPool {
   /**
    * Process a given input source as an async iterable with progress information
    */
-  static runStream<I, O>(worker: WorkerInput<I, O>, source: IterableSource<I>, options?: WorkPoolConfig<I, O>): AsyncIterable<WorkPoolCompleteEvent<I, O>> {
+  static runStream<I, O>(
+    worker: WorkerInput<I, O>,
+    source: IterableSource<I>,
+    options?: WorkPoolConfig<I, O>
+  ): AsyncIterable<WorkPoolCompleteEvent<I, O>> {
     const queue = new AsyncQueue<WorkPoolCompleteEvent<I, O>>();
     const result = this.run(worker, source, {
       ...options,
-      onComplete: async (event) => {
+      onComplete: async event => {
         await options?.onComplete?.(event);
         queue.add(event);
         return;
@@ -153,4 +166,4 @@ export class WorkPool {
     result.finally(() => queue.close());
     return queue;
   }
-}
+}

package/src/types.ts

@@ -48,13 +48,15 @@ export type WorkPoolErrorEvent<I> = {
 };
 
 export type WorkerFactoryInput<I, O = unknown> = Partial<Worker<I, O>> & { execute: WorkerExecutor<I, O> };
-export type WorkerInput<I, O> = (() => (WorkerFactoryInput<I, O> | Promise<WorkerFactoryInput<I, O>>)) | WorkerExecutor<I, O>;
+export type WorkerInput<I, O> = (() => WorkerFactoryInput<I, O> | Promise<WorkerFactoryInput<I, O>>) | WorkerExecutor<I, O>;
 export type WorkPoolConfig<I, O> = Options & {
   isSuccess?: (output: O) => boolean;
   onComplete?: (event: WorkPoolCompleteEvent<I, O>) => void | Promise<void>;
-  onError?<R = unknown>(event: WorkPoolErrorEvent<I>): (R | Promise<R>);
+  onError?<R = unknown>(event: WorkPoolErrorEvent<I>): R | Promise<R>;
   shutdown?: AbortSignal;
   total?: number;
 };
 
-export const isWorkerFactory = <I, O>(value: WorkerInput<I, O>): value is (() => (WorkerFactoryInput<I, O> | Promise<WorkerFactoryInput<I, O>>)) => value.length === 0;
+export const isWorkerFactory = <I, O>(
+  value: WorkerInput<I, O>
+): value is () => WorkerFactoryInput<I, O> | Promise<WorkerFactoryInput<I, O>> => value.length === 0;