Typescript not understand Promise than catch logic

[vforv]

    "typescript": "^2.7.2",
    "typescript-eslint-parser": "^14.0.0",

If I have promise like this:

export default function to<T>(promise: Promise<T>) {
    return promise
        .then((data: T) => {
            return { error: undefined, data };
        })
        .catch((error: Error) => {
            return { error, data: undefined };
        });
}

And after that I add async await with this logic:

public someMethod() {
const { error, data } = await to<SomeType>(SOME PROMISE HERE);

if(error) {
  return;
}

// HERE I WILL NOT BE ABLE TO GET SomeType because Typescript still recognise data as type:
// undefined | SomeType
data.
}

Maybe this is some bug with IDE I don't know. I am usigin Visual Code.

[DanielRosenwasser]

TypeScript doesn't have a way to correlate the types of error and data once you've destructured them into independent variables.

Otherwise, being able to discriminate on undefined or null on a property of an object is an open issue: #24479

[vforv]

That is bad because I need to hack data variable like this: (data as Website[]) to make it work

[kitsonk]

I think @DanielRosenwasser might have looked at it a bit too quickly... What you have written int TypeScript could easily be improved to accomplish your intent:

export interface ToReturn<T> {
    error: Error | undefined;
    data: T | undefined;
}

export default function to<T>(promise: Promise<T>): Promise<ToReturn<T>> {
    return promise
        .then((data: T) => {
            return { error: undefined, data };
        })
        .catch((error: Error) => {
            return { error, data: undefined };
        });
}

async function someMethod() {
    const { error, data } = await to(Promise.resolve('foo'));

    if(error) {
        return;
    }

    data; // typeof string
}

These sort of basic questions are best asked on StackOverflow or Gitter though.

[kitsonk]

Actually, @DanielRosenwasser is right, though I am not entirely sure you wanted/needed what Daniel was suggesting. While it is mildly inconvenient, you can still access the type. Your original code was still flawed though in representing the return of the function. Here is a slightly better example which expresses what Daniel was talking about when run under --strictNullChecks:

export type ToReturn<T> = {
    error: Error;
    data: undefined;
} | {
    error: undefined;
    data: T
};

export default function to<T>(promise: Promise<T>): Promise<ToReturn<T>> {
    return promise
        .then((data: T) => {
            return { error: undefined, data };
        })
        .catch((error: Error) => {
            return { error, data: undefined };
        });
}

async function someMethod() {
    const { error, data } = await to(Promise.resolve('foo'));

    if (error) {
        return;
    }
    
    data; // typeof string | undefined

    if (data) {
        data; // string
    }
}

[vforv]

Yes, in this part

if (error) {
        return;
}
    
data; // typeof string | undefined

data should be just string but not string | undefined

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.