Is it bad practice to have a constructor function return a Promise?

I encountered the same problem and came up with this simple solution.

Instead of returning a Promise from the constructor, put it in this._initialized property, like this:

function Engine(path) {
  this._initialized = Promise.resolve()
    .then(() => {
      return doSomethingAsync(path)
    })
    .then((result) => {
      this.resultOfAsyncOp = result
    })
}
  

Then, wrap every method in a callback that runs after the initialization, like that:

Engine.prototype.showPostsOnPage = function () {
  return this._initialized.then(() => {
    // actual body of the method
  })
}

How it looks from the API consumer perspective:

engine = new Engine({path: '/path/to/posts'})
engine.showPostsOnPage()

This works because you can register multiple callbacks to a promise and they run either after it resolves or, if it's already resolved, at the time of attaching the callback.

This is how mongoskin works, except it doesn't actually use promises.

Edit: Since I wrote that reply I've fallen in love with ES6/7 syntax so there's another example using that.

class Engine {
  
  constructor(path) {
    this._initialized = this._initialize(path)
  }

  async _initialize() {
    // actual async constructor logic
    this.resultOfAsyncOp = await doSomethingAsync(path)
  }

  async showPostsOnPage() {
    await this._initialized
    // actual body of the method
  }
  
}

To avoid the separation of concerns, use a factory to create the object.

class Engine {
    constructor(data) {
        this.data = data;
    }

    static makeEngine(pathToData) {
        return new Promise((resolve, reject) => {
            getData(pathToData).then(data => {
              resolve(new Engine(data))
            }).catch(reject);
        });
    }
}

The return value from the constructor replaces the object that the new operator just produced, so returning a promise is not a good idea. Previously, an explicit return value from the constructor was used for the singleton pattern.

The better way in ECMAScript 2017 is to use a static methods: you have one process, which is the numerality of static.

Which method to be run on the new object after the constructor may be known only to the class itself. To encapsulate this inside the class, you can use process.nextTick or Promise.resolve, postponing further execution allowing for listeners to be added and other things in Process.launch, the invoker of the constructor.

Since almost all code executes inside of a Promise, errors will end up in Process.fatal

This basic idea can be modified to fit specific encapsulation needs.

class MyClass {
  constructor(o) {
    if (o == null) o = false
    if (o.run) Promise.resolve()
      .then(() => this.method())
      .then(o.exit).catch(o.reject)
  }

  async method() {}
}

class Process {
  static launch(construct) {
    return new Promise(r => r(
      new construct({run: true, exit: Process.exit, reject: Process.fatal})
    )).catch(Process.fatal)
  }

  static exit() {
    process.exit()
  }

  static fatal(e) {
    console.error(e.message)
    process.exit(1)
  }
}

Process.launch(MyClass)

Yes. It is absolutely bad practice.

Constructor return override is a bad idea in general – outside carefully applied idioms. It can break inheritance, and it especially breaks fields defined in deriving classes. For an example:

const MyCounterMixin = (claſs, startValue = 0) => {
  return class extends claſs {
    #counter = startValue;
    [MyCounterMixin.count]() {
      return this.#counter++;
    }
  };
}
MyCounterMixin.count = Symbol('MyCounterMixin.count');

class GoodCitizen {}
class Snowflake { constructor() { return (async () => this)(); } }

(async () => {
  const GoodCitizenMixin = MyCounterMixin(GoodCitizen);
  const goodCitizen = new GoodCitizenMixin();
  console.log(goodCitizen[MyCounterMixin.count]());   // OK

  const SnowflakeMixin = MyCounterMixin(Snowflake);
  const snowflake = await new SnowflakeMixin();       // or is it just “new”?
  console.log(snowflake[MyCounterMixin.count]());     // TypeError
})().catch(e => {
  console.error(e);
});

The TypeError occurs because the mixin installed its private field on the promise that was returned from the Snowflake constructor, and not on the eventually returned object. Which code should be blamed for this error? I think the Snowflake constructor, because it broke the convention that a constructor ought to return an instance of the class directly. This is crucially relied on by features like super within a constructor. There is no way to write Snowflake such that it both return a promise and be compatible with inheritance.

If you shun inheritance (which, after all, is not a bad idea anyway), you may fail to experience many issues at first – but it’s still defying a strong language convention that a constructor ought to return an instance of its class. TypeScript enforces it as well – the following code is a type-checking error on the return line:

class Snowflake {
  constructor() {
    return (async () => this)();
  }
  foo() {}
}

There is no way to override the type signature for the constructor either: TypeScript will always assume a new expression will return the object directly (if it returns at all). The best you can do is lie to the type checker by writing a type assertion falsely claiming that the IIAFE returns the object instead of a promise – and this is not what type assertions are for: they exist to express true things that the type checker cannot see, like when using FileReader.

Consider also that in modern JavaScript, the preferred syntax for writing a function that returns a promise is to prefix the function with the async keyword. But async constructor() {} has been specifically made a syntax error:

console.log("this will not even parse");

class Invalid {
  async constructor() {
    /* … */
  }
}

This is essentially for the same reason – because a constructor is supposed to return the constructed object, not a promise that fulfils to one. If the TC39 committee intended you to write asynchronous constructors, this syntax would have been allowed.

This is not exclusive to promises – all kinds of careless usage of constructor return overrides would have this problem. That is not to say the feature is entirely useless; you can come up with idioms employing a return override that do not run into such problems (like instance caching or super trickery), but such idioms are rather limited in use and come with constraints (some may even prohibit the use of inheritance). None would allow a constructor to be asynchronous: spawning asynchronous tasks from the constructor would have to be expressed by other means.