0

The Problem: I want to write a function that takes an object and the name of a property as parameters. What I want to achieve is that only property names of properties with a specific type are accepted.

Example: In a person object I have fields name:string and age:number, my function should then only be able to be called with the parameters (person, 'name'). This can be achieved by creating this type:

export type OnlyPropertiesWithSpecificType<TYPE, T> = {
  [K in keyof T]: T[K] extends TYPE ? K : never;
}[keyof T];

When accessing the property inside the function the type of the property's values should be constrainted like this:

type Person = {
  name: string;
  age: number;
};

function somePersonFunction(obj: Person, param: OnlyPropertiesWithSpecificType<string, Person>): string {
  return obj[param]; // works, obj[param] is of type 'string'
}

However when I try to generify the function, it is no longer type constrainted:

function someGenericFunction<T>(obj: T, param: OnlyPropertiesWithSpecificType<string, T>): string {
  return obj[param]; // doesn't work: "TS2322: Type 'T[{ [K in keyof T]: T[K] extends string ? K : never; }[keyof T]]' is not assignable to type 'string'."
}

This is confusing, because the compiler still only accepts property names belonging to properties of type 'string' as param:

someGenericFunction(person, 'name'); // works
someGenericFunction(person, 'age'); // doesn't work

What I tried:

  • TS versions 3.4.5 and 4.1.2.
  • Various variations on T, i.e. T extends object

I created a sandbox with the above example: https://codesandbox.io/s/typescript-forked-ypy0b

How do I solve this problem?

Moritz Hohmeier
  • 165
  • 9

1 Answers1

2

It looks like TS hasn't worked out that someGenericFunction will always return a string, even though in practice it always will.

However unless you absolutely need the : string return type annotation from someGenericFunction, you can just omit it and your code will work as expected.

function someGenericFunction<T>(
  obj: T,
  param: OnlyPropertiesWithSpecificType<string, T>
) {
  return obj[param]; // inferred return type is T[OnlyPropertiesWithSpecificType<string, T>]
}

When called with actual types TS does infer that T[OnlyPropertiesWithSpecificType<string, T>] will always be assignable to string, which is why the functions do work.

Aron
  • 8,696
  • 6
  • 33
  • 59
  • Thanks again! This does indeed work for all following usages of someGenericFunction. It would also work with T[OnlyPropertiesWithSpecificType] as explicit return type. The problem is, I need the string inside someGenericFunction. When useing const val = obj[param] inside of someGenericFunction, its type is not string and I don't understand why. Is this a bug? – Moritz Hohmeier Feb 19 '21 at 07:27
  • Can you give me more context on why you need its type to explicitly be a string? – Aron Feb 19 '21 at 11:04
  • It doesnt have to be the return type but i want to call a function whos param type is string, like this: https://codesandbox.io/s/typescript-forked-yn9mx – Moritz Hohmeier Feb 22 '21 at 10:57
  • @MoritzHohmeier that seems to work just fine. The compiler lets you call `doSomethingWithAString(obj[param])` without any errors. Is there still a problem? – Aron Feb 23 '21 at 15:44