Promise Queue

README.md

Promise Queue (Typescript)

Useful classes to queue your promises

Instantiate it PromiseQueue.ts somewhere in your code. I recommend that you use as a Singleton.

// import PromiseQueue from 'PromiseQueue'

const queue = new PromiseQueue()
queue.add(() => new Promise((resolve) => {
  // your code
  resolve()
}))

queue.add(async () => {
  // your code
})

PromiseQueue.ts

import { PromiseQueueItem, PromiseItem } from './PromiseQueueItem'
export class PromiseQueue {
  public isActive = true
  public isRunning = false

  private promises: PromiseQueueItem[] = []

  public get promisesRunning() {
    return this.promises.filter((promiseItem) => promiseItem.isRunning)
  }

  public get promisesFinished() {
    return this.promises.filter((promiseItem) => promiseItem.isFinished)
  }

  public get promisesError() {
    return this.promises.filter((promiseItem) => promiseItem.isError)
  }

  public get promisesWaiting() {
    return this.promises.filter((promiseItem) => promiseItem.isWaiting)
  }

  public get canStart() {
    return this.promisesWaiting.length > 0 && this.isRunning === false
  }

  public add(promise: PromiseItem) {
    const promiseQueueItem = new PromiseQueueItem(promise)

    this.promises.push(promiseQueueItem)
  }

  public async start() {
    if (this.canStart) {
      this.isRunning = true
      console.log('can start')
      this.execNext()
    }
  }

  private async execNext(recursive = true) {
    const promiseQueueItem = this.promisesWaiting[0]
    if (promiseQueueItem) {
      console.log(promiseQueueItem)
      await promiseQueueItem.execute()
      if (recursive) {
        await this.execNext(recursive)
      }
    } else {
      this.isRunning = false
    }
  }
}

PromiseQueueItem.ts

export type PromiseItem = () => Promise<any>

export class PromiseQueueItem {
  public isRunning = false
  public isFinished = false
  public isError = false
  public isWaiting = true

  public promise: PromiseItem

  public constructor(promise: PromiseItem) {
    this.promise = promise
  }

  public execute() {
    this.isWaiting = false
    return this.promise()
      .catch((...err) => {
        this.isError = true
        throw new Error(...err)
      })
      .finally(() => {
        this.isFinished = true
      })
  }
}