A simple implementation of a promise queue that is temporal independent

asyncAwaiterQueue.js

class asyncAwaiterQueue {
  constructor(...values) {
    
    this.promise = new Promise(resolve  => {
      this.resolve = resolve;
    });
    
    values.forEach(v => this.put(v));
  }

  put(value) {
    // advance the tail

    let resolveNext = null;
    const nextPromise = new Promise(resolve => {
      resolveNext = resolve;
    });

    this.resolve({
      value: Promise.resolve(value), // normalize the value
      nextPromise, 
    });

    this.resolve = resolveNext;
  }

  get() {
    // advance the head

    const resultingPromise = this.promise.then(({ value }) => value);
    const actualPromise = this.promise;
    
    // defer next node resolution until the current is solved
    // because the resultingPromise's value could be a long time running promise
    this.promise = resultingPromise.then(() => actualPromise).then(({ nextPromise }) => nextPromise);

    return resultingPromise;
  }

}

asyncDoubleAwaiterQueue.js

class asyncDoubleAwaiterQueue {
  constructor(...values) {
    this.get_promise = new Promise((resolve) => {
      this.get_resolve = resolve;
    });

    this.put_promise = new Promise((resolve) => {
      this.put_resolve = resolve;
    });

    values.forEach((v) => this.put(v));
  }

  put(value) {
    const v = Promise.resolve(value); // normalize the value

    let get_resolve_next = null;
    const get_promise_next = new Promise((resolve) => {
      get_resolve_next = resolve;
    });

    this.get_resolve({
      value: v,
      get_promise_next,
    });

    this.get_resolve = get_resolve_next;

    const current_put_promise = this.put_promise;

    this.put_promise = this.put_promise.then(
      ({ put_promise_next }) => put_promise_next
    );

    return current_put_promise;
  }

  get() {
    const resulting_get_promise = this.get_promise
      .then(({ value }) => value)
      .then((v) => {
        let put_resolve_next = null;
        const put_promise_next = new Promise((resolve) => {
          put_resolve_next = resolve;
        });

        this.put_resolve({
          put_promise_next,
        });

        this.put_resolve = put_resolve_next;

        return v;
      });

    const current_get_promise = this.get_promise;

    this.get_promise = resulting_get_promise
      .then(() => current_get_promise)
      .then(({ get_promise_next }) => get_promise_next);

    return resulting_get_promise;
  }
}

const queue = new asyncDoubleAwaiterQueue();

queue.get().then((v) => console.log(`Get 1 of ${v}`));

queue.get().then((v) => console.log(`Get 2 of ${v}`));

queue
  .put(new Promise((res) => setTimeout(res, 10000, 1)))
  .then((v) => console.log(`Put 1`));
queue
  .put(new Promise((res) => setTimeout(res, 5000, 2)))
  .then((v) => console.log(`Put 2`));

asyncQueue.js

class AsyncQueue {
  constructor(...values) {
    
    this.promise = new Promise(resolve  => {
      this.resolve = resolve;
    });
    
    values.forEach(v => this.put(v));
  }

  put(value) {
    // advance the tail

    let resolveNext = null;
    const nextPromise = new Promise(resolve => {
      resolveNext = resolve;
    });

    this.resolve({
      value,
      nextPromise, 
    });

    this.resolve = resolveNext;
  }

  get() {
    // advance the head

    const resultingPromise = this.promise.then(({ value }) => value);
    this.promise = this.promise.then(({ nextPromise }) => nextPromise);

    return resultingPromise;
  }
}

I see! Thank you very much. I was clearer with the aww sample. And thanks for the gtor reference. I'll check it out 🙌

I see! Thank you very much. I was clearer with the aww sample. And thanks for the gtor reference. I'll check it out 🙌

You're welcome 😃