@mikeyt23/node-cli-utils 2.0.11 → 2.0.13

package/dist/esm/parallel.d.ts

@@ -0,0 +1,118 @@
+/**
+ * A type guard useful for filtering results of `Promise.allSettled`.
+ * @example
+ * ```
+ * const settledPromises = await Promise.allSettled(promises)
+ * settledPromises.filter(isSettledRejected).map(r => r.reason)
+ * ```
+ */
+export declare const isSettledRejected: (input: PromiseSettledResult<unknown>) => input is PromiseRejectedResult;
+/**
+ * A type guard useful for filtering results of `Promise.allSettled`.
+ * @example
+ * ```
+ * const settledPromises = await Promise.allSettled(promises)
+ * settledPromises.filter(isSettledFulfilled).map(r => r.value)
+ * ```
+ */
+export declare const isSettledFulfilled: <T>(input: PromiseSettledResult<T>) => input is PromiseFulfilledResult<T>;
+/**
+ * The result from an individual operation during a call to {@link runParallel}.
+ */
+export interface ParallelItemResult<InputType, OutputType> {
+    /** The original item passed to the operation function. */
+    inputItem: InputType;
+    /** The result property will be undefined if the promise is rejected when operating on the item. */
+    outputResult?: OutputType;
+    /** Set to `true` if not skipped, the promise wasn't rejected and the success evaluation function returned true for the output, `false` otherwise. */
+    success: boolean;
+    /** The value of the promise rejection (often an Error object, but can technically be anything). */
+    rejectedReason?: unknown;
+    /**
+     * Items can be skipped if the {@link RunParallelOptions.shouldSkipFunc} is used and evaluated to `true` for an item, or if
+     * {@link RunParallelOptions.onlyFirstN} was passed and the item was not in range.
+     * */
+    skipped: boolean;
+}
+/**
+ * The result of {@link runParallel}.
+ */
+export declare class ParallelResult<InputType, OutputType> {
+    readonly allItemResults: ParallelItemResult<InputType, OutputType>[];
+    readonly onlyFirstN?: number;
+    constructor(allItemResults: ParallelItemResult<InputType, OutputType>[], onlyFirstN?: number);
+    get successfulItemResults(): ParallelItemResult<InputType, OutputType>[];
+    get allInputItems(): InputType[];
+    get allOutputResults(): OutputType[];
+    /** Does not include skipped items. */
+    get failedItemResults(): ParallelItemResult<InputType, OutputType>[];
+    get skippedItemResults(): ParallelItemResult<InputType, OutputType>[];
+    get rejectedItemResults(): ParallelItemResult<InputType, OutputType>[];
+    get numSuccessful(): number;
+    /** Note that this does not include promise rejections (see {@link numRejected}) or skipped items (see {@link numSkipped}). */
+    get numFailed(): number;
+    /** Note that this does not include successful promises with failure results - see {@link numFailed}. */
+    get numRejected(): number;
+    get numSkipped(): number;
+    get numTotalItems(): number;
+    /** Does not consider skipped items - only promise rejections and evaluated failures. */
+    get noFailures(): boolean;
+    logFinishedMessage(): void;
+}
+/** The async function to run on each item during a call to {@link runParallel}. */
+export type OperationExecutor<OutputType, InputType> = (operationItem: InputType) => Promise<OutputType>;
+/** The function that will determine whether each operation during a call to {@link runParallel} should be considered successful or not. */
+export type SuccessChecker<OutputType> = (operationResult: OutputType) => boolean;
+/** The sync or async function that determines whether a particular item input for {@link runParallel} should be skipped or not. */
+export type SkipChecker<InputType> = ((operationItem: InputType) => Promise<boolean>) | ((operationItem: InputType) => boolean);
+/** Additional options that can be passed to {@link runParallel}. */
+export interface RunParallelOptions<InputType> {
+    /**
+     * Defaults to 10 - the maximum number of tasks that will be allowed to run concurrently. While NodeJS is single-threaded,
+     * it is worth controlling the number of running tasks to avoid overwhelming I/O or an external service.
+     */
+    maxConcurrent: number;
+    /** If provided, this will be used to determine whether or not an item should be skipped. */
+    shouldSkipFunc?: SkipChecker<InputType>;
+    /**
+     * If provided, this will limit processing to the first N items. Useful for testing new functionality on a subset of items.
+     *
+     * Note that this will completely bypass any processing of items after the first N items. So for example, there won't be
+     * "skipped" items for those not processed - they simply won't be on the result object at all.
+     */
+    onlyFirstN?: number;
+}
+/**
+ * Run an operation against an array of items.
+ * @template OutputType The output type of each call to `operationFunc`.
+ * @template InputType The input type for each item in the `itemsToOperateOn` array.
+ * @param itemsToOperateOn The array of items of type `InputType` to operate on.
+ * @param executorFunc The async function to call on each item in `itemsToOperateOn` - should return type `OutputType`.
+ * @param isResultSuccessFunc The boolean returning function to evaluate whether each item of type `OutputType` returned should be considered successful.
+ * @param skipCheckFunc An optional boolean async function to determine whether each item of type `InputType` should be operated on.
+ * @param onlyFirstN Optional. Stop after this number of items processed.
+ * @returns A {@link ParallelResult}
+ */
+export declare function runParallel<InputType, OutputType>(itemsToOperateOn: Iterable<InputType>, executorFunc: OperationExecutor<OutputType, InputType>, isResultSuccessFunc: SuccessChecker<OutputType>, options?: Partial<RunParallelOptions<InputType>>): Promise<ParallelResult<InputType, OutputType>>;
+/** The return type of {@link ParallelExecutor.processQueue}. This is a generic wrapper for {@link Promise.allSettled} with results of type {@link ParallelItemResult}.
+ *
+ * To filter the results, use type guards {@link isSettledRejected} and {@link isSettledFulfilled}.
+*/
+export type AllSettledResult<ParallelItemResult> = Promise<PromiseSettledResult<Awaited<ParallelItemResult>>[]>;
+/**
+ * This class simulates a semaphore, running as many of the tasks simultaneously as possible while staying under the limit of the value passed for `maxConcurrent`.
+ *
+ * Note that NodeJS is single-threaded, so this is more about prevention of overwhelming I/O systems and external services than it is about true parallel execution.
+ */
+export declare class ParallelExecutor<InputType, OutputType> {
+    private maxConcurrent;
+    private numExecuting;
+    private queue;
+    private operationPromises;
+    private taskCompletePromises;
+    constructor(maxConcurrent: number);
+    queueTask(item: InputType, operationFunc: OperationExecutor<OutputType, InputType>): void;
+    processQueue(): AllSettledResult<ParallelItemResult<InputType, OutputType>>;
+    private release;
+}
+//# sourceMappingURL=parallel.d.ts.map

