Type to represent the keys of an object that have specific value type in Typescript

Question

I have a function that takes a config object with two keys. The values of these are arrays of keys into the object.

The a values on the Config type are going to be removed from the object of type T , but the b values need to be transformed in some way that is only valid for string-valued keys.

The result is a function that takes the type T as an explicit parameter and returns a function that does the transformation on an object of type T :

interface Config<T extends Object, K extends keyof T> {
  a?: K[]  // keys to remove from T, this works fine
  b?: K[]  // keys to modify string value - want to constrain these
}

export function f<T extends Object>(config: Config<T, keyof T>): (row: T) => Partial<T> {
  return function (row) {
    // remove keys from config.a
    // do something stringy with keys from config.b
  }
}

It's called like this:

const fn = f<SomeType>({ a: [...], b: [...] })

Is there some way to constrain b in the Config interface to only string-valued keys? I tried everything I could think of but most of what I tried generated syntax errors. I'm working around this right now by coercing the string values to string because the type system doesn't know that they are strings. Is there a better way to do this?

Answer 1

If you don't need to keep track of the actual union of keys to be removed/added you can remove the K parameter from Config . From you example I don't think it's needed.

To get only the keys of a certain type we can use a conditional type coupled with mapped types:

interface Config<T extends Object> {
    a?: (keyof T)[]  // keys to remove from T, this works fine
    b?: KeyOfValueType<T, string>[]  // keys to modify string value - want to constrain these
}
type KeyOfValueType<T, TValue> = {[P in keyof T]: T[P] extends TValue ? P : never}[keyof T];


export function f<T extends Object>(config: Config<T>): (row: T) => Partial<T> {
    return function (row) {

        return null as any;
    }
}
interface SomeType {
    nr: number;
    str: string
}
const fnOk = f<SomeType>({ a: ['nr'], b: ['str' ] })
const fnNok = f<SomeType>({ a: ['nr'], b: ['str', 'nr'] })