Synchronous code in constructor with Promises

await inside constructor + javascript
javascript promise
async constructor typescript
async/await
[object promise]
es6 promises
node.js promise
promise fulfilled

This question already has an answer here:

Your objective of not returning the instance until after the connection won't work (at least not like this). The constructor's job is to create an instance and return that. Functions need to return something synchronously. If it's performing some async operation then a function can return a promise instead, but you don't want a promise from the constructor — you need the instance.

The easy way to do this is to require your object to be initialized after it's created, then the constructor can construct and return the instance and the init function is free to return a promise:

class AClass {
  constructor(n) {/* some setup */}

  func() {
    return new Promise(resolve =>  {
      setTimeout(() => {
        resolve("some name");
      }, 1000);
    }); 
  }

  async init() {
    this.name = await this.func();
    return this
  }

}

new AClass('test').init()
.then((initialized_obj) => console.log(initialized_obj))

The ES6 Promise Constructor And Its Executor Function Are Invoked , the ES6 Promise constructor - and the executor function that we pass to it - are invoked synchronously, inline with the control flow of our code. Using the Promise() constructor It is possible to build your own promises using the Promise() constructor. The main situation in which you'll want to do this is when you've got code based on an old-school asynchronous API that is not promise-based, which you want to promis-ify.

Two things about your code:

When you call an async function (this.init()), it will be executed uptill its returned await statement and will return a promise and the control will go to next line (console.log('init returned.')). Understanding this will resolve your confusion.
Code after await statement (console.log('after func(): ');) will execute only after awaited promise has been resolved.

I have repurposed your code to do what you want.

    async function AClass(n) {
        let obj = {}
        obj.func = () => {
            return new Promise(resolve => {
                setTimeout(() => {
                    resolve(true);
                }, 2000);
            });
        };
    
        obj.init = async function () {
            console.log('calling func()');
            let x = await obj.func();
            console.log('after func(): ');
        };
    
        obj.name = n;
        console.log('calling init.');
        await obj.init();
        console.log('init returned.');
        return obj;
    
    }
    
    
    let x = AClass('test');
    x.then((resolveValue) => {
        /*
        *Now the "class" has been instantiated, 
        * code to use the object of the "class" goes here
        * */
        console.log(JSON.stringify(resolveValue));
    });

How to do asynchronous operation in object constructor, How to do object-oriented programming (OOP) with asynchronous calls? An object constructor is responsible for initializing the state of the object, but async calls don't fit the equation well. This rules out returning a Promise as a return value. callback is a function to be executed by the constructor, during the process of construction of the promise. When the constructor generates the new promise, it also generates a pair of functions for resolve and reject .

If you really want the constructor to return a working AClass synchronously, you can do it by rewriting other parts of code a little. I'm assuming that the methods writeItem, readItem, etc are asynchronous. All you have to do is rewrite these methods so that they wait for the object to be initialised (if necessary) before proceeding.

For example, suppose your class looks like this:

class AClass {
  constructor(n) {
    this.name = n;
    this.init();
  }

  async init() {
    ...
  }

  async writeItem(item) {
    return await db.writeItem(item);
  }

  async readItem(itemId) {
    return await db.readItem(itemId);
  }

}

You should then be able to rewrite it as follows:

class AClass {
  constructor(n) {
    this.name = n;
    this.awaitInit = this.init();
  }

  async init() {
    ...
  }

  async writeItem(item) {
    await this.awaitInit;
    return await db.writeItem(item);
  }

  async readItem(itemId) {
    await this.awaitInit;
    return await db.readItem(itemId);
  }

}

JavaScript Promises and Async/Await: As Fast As Possible™, Using Async/Await syntax, a promise-based asynchronous code can be A promise object is created from Promise constructor/class which Remember that a promise doesn't do anything, and doesn't change the nature of the code in the promise executor. All a promise does is provide a means of observing the result of something (with really handy combinable semantics). Let's factor out the common parts of those three promises into a function:

25. Promises for asynchronous programming, This chapter is an introduction to asynchronous programming via Promises in general If x is a Promise whose constructor is the receiver ( Promise if you call The above code is unreadable, To more comfortable the promise process, we can use the Promise all method. Promise All. Promise all is used to simplify the chaining in promises. The Promise all method is waiting for all promises to be executed and return the result as an array.

Promises for asynchronous programming • JavaScript for impatient , addAsync() immediately invokes the Promise constructor. The actual implementation of that function resides in the callback that is passed to that constructor (line No inversion of control: similarly to synchronous code, Promise-based functions return results, they don’t (directly) continue – and control – execution via callbacks. That is, the caller stays in control.

Promise, This lets asynchronous methods return values like synchronous methods: executor: A function to be executed by the constructor, during the process of The executor is custom code that ties an outcome to a promise. You Async/Await is a fancier syntax to handle multiple promises in synchronous code fashion. When we put async keyword before a function declaration, it will return a promise and we can use await keyword inside it which blocks the code until promise it awaits resolves or rejects.

Comments

stackoverflow.com/questions/46515764/… - In this question, OP asks "Why does the log message inside the function execute afterwards?". The top answer should be helpful.
@Sam this is expected, init can be called as sync or async in same time, depends on your needs
You still can call it as async with Promise inside constructor this.init.then()
"I'd like to set-up the database connection in the constructor" - just don't do that
See Asynchronous operations in constructor. That answer shows a couple design patterns, including a factory function which is my recommendation because then the object is not available to the consumer at all until it is fully initialized.
"require your object to be initialized after it's created" - why not just create the object after doing the asynchronous initialisation? Nothing forces me to call init on an instance.
@bergi are you suggesting wrapping the whole thing in a larger initialization function so the initializer creates the instance and returns a promise resolving to that instance?
Correct. That can even be a static method of the class, which does the initialisation and then passes its results to the constructor.
@MarkMeyer - Node's asynchronous design patterns are still pretty foreign feeling to me, but this works beautifully. Thanks for the quick and very helpful reply!
Where do you get the actual instance in this example?
resolveValue is the instance.
But it's not an instance of AClass it's just an object.
Yeah right, but It serves the same purpose. This is the solution that came to my mind since async on constructor is not allowed. However, your solution is far more elegant.
One thing you could do is make a real class AClass and call the function you have nowAClassFactory. Then inside AClassFactory instead of obj = {} you would have something like obj = new AClass(n). Then this would be pretty close to what @bergi is suggesting in the comments above.