TypeScript：当提供变量 CLASS 作为函数参数时，将返回类型推断为该类的实例（仅从参数中）

Question

I want to create a function that takes actual class objects themselves as an argument (actually in an object full of multiple arguments), and I want the return-type of the function to be inferred to be an instance of that class that was supplied as the argument.

This is an ORM, so the classes are models which each represent an SQL table. There will then be a number of database query functions (outside of the classes altogether) that each take arguments indicating what table to select from etc.

Best explained with code...

export class DogModelClass {
    id:number;
    name:string;
    woofCount:number;
}

export class CatModelClass {
    id:number;
    name:string;
    meowCount:number;
}

interface ArgumentsInterface {
    theActualClass; // <-- this argument will be the actual CLASS itself, NOT instance of the class
}

function getModelFromDatabase(args:ArgumentsInterface) {
    // some database code to get the a "dog" or "cat" row from the DB and return an INSTANCE of the relevant args.theActualClass class
}

// I want typescript to infer that dogInstance is an INSTANCE of DogModelClass (simply from the function arguments alone)...
const dogInstance = getModelFromDatabase({theActualClass:DogModelClass});

// I want typescript to infer that catInstance is an INSTANCE of CatModelClass (simply from the function arguments alone)...
const catInstance = getModelFromDatabase({theActualClass:CatModelClass});

I know that I could add a generic to the function itself, ie

function getModelFromDatabaseWithGeneric<ModelGeneric>(args:ArgumentsInterface):ModelGeneric {
    return <ModelGeneric>{};
}
const dogInstance2 = getModelFromDatabaseWithGeneric<DogModelClass>({theActualClass:DogModelClass});

But I don't want to have to set the generic type the every time I call the function, as the model class itself already needs to be set in the arguments anyway for other reasons (such as the functions knowing which table to SELECT from etc). So it's just kind of redundant having to write the class name twice every time I call all my querying functions.

How can I achieve this?

Also please let me know if there's more accurate terms I can use for all this. I'm never quite sure what to call "the actual class object - not the instance" in JS when it comes to passing them around as variables like this.

Answer 1

One way this can be accomplished is by restricting the generic type to be a class constructor, then returning its InstanceType :

function getModelFromDatabase<T extends { new(...args: any[]): any }>(args: { theActualClass: T }): InstanceType<T> { /* ... */ }

Or, if you prefer, by ensuring the argument is always a constructor type:

function getModelFromDatabase<T>(args: { theActualClass: {new (...args: any[]): T} }): T { /* ... */ }

Both accomplish the same goal:

// Infered as an INSTANCE of DogModelClass 
const dogInstance = getModelFromDatabase({theActualClass: DogModelClass});

// Infered as an INSTANCE of CatModelClass
const catInstance = getModelFromDatabase({theActualClass: CatModelClass});