Spot the Bug | WorkerPool edition

import { Injectable, Optional } from '@nestjs/common';

export type Task<T> = () => Promise<T>;

class Worker<T> {
  public workerPromise: Promise<T>;
  private resolve: (resolvedValue: T) => void;
  private reject: (error: Error) => void;

  constructor(private task: Task<T>) {
    this.workerPromise = new Promise<T>((resolve, reject) => {
      this.resolve = resolve;
      this.reject = reject;
    });
  }

  public run(): Promise<T> {
    const taskPromise = this.task();
    taskPromise.then(this.resolve, this.reject);
    return taskPromise;
  }
}

@Injectable()
export class WorkerPool<T> {
  private queuedTasks: Array<Worker<T>> = [];
  private runningTasks = 0;

  constructor(@Optional() private concurrency: number = 30) {}

  public queue(tasks: Task<T>[]): Promise<T[]> {
    const workers = tasks.map((task) => new Worker(task));

    for (const worker of workers) {
      this.queuedTasks.push(worker);
    }

    this.flush();

    return Promise.all(workers.map(({ workerPromise }) => workerPromise));
  }

  private flush() {
    const { queuedTasks, runningTasks } = this;

    while (queuedTasks.length && runningTasks < this.concurrency) {
      this.runTask(queuedTasks.shift()!);
    }
  }

  private completeTask() {
    this.runningTasks--;
    this.flush();
  }

  private runTask(worker: Worker<T>) {
    this.runningTasks++;
    const done = () => {
      return this.completeTask();
    };
    worker.run().then(done, done);
  }
}