Adding property to nested object in union type in Typescript

I have a set of objects that each have different types for an attribute object field depending on their value in a name field. I would like to create a function that can take any of these objects and add an id property to its attributes.

Here is a minimal example of what I have tried:

type Test1<T extends boolean> = {
  name: "test1";
  attrs: { t1: boolean; id: T extends true ? string : never };
};

type Test2<T extends boolean> = {
  name: "test2";
  attrs: { t2: string; id: T extends true ? string : never };
};

type Test<T extends boolean> = Test1<T> | Test2<T>;

const addId = (node: Test<false>, id: string): Test<true> => {
  return { name: node.name, attrs: { ...node.attrs, id } };
};

While this should produce the correct result, typescript raises an error:

Type '{ name: "test1" | "test2"; attrs: { id: string; t1: boolean; } | { id: string; t2: string; }; }' is not assignable to type 'Test<true>'.
  Type '{ name: "test1" | "test2"; attrs: { id: string; t1: boolean; } | { id: string; t2: string; }; }' is not assignable to type 'Test2<true>'.
    Types of property 'name' are incompatible.
      Type '"test1" | "test2"' is not assignable to type '"test2"'.
        Type '"test1"' is not assignable to type '"test2"'

I can resolve the error by discriminating the type before creating the new object as so:

const addId1 = (node: Test<false>, id: string): Test<true> => {
  if (node.name === "test1") {
    return { name: node.name, attrs: { ...node.attrs, id } };
  } else {
    return { name: node.name, attrs: { ...node.attrs, id } };
  }
};

but this becomes tedious when we have more than two types of nodes.

Is there any way to resolve this issue easily and in a way that generalizes to larger unions without relying on any or the like?

TypeScript can't really handle "correlated unions" as described in microsoft/TypeScript#30581. Your Test<true> and Test<false> types are discriminated union types, but TypeScript doesn't allow you to write a single block of code that operates on union types as if each union member were considered separately. So even though { name: node.name, attrs: { ...node.attrs, id } } is seen as working for both Test1<T> and Test2<T>, the compiler loses the thread for Test<T>. You can write different code blocks for different cases, as you've shown with if (node.name === "test1"), but, as you've said, that's redundant.

The recommend workaround for cases like this is described in microsoft/Typescript#47109. Discriminated unions should be refactored to generic indexes into a basic key-value type or mapped types over such a basic key-value type. Read the GitHub issue for more detailed information.

In your case, the refactoring looks like this:

interface TestMap {
    test1: { t1: boolean }
    test2: { t2: string }
}

type Test<
    T extends boolean,
    K extends keyof TestMap = keyof TestMap
> = { [P in K]: {
    name: P,
    attrs: TestMap[P] & { id: T extends true ? string : never }
} }[K]

The basic TestMap key-value interface represents the relationship between the name property and the non-id attrs. And Test<T, K> takes the place of your Test<T>. It's a distributive object type, so Test<T, keyof TestMap> turns out to be equivalent to your Test<T>, and Test<T, "test1"> is equivalent to your Test1, and Test<T, "test2"> to Test2`. (So if you need them, you can still define them

type Test1<T extends boolean> = Test<T, "test1">
type Test2<T extends boolean> = Test<T, "test2">

.) Anyway now your addId() function can be generic in K extends keyof TestMap, and it will just work:

const addId = <K extends keyof TestMap>(
    node: Test<false, K>, id: string): Test<true, K> => {
    return { name: node.name, attrs: { ...node.attrs, id } };
};

And when you call it, the compiler will distinguish between "test1" and "test2" cases properly, if you want:

declare const t1: Test1<false>;
const r1: Test1<true> = addId(t1, "x")

declare const t2: Test2<false>;
const r2: Test2<true> = addId(t2, "x")

But it can also accept the full union:

declare const t: Test<false>;
const r: Test<true> = addId(t, "z");

Playground link to code