package/dist/esm/parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../src/parallel.ts"],"names":[],"mappings":"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"}

package/dist/esm/parallel.js

@@ -0,0 +1,222 @@
+import { Emoji, log, trace } from './generalUtils.js';
+import { cyan } from './colors.js';
+/**
+ * A type guard useful for filtering results of `Promise.allSettled`.
+ * @example
+ * ```
+ * const settledPromises = await Promise.allSettled(promises)
+ * settledPromises.filter(isSettledRejected).map(r => r.reason)
+ * ```
+ */
+export const isSettledRejected = (input) => input.status === 'rejected';
+/**
+ * A type guard useful for filtering results of `Promise.allSettled`.
+ * @example
+ * ```
+ * const settledPromises = await Promise.allSettled(promises)
+ * settledPromises.filter(isSettledFulfilled).map(r => r.value)
+ * ```
+ */
+export const isSettledFulfilled = (input) => input.status === 'fulfilled';
+/**
+ * The result of {@link runParallel}.
+ */
+export class ParallelResult {
+    allItemResults;
+    onlyFirstN;
+    constructor(allItemResults, onlyFirstN) {
+        this.allItemResults = allItemResults;
+        this.onlyFirstN = onlyFirstN;
+    }
+    get successfulItemResults() {
+        return this.allItemResults.filter(r => r.success);
+    }
+    get allInputItems() {
+        return this.allItemResults.map(r => r.inputItem);
+    }
+    get allOutputResults() {
+        return this.allItemResults.filter(r => r.outputResult !== undefined).map(r => r.outputResult);
+    }
+    /** Does not include skipped items. */
+    get failedItemResults() {
+        return this.allItemResults.filter(r => !r.success && !r.skipped);
+    }
+    get skippedItemResults() {
+        return this.allItemResults.filter(r => r.skipped);
+    }
+    get rejectedItemResults() {
+        return this.allItemResults.filter(r => r.rejectedReason);
+    }
+    get numSuccessful() {
+        return this.successfulItemResults.length;
+    }
+    /** Note that this does not include promise rejections (see {@link numRejected}) or skipped items (see {@link numSkipped}). */
+    get numFailed() {
+        return this.failedItemResults.length;
+    }
+    /** Note that this does not include successful promises with failure results - see {@link numFailed}. */
+    get numRejected() {
+        return this.rejectedItemResults.length;
+    }
+    get numSkipped() {
+        return this.skippedItemResults.length;
+    }
+    get numTotalItems() {
+        return this.allItemResults.length;
+    }
+    /** Does not consider skipped items - only promise rejections and evaluated failures. */
+    get noFailures() {
+        return this.numFailed === 0 && this.numRejected === 0;
+    }
+    logFinishedMessage() {
+        const divider = '---';
+        const onlyFirstNMessage = this.onlyFirstN !== undefined ? ` (onlyFirstN set to ${this.onlyFirstN})` : '';
+        log(`${this.noFailures ? Emoji.GreenCheck : Emoji.Warning} ${cyan('runParallel')} completed - ${this.numTotalItems - this.numSkipped} items processed${onlyFirstNMessage}`);
+        if (this.numSkipped > 0) {
+            log(`${Emoji.Info} skipped ${this.numSkipped}`);
+        }
+        if (this.numRejected > 0) {
+            log(`${Emoji.Stop} Warning: some calls were rejected instead of returning a result`);
+            log(divider);
+            for (const rejected of this.rejectedItemResults) {
+                log('item: ', rejected.inputItem);
+                log('reason: ', rejected.rejectedReason);
+                log(divider);
+            }
+        }
+        if (this.numFailed > 0) {
+            log(`${Emoji.Warning} Number of failed results: ${this.numFailed}`);
+            log(divider);
+            for (const failed of this.failedItemResults) {
+                log('item: ', failed.inputItem);
+                log('output: ', failed.outputResult);
+                log(divider);
+            }
+        }
+    }
+}
+/**
+ * Run an operation against an array of items.
+ * @template OutputType The output type of each call to `operationFunc`.
+ * @template InputType The input type for each item in the `itemsToOperateOn` array.
+ * @param itemsToOperateOn The array of items of type `InputType` to operate on.
+ * @param executorFunc The async function to call on each item in `itemsToOperateOn` - should return type `OutputType`.
+ * @param isResultSuccessFunc The boolean returning function to evaluate whether each item of type `OutputType` returned should be considered successful.
+ * @param skipCheckFunc An optional boolean async function to determine whether each item of type `InputType` should be operated on.
+ * @param onlyFirstN Optional. Stop after this number of items processed.
+ * @returns A {@link ParallelResult}
+ */
+export async function runParallel(itemsToOperateOn, executorFunc, isResultSuccessFunc, options) {
+    const defaultOptions = { maxConcurrent: 10 };
+    const mergedOptions = { ...defaultOptions, ...options };
+    const parallel = new ParallelExecutor(mergedOptions.maxConcurrent);
+    const skippedItemResults = [];
+    let i = 0;
+    for (const item of itemsToOperateOn) {
+        if (mergedOptions.onlyFirstN !== undefined && i >= mergedOptions.onlyFirstN) {
+            trace(`stopping because 'onlyFirstN' param was passed with the value ${mergedOptions.onlyFirstN}`);
+            break;
+        }
+        i++;
+        if (mergedOptions.shouldSkipFunc !== undefined && await mergedOptions.shouldSkipFunc(item)) {
+            trace(`skipped item: `, item);
+            skippedItemResults.push({ inputItem: item, skipped: true, success: false });
+            continue;
+        }
+        parallel.queueTask(item, executorFunc);
+    }
+    const promiseResults = await parallel.processQueue();
+    const itemResults = promiseResults.filter(isSettledFulfilled).map(r => r.value);
+    const promiseRejections = promiseResults.filter(isSettledRejected).map(r => r.reason);
+    if (promiseRejections.length > 0) {
+        log('---');
+        log(`${Emoji.Exclamation} Warning: control flow functions that should normally not fail had promise rejections`);
+        for (const reject of promiseRejections) {
+            log(reject);
+            log('---');
+        }
+    }
+    for (const itemResult of itemResults) {
+        itemResult.success = itemResult.rejectedReason === undefined
+            && itemResult.outputResult !== undefined
+            && isResultSuccessFunc(itemResult.outputResult);
+    }
+    const parallelResult = new ParallelResult([...itemResults, ...skippedItemResults], mergedOptions.onlyFirstN);
+    return parallelResult;
+}
+/**
+ * This class simulates a semaphore, running as many of the tasks simultaneously as possible while staying under the limit of the value passed for `maxConcurrent`.
+ *
+ * Note that NodeJS is single-threaded, so this is more about prevention of overwhelming I/O systems and external services than it is about true parallel execution.
+ */
+export class ParallelExecutor {
+    maxConcurrent = 0;
+    numExecuting = 0;
+    queue = [];
+    operationPromises = [];
+    taskCompletePromises = [];
+    constructor(maxConcurrent) {
+        if (maxConcurrent <= 0) {
+            throw new Error('Invalid value passed for maxConcurrent - must be greater than 0');
+        }
+        this.maxConcurrent = maxConcurrent;
+    }
+    queueTask(item, operationFunc) {
+        let completionResolver;
+        const completionPromise = new Promise((resolve) => {
+            completionResolver = resolve;
+        });
+        this.taskCompletePromises.push(completionPromise);
+        const operationWrapper = async () => {
+            return new Promise(resolve => {
+                operationFunc(item)
+                    .then(output => {
+                    resolve({
+                        inputItem: item,
+                        skipped: false,
+                        success: true,
+                        rejectedReason: undefined,
+                        outputResult: output
+                    });
+                })
+                    .catch(err => {
+                    resolve({
+                        inputItem: item,
+                        skipped: false,
+                        success: false,
+                        rejectedReason: err,
+                        outputResult: undefined
+                    });
+                });
+            });
+        };
+        const parallelTask = () => {
+            trace(`Task called - queue.length: ${this.queue.length} - numExecuting: ${this.numExecuting}`);
+            this.numExecuting++;
+            const promise = operationWrapper();
+            this.operationPromises.push(promise);
+            promise.finally(() => {
+                this.release(completionResolver);
+            });
+        };
+        this.queue.push(parallelTask);
+    }
+    async processQueue() {
+        while (this.queue.length > 0 && this.numExecuting < this.maxConcurrent) {
+            const next = this.queue.shift();
+            if (next)
+                next();
+        }
+        await Promise.allSettled(this.taskCompletePromises);
+        return await Promise.allSettled(this.operationPromises);
+    }
+    release(completionResolver) {
+        trace(`Task released - queue.length: ${this.queue.length} - numExecuting: ${this.numExecuting}`);
+        this.numExecuting--;
+        completionResolver();
+        const next = this.queue.shift();
+        if (next)
+            next();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parallel.js","sourceRoot":"","sources":["../../src/parallel.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikeyt23/node-cli-utils",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "description": "Some node cli utility functions",
   "author": "Mike Thompson",
   "license": "MIT",
@@ -95,6 +95,16 @@
         "default": "./dist/cjs/hostFileUtils.js"
       }
     },
+    "./parallel": {
+      "import": {
+        "types": "./dist/esm/parallel.d.ts",
+        "default": "./dist/esm/parallel.js"
+      },
+      "require": {
+        "types": "./dist/cjs/parallel.d.ts",
+        "default": "./dist/cjs/parallel.js"
+      }
+    },
     "./testUtils": {
       "import": {
         "types": "./dist/esm/testUtils.d.ts",