await/.then does not unwrap Promise<Promise<T>>

[jamiebuilds]

While it is possible to create types like Promise<Promise<T>>, await and Promise#then do not unwrap to T correctly the same way they do in JavaScript implementations.

[try flow]

declare function wrap<T>(fn: T): Promise<T>;

async function main() {
  let val: Promise<Promise<42>> = wrap(Promise.resolve(42));
  let res: 42 = await val;
  
  val.then((res: 42) => {
    // ...
  });
}

Error one: await

    7:   let res: 42 = await val;
                       ^ Promise. This type is incompatible with
    7:   let res: 42 = await val;
                  ^ number literal `42`

Error two: .then

    9:   val.then((res: 42) => {
                  ^ function. This type is incompatible with the expected param type of
    [LIB] static/v0.62.0/flowlib/core.js:598:       onFulfill?: (value: R) => Promise<U> | U,
                                                                ^ function type
        The first parameter is incompatible:
            6:   let val: Promise<Promise<42>> = wrap(Promise.resolve(42));
                                  ^ Promise. This type is incompatible with
            9:   val.then((res: 42) => {
                                ^ number literal `42`

[jcready]

I would argue that Promise<Promise<T>> is an impossible type. You cannot actually create a javascript Promise which resolves to another Promise. But I agree that flow needs to figure out how to collapse/unwrap Promise<Promise<T>> into Promise<T>.

[samwgoldman]

I don't think it's worth the implementation complexity to change await and .then to behave this way. We'd need to somehow run <T>(Promise<T>) => T until we reach a fixed point.

Certainly possible, but since Promise<Promise<T>> isn't actually inhabitable, I don't think it's worth adding the logic for programs which can't actually be written (although they can be declared, as you've shown).

[jamiebuilds]

That's exactly the problem, it's really difficult to write type definitions for a lot of libraries which use promises and not run into this error.

[samwgoldman]

Sure, I appreciate that, and I wish the implicit unwrapping behavior weren't so.

What we do is type await-like things like this: <T>(Promise<T> | T) => T and wrap-like things like this: <T>(Promise<T> | T) => Promise<T>.

[jcready]

@samwgoldman that doesn't unwrap all "thenables" though. Libraries like bluebird can implement their own Promises which arent accepted by flow to be a Promise (because it defines a static bind method on the class which doesn't conform to the standard Promise). Which means that your method for unwrapping doesn't work because flow treats the bluebird Promise as T instead of a Promise<T>. If you were to await ({ then(cb){ cb('foo') } }) the resulting value would be 'foo', not an object with a then method.