Class AutoQueue

packages/node-core/src/utils/queues/autoQueue.ts:34–236

 * but the promisies for this will still resolve in order they were inserted in the queue
 */
export class AutoQueue<T> implements IQueue {
  private pendingPromise = false;
  private queue: Queue<Action<T>>;
  private _abort = false;
  private _resolveIdle?: () => void;
  // private processingTasks = 0;

  private eventEmitter = new EventEmitter2();

  private runningTasks: Promise<void | T>[] = [];

  // Completed tasks that have completed before earlier tasks
  private outOfOrderTasks: Record<number, {action: Action<T>; result?: T; error?: unknown}> = {};
  // Next index assigned to a task when pushing to the queue
  private nextIndex = 0;
  // Next task to resolve, used to order the outOfOrderTasks
  private nextTask = 0;
  // Flag to ensure processOutOfOrderTasks is not re-entrant
  private isProcessingOutOfOrder = false;

  /**
   * @param {number} capacity - The size limit of the queue, if undefined there is no limit
   * @param {number} [concurrency=1] - The number of parallel tasks that can be processed at any one time.
   * @param {number} [taskTimeoutSec=900] - A timeout for tasks to complete in. Units are seconds. Align with nodeConfig process timeout.
   * @param {string} [name] - A name for the queue to help with debugging
   * */
  constructor(
    capacity?: number,
    public concurrency = 1,
    private taskTimeoutSec = 900,
    protected name = 'Auto'
  ) {
    this.queue = new Queue<Action<T>>(capacity);
  }

  get size(): number {
    return this.queue.size + this.runningTasks.length + Object.keys(this.outOfOrderTasks).length;
  }

  get capacity(): number | undefined {
    return this.queue.capacity;
  }

  get freeSpace(): number | undefined {
    if (!this.capacity) return undefined;
    return this.capacity - this.size;
  }

  /*
   * We don't want this function to be async
   * If it is async it will return a promise that throws rather than throwing the function
   */
  // eslint-disable-next-line @typescript-eslint/promise-function-async
  put(item: Task<T>): Promise<T> {
    return this.putMany([item])[0];
  }

  // eslint-disable-next-line @typescript-eslint/promise-function-async