Is it possible to annotate exclusive union in TypeScript?

Question

I'm trying to find a type for generic error handling that does something like this:

function request(): GenericError<{body:string}> {
  if (/* Some condition */) {
    return { error: "An error occurred" };
  }

  return { body: "Things went well" };
}

The goal is to infer that body exists if error doesn't, i.e:

const response = request();

if (response.error) return;

/* TypeScript should infer that body can't be undefined here */

I don't know if this is possible in TypeScript and this question might be a duplicate, but I don't know how to word the problem exactly. I tried annotating the function with the answers in this question but none of them could guarantee body to exist if error didn't, as far as I could see.

Typescript Playground

Why you don't just return union between body and error? The you can check with in operator if error is in response. — KiraLT, Aug 23 '22 at 21:25
@KiraLT Using that union errors when doing if (response.error), complaining that response.error in undefined in { body: string }. — DoHn, Aug 23 '22 at 21:29
A discriminated union with an indicator of success seems like a good option here. — Alejandro, Aug 23 '22 at 21:30
You could use the union and change the condition from `response.error` to `"error" in response`. — Michael Liu, Aug 23 '22 at 21:36

Matthieu Riegler · Accepted Answer · 2022-08-23T21:36:53.670

1

A union { error: string } | { body: string } + narrowing will do it :

function request(): { error: string } | { body: string } {
    if (/* Some condition */) {
        return { error: "An error occurred" };
    }

    return { body: "Things went well" };
}

const response = request();

if ('error' in response) { // narrowing
    response.error // OK
    return 
}

response.body // OK

Playground

edited Aug 23 '22 at 21:36

answered Aug 23 '22 at 21:30

Matthieu Riegler

31,918
20
95
134

score 0 · Answer 2 · answered Aug 23 '22 at 21:41

I like to use this pattern than uses a discriminated union alongside a "success" property:

interface SuccessResult {
    result: true;
    body: string;
}
interface FailureResult {
    result: false;
    error: string;
}
type Result = SuccessResult | FailureResult;

Now change the original function to return this instead:

function request(): Result {
    if (/* Some condition */) {
        return { result: false, error: "An error occurred" };
    }

    return { result: true, body: "Things went well" };
}

And finally check for the outcome in the caller:

const response = request();
if (response.result) {
    //Read response.body here, with response.error being invalid (won't compile)
} else {
    //Read response.error here, with response.body being invalid (won't compile)
}

Is it possible to annotate exclusive union in TypeScript?

2 Answers2