TypeScript重载函数无法正确推导实现中的声明签名问题

问题场景 #

期望函数重载的声明与实现类型匹配，但以下代码中get函数实现里的args触发类型错误：

type UserFindMany = { a: boolean }
type WorkflowFindMany = { b: boolean }
type PostFindMany = { c: boolean }

type ORM = {
    user: {
        findMany(args: UserFindMany): { a: string };
    };
    workflow: {
        findMany(args: WorkflowFindMany): { b: string };
    };
}

const orm: ORM = {
    user: {
        findMany(args) { return { a: 'a' } },
    },
    workflow: {
        findMany(args) { return { b: 'b' } },
    },
}

type ORMKeys = keyof ORM;

function get<const TModel extends 'user'>(model: TModel, args: UserFindMany): { a: string };
function get<const TModel extends 'workflow'>(model: TModel, args: WorkflowFindMany): { b: string };
function get<const TModel extends ORMKeys>(model: TModel, args: UserFindMany | WorkflowFindMany): { a: string } | { b: string } {
    return orm[model].findMany(args); // 报错！
    // Argument of type 'UserFindMany | WorkflowFindMany' is not 
    // assignable to parameter of type 'UserFindMany & WorkflowFindMany'.
}

const a = get('user', { a: true }); // 无错误
const b = get('user', { b: true }); // 触发错误

报错提示：

Argument of type 'UserFindMany | WorkflowFindMany' is not assignable to parameter of type 'UserFindMany & WorkflowFindMany'.

原因分析 #

TypeScript对联合类型的函数调用有严格的类型检查逻辑：

• 当model是ORMKeys（即'user' | 'workflow'）时，orm[model].findMany的类型会被推断为联合函数类型：((args: UserFindMany) => {a: string}) | ((args: WorkflowFindMany) => {b: string})。
• 对于联合类型的函数，TypeScript要求传入的参数必须满足所有分支函数参数类型的交集（也就是UserFindMany & WorkflowFindMany）——因为它无法确定当前调用的是哪个分支的函数，只能接受所有分支都兼容的参数。
• 但代码中传入的args是UserFindMany | WorkflowFindMany，这个联合类型无法满足交集类型的要求，因此触发报错。

解决方案 #

方案1：泛型绑定+类型断言（通用简洁） #

通过泛型将model和args的类型强绑定，再用类型断言告诉TypeScript参数类型是匹配的：

// 提取ORM中每个model对应的findMany参数和返回值类型
type FindManyArgs<T extends ORMKeys> = Parameters<ORM[T]['findMany']>[0];
type FindManyResult<T extends ORMKeys> = ReturnType<ORM[T]['findMany']>;

function get<const TModel extends ORMKeys>(model: TModel, args: FindManyArgs<TModel>): FindManyResult<TModel> {
    // 断言args符合当前model对应的参数类型，因泛型绑定已确保类型匹配，断言安全
    return orm[model].findMany(args as FindManyArgs<TModel>);
}

方案2：分支类型守卫（直观清晰） #

通过条件判断明确model的类型，让TypeScript在每个分支中正确推断参数类型：

function get<const TModel extends ORMKeys>(model: TModel, args: UserFindMany | WorkflowFindMany): { a: string } | { b: string } {
    if (model === 'user') {
        return orm.user.findMany(args as UserFindMany);
    } else {
        return orm.workflow.findMany(args as WorkflowFindMany);
    }
}

这种方式适合model数量较少的场景，类型推断更明确。

方案3：简化类型断言（快速修复） #

如果场景简单，也可以直接对findMany进行类型断言，跳过联合类型检查：

function get<const TModel extends ORMKeys>(model: TModel, args: UserFindMany | WorkflowFindMany): { a: string } | { b: string } {
    return (orm[model].findMany as (args: typeof args) => any)(args);
}

注意：此方式需确保业务逻辑中model和args的类型是严格对应的，避免运行时错误。

内容的提问来源于stack exchange，提问作者pvarouktsis