How to ensure a string-keyed object as generic in typescript

Question

Having a generic function that takes a string-indexed object

function wantsStringIndexedObject<
    Obj extends { [k: string]: any }, 
    K extends keyof Obj
  >(obj: Obj, key: K) {

  const _ktype = typeof key
  // const ktype: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"

  const val = obj[key]

  wantsStringAndAny(key, val)
  // Argument of type 'K' is not assignable to parameter of type 'string'.
  // Type 'keyof Obj' is not assignable to type 'string'.
  //    Type 'string | number | symbol' is not assignable to type 'string'.
  //    Type 'number' is not assignable to type 'string'.
  // (parameter) key: K extends keyof Obj
} 

// no error here
wantsStringIndexedObject({
  1: 10,
  [Symbol()]:1
}, 1) 

function wantsStringAndAny(str: string, v:any) {} 

TS playground

I know I could use a type guard on key before calling wantsStringAndAny but I would expect:
1: key should be typed as string for sure inside wantsStringIndexedObject
2: shouldn't be allowed to call wantsStringIndexedObject with that kind of object

I suppose that the issue comes from generic definition Obj extends { [k: string]: any }
infact any object with any index type extends a { [k: string]: any } with 0 properties.

so, is there a way to define a generic ensuring a string-indexed-object constraint ?

Answer 1

You can ensure the key is of a string type by using the Extract conditional type to filter the key of Obj:

function wantsStringAndAny(str: string, v:any) {

} 

function wantsStringIndexedObject<
    Obj extends object, 
    K extends Extract<keyof Obj, string>
  >(obj: Obj, key: K) {

  const _ktype = typeof key
  const val = obj[key]

  wantsStringAndAny(key, val)
} 

// err
wantsStringIndexedObject({
  1: 10,
  [Symbol()]:1
}, 1)

//ok
wantsStringIndexedObject({
  "1": "",
}, "2")

Generally a constraint is the minimal contract a type must implement, nothing stopping the actual type from having symbols amongst it's keys as well. Also string index will actually allow indexing with both strings and numbers, so numbers would be allowed under your supposition as well.

If you want to also forbid any number or symbol keys from Obj you could do the following:

function wantsStringIndexedObject<
    Obj extends object, 
    K extends Extract<keyof Obj, string>
  >(obj: Obj & Record<Extract<keyof Obj, number | symbol>, never>, key: K) {

  const _ktype = typeof key
  const val = obj[key]

  wantsStringAndAny(key, val)
} 

//ok
wantsStringIndexedObject({
  "1": "",
}, "1")
wantsStringIndexedObject({
  "1": "",
  2: 0 // errr
}, "1")

This takes any number or symbol keys and basically says they should be of type never (possible but unlikely) and you will get an error on any such keys.