(Partial<Type>)[keyof Type] is udefined in certain settings and assignment is not possible

[mckravchyk]

Bug Report

🔎 Search Terms

Partial keyof undefined

🕗 Version & Regression Information

I'm using 4.2.4 in production and it occurs. I have tested with 4.4 beta on the playground and it also occurs. I have no knowledge if the bug occurred in prior versions.

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about it.

⏯ Playground Link

Playground link with relevant code

💻 Code

type Data1 = {
  test1: string
  test2: string
}

type Data2 = {
  test1: string
  test2: boolean
}

let data1: Partial<Data1> = { };
let data2: Partial<Data2> = { };

// metadata.test = 'test';
let key = 'test1';
let value = 'test';

// Ok
data1[key as keyof Data1] = value;

// Error: Type 'string' is not assignable to type 'undefined'
// It seems like the bug occurs only if the object type has values of
// different types
data2[key as keyof Data2] = value;

// The real case scenario is I want to iterate some properties and
// assign them to the partial, so I expect that the partial has no
// initial properties defined at all and can be assigned any property of
// partialed type.

type TableData =  {
    id: string
    title: string
    icon: string
}

type Metadata = {
    url: string
    active: boolean
}

type CreateProps = Omit<TableData, 'id'> & Partial<Metadata>;

function create(props: CreateProps): void {
  const id = 'test';

  const tableData: TableData = {
    id,
    title: props.title,
    icon: props.icon
  }
  
  const metadata: Partial<Metadata> = { };

  for (const key of Object.keys(props)) {
      // Build metadata from those props which are not tableData
      if (typeof tableData[key as keyof TableData] === 'undefined') {
          // Error:
          // Type 'string | boolean' is not assignable to type 'undefined' 
          metadata[key as keyof Metadata] = props[key as keyof CreateProps]!;
      }
    }
  }

🙁 Actual behavior

data2[key as keyof Data2] is undefined and it's not possible to assign anything to it.

🙂 Expected behavior

data2[key as keyof Data2] should not be undefined. At least it should be undefined | string | boolean. It should also be possible to assign a value to it, despite being possible undefined.

[MartinJohns]

Related: #32693

[RyanCavanaugh]

data2[key as keyof Data2] is undefined and it's not possible to assign anything to it.

This is the correct behavior. data2 has two properties, which have the legal values string | undefined and boolean | undefined. If you're assigning into an arbitrary property of data2, the only value which is legal for both possible target properties is undefined.

  metadata[key as keyof Metadata] = props[key as keyof CreateProps]!;

The same logic applies here.

[fatcerberus]

See also #30769. In particular:

When an indexed access T[K] occurs on the source side of a type relationship, it resolves to a union type of the properties selected by T[K], but when it occurs on the target side of a type relationship, it now resolves to an intersection type of the properties selected by T[K]. Previously, the target side would resolve to a union type as well, which is unsound.

Emphasis mine. (string | undefined) & (boolean | undefined) is undefined.

[mckravchyk]

Thanks. Is there any workaround to allow the assignment besides using ts-ignore?

[RyanCavanaugh]

I would a type assertion corresponding to why the code isn't actually wrong, e.g. data2[key as 'test1'] = value

[mckravchyk]

I'm sorry, to be more precise I'm looking for a workaround to the more complex example.

I understand that the compiler is right, but I'm not able to code something which is pretty standard without using ts-ignore on the error line.

Playground

type TableData =  {
    id: string
    title: string
    icon: string
}

type Metadata = {
    url: string
    active: boolean
}

type CreateProps = Omit<TableData, 'id'> & Partial<Metadata>;

function create(props: CreateProps): void {
  const id = 'test';

  const tableData: TableData = {
    id,
    title: props.title,
    icon: props.icon
  }
  
  const metadata: Partial<Metadata> = { };

  for (const key of Object.keys(props)) {
      // Build metadata from those props which are not tableData
      if (typeof tableData[key as keyof TableData] === 'undefined') {
          // Error:
          // Type 'string | boolean' is not assignable to type 'undefined' 
          metadata[key as keyof Metadata] = props[key as keyof CreateProps]!;
      }
    }
  }

[mckravchyk]

After some more thinking, using ts-ignore is probably the most elegant option if the actual solution would require writing some additional generic types. Unless there is something simple.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[mckravchyk]

Just coming back to it after some time, instead of using @ts-ignore, I would do this today:

metadata[key as keyof Metadata] = props[key as keyof CreateProps] as unknown as undefined;

Not pretty, but come to think of it the key type is any arbitrary key and there's no relation between them so casting has to be used anyway, there's probably a more correct way to do it but it would be way too much effort for an internal implementation of one function.