Is async function awaited automatically if call in constructor?

I'm working on some code which needs to be changed to be async (because of library upgrade). My code has same base class which is inherited by other classes and I want to call some functions in constructor which are async now. As I know it's impossible to await constructor but what I found async function used inside constructor is awaited. From logical point it shouldn't work but it works. Can someone confirm explain why it works?

Example

abstract class Base {
    constructor() {
        // do some setup
        this.asyncMethod();
    }

    abstract asyncMethod(): Promise<void>;
}

class Test extends Base {
    constructor() {
        super();
    }

    async asyncMethod(): Promise<void> {
        await setTimeout(() => console.log('Tadaaaa'));
    }
}

const instance = new Test();

No it is not. And constructors can't be async.

A test that shows the constructor isn't waiting

I simplified the code from the question into an example that clearly shows that the constructor does not wait for an async method. When yo u run this code you will see that you get 'Constructor done' from the constructor before 'All done' that is written from the async method.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

class MyClass {
  constructor() {
    this.asyncMethod();
    console.log('Constructor done');
  }

  sleep(ms) {
    return new Promise(res => setTimeout(res, ms));
  }

  async asyncMethod() {
    await this.sleep(500);
    console.log('All done');
  }
}

const instance = new MyClass();

<!-- end snippet -->

A workaround if you need something similar to an async constructor

A workaround would be to make the constructor uncallable and make a static method that is a factory that creates new instances of the class.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

class Dog {
  // make 'new Dog()' throw an error
  constructor() {
    throw new Error('Please call await Dog.new() to create a dog.');
  }
  // a factory method that creates a dog
  static async new(...args) {
    let instance = Object.create(Dog.prototype);
    instance._constructor(...args);
    return instance;
  }
  // our 'real' constructor
  async _constructor(name) {
    this.name = name;
    /* do async stuff */
  }
}

// new Dog(); -> would throw an error
async function test() {
  // instead create dog instances like this
  let lassie = await Dog.new('Lassie');
  console.log(lassie.constructor.name);
  console.log(lassie);
}
test();

<!-- end snippet -->

If you would have set up the async method test correctly, it wouldn't have worked (setTimeout doesn't return a promise).

As an alternative you can have a private property that gets the promise in the constructor. Then make any method that depends on that state async. This way the caller will not await during construction of the instance, but when calling a dependent method.

Demo:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

class Test {
    #promise
    
    constructor() {
        this.#promise = this.#asyncMethod();
    }

    async #asyncMethod() {
        const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');
        return response.json();
    }
    
    async title() {
        // Every method that needs the async state needs to await it
        const obj = await this.#promise;
        return obj.title;
    }

    async userId() {
        // Every method that needs the async state needs to await it
        const obj = await this.#promise;
        return obj.userId;
    }
    
}

// Demo
(async () => {
    const instance = new Test();
    const title = await instance.title();
    console.log(title);
    const userId = await instance.userId();
    console.log(userId);
})();

<!-- end snippet -->

Actually... You can make constructors async by simply returning the promise:

#1 &mdash; Technically async

• Pro: returns a Promise
• Pro: Easy to write
• Con: Cannot use await

class Base {
    // This is technically async--since it returns a Promise
    // But, I'm assuming you meant if you could use `await` within--which is no, see method #2
    constructor() {
        // You can NOT use `await` within the constructor here :(
        return this.asyncMethod();
    }

    async asyncMethod() {
        // You CAN use `await` here :)
        return fetch('#');
    }
}

#2 &mdash; Actually async

• Pro: returns a Promise
• Pro: can use await
• Con: Has to be overengineered

function Base(...args) {
    // This is truly async--it is a promise
    async function Base(...args) {
        // You can use `await` here! :D
        return await this.asyncMethod();
    }

    Base.prototype.asyncMethod = function asyncMethod() {
        // You can change this to be `async`
        return fetch('#');
    };

    return Base.call(null, args);
}