Create a customized interface using TypeScript that inherits from a generic interface by excluding the first parameter from all functions.
Starting with the following generic interface:
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;
}
The goal is to dynamically generate specific interfaces such as:
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[]>;
}
The current code snippet is incomplete and fails to properly infer types for the specific interfaces. Here's an attempt:
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>;
When testing the generated types:
async function someMethod() {
const foundUsers = await userRepository.find({});
}
The type of foundUsers turns out to be unknown[] instead of User[]. How can this be resolved?