TypeScript：基于泛型构造一个类型化接口[重复]

Question

TypeScript：基于泛型构造一个类型化接口，使用相同的方法，但从所有函数中排除第一个参数。

有一个通用接口，例如：

interface GenericRepository {
  insertOne<E>(entity: Type<E>, body: E): Promise<string>;

  find<E>(entity: Type<E>, qm: Query<E>): Promise<E[]>;
}

interface Type<T> extends Function {
  new (...args: any[]): T;
}

type Query<E> = {
  [K in keyof E]: E[K];
};

class User {
  firstName?: string;
}

class Company {
  name?: string;
}

我希望能够动态“生成”特定的接口/类型，例如：

interface UserRepository {
  insertOne(body: User): Promise<string>;

  find(qm: Query<User>): Promise<User[]>;
}

interface CompanyRepository {
  insertOne(body: Company): Promise<string>;

  find(qm: Query<Company>): Promise<Company[]>;
}

以下是我到现在为止的内容，但由于没有正确推断出entity 类型（针对特定接口），因此无法正常工作：

type SpecificRepository<E> = {
  [K in keyof GenericRepository]: Fn<GenericRepository[K], E>;
};

type Fn<A extends (...args: any[]) => any, E> = (...a: Params<Parameters<A>>) => ReturnType<A>;

type Params<T extends any[]> = T extends [infer F, ...infer L] ? L : never;


const userRepository = {} as SpecificRepository<User>;
const companyRepository = {} as SpecificRepository<Company>;

如果我这样做（用于测试“生产”类型）：

async function someMethod() {
  const foundUsers = await userRepository.find({});
}

那么foundUsers 的类型是unknown[]，但它应该是User[]。

如何正确地做到这一点？

Answer 1

你快到了！为了帮助 TypeScript 的推理机制，您应该使 interface 通用，而不仅仅是它的成员函数。这样你也不需要子类化：

interface GenericRepository<E> {
  insertOne(entity: Type<E>, body: E): Promise<string>;

  find(entity: Type<E>, qm: Query<E>): Promise<E[]>;
}

interface Type<T> extends Function {
  new (...args: any[]): T;
}

type Query<E> = {
  [K in keyof E]: E[K];
};

class User {
  firstName?: string;
}

class Company {
  name?: string;
}

const userRepository = {} as GenericRepository<User>;
const companyRepository = {} as GenericRepository<Company>;

async function someMethod() {
  const foundUsers = await userRepository.find({});
}