如何写一个抽象的 typescript 泛型类型？

Question

given the following types

interface Base {
  id: string;
}

interface A extends Base {
  propA: string;
}

interface B extends Base {
 propB: string;
}

I would like to express a generic MyGeneric<T> with the following constraints:

1. T must be an object
2. T keys must be string

3. T values must be instanceOf Base (either of type Base , or of a type extending Base)

   (3. was T values must be compatible with Base interface but it has been reworded in order to avoid incomprehension)

I tried

interface MyConstraint {
  [key: string]: Base
}

interface MyGeneric<T extends MyConstraint> {
  data: T
}

But in this case, when the user wants to use it, it has 2 drawbacks:

interface userDefinedInterface1 {
  a: A;
  b: B;
}

function foo1(p: MyGeneric<userDefinedInterface1>):void {
  //drawback 1: this throws TS2344:
  //Type 'userDefinedInterface1' does not satisfy the constraint 'userDefinedInterface1'.   //Index signature is missing in type 'userDefinedInterface1'.
}

//to solve drawback 1, the user has to extend MyConstraint
interface userDefinedInterface2 extends MyConstraint {
  a: A;
  b: B;
}

function foo2(p: MyGeneric<userDefinedInterface2>):void {
  //drawback 2: here, ts considers every string property as valid because of [key: string] 
  console.log(p.data.arbitraryKey);//this is valid
}

Is there a way to define interface MyGeneric<T> to respect the 3 mentioned constraints without these 2 drawbacks?

Answer 1

There's only one limitation - if you want to add extra key you have to specify them.

interface Base {
  id: string;
  num: number;
}

interface A extends Base {
  propA: string;
}

interface B extends Base {
 propB: string;
}

type MyGeneric<T extends Base, K extends keyof any = never> = {
  data: T & {
    [key in K | keyof T]: key extends keyof T ? T[key] : string;
  }
}


const test1: MyGeneric<B, 'test'> = {
  data: {
    id: '123',
    num: 123,
    propB: '123',
    test: '123',
  },
};
const test2: MyGeneric<B> = {
  data: {
    id: '123',
    num: 123,
    propB: '123',
    test: '123', // fails, it has to be provided in current TS.
  },
};

Playground

If you want to rely only on keys of T .

then simply use this version:

type MyGeneric<T extends Base> = {
  data: T & {
    [key in keyof T]: key extends keyof Base ? Base[key] : string;
  }
}

Answer 2

I think this should solve both of your drawbacks:

type MyConstraint<T> = {
  [K in keyof T]: T[K] extends Base ? T[K] : never;
};

interface MyGeneric<T extends MyConstraint<T>> {
  data: T;
}

For the small price of making the MyConstraint generic. Both of your examples should now work plus of course if you did something like:

interface UserDefinedInterface3 {
  a: A;
  b: B;
  c: string;
}

type Wrong = MyGeneric<UserDefinedInterface3>;

You would get an error saying that types of property c are not compatible.