如何在TypeScript中基于泛型参数限制泛型类的方法调用？

这段TypeScript代码中，IQuery<T>的first方法设计存在缺陷：当调用map返回非对象类型（比如number）时，调用first()虽然返回never类型，但不会触发编译错误，不符合我们**仅允许对象类型调用first**的需求。

原代码：

interface IQuery<T> {
    first<U = T & object>(): Promise<U>
    sum(): Promise<T>;
    map<TR>(fx: (x: T) => TR): IQuery<TR>;
}

async function fx(q: IQuery<Product>) {
    // 类型正确
    const total = await q.map((x) => x.price).sum();

    // 类型正确
    const firstProduct = await q.map((x) => x).first();

    // 本应报错，但仅返回never，无编译提示
    const firstID = await q.map((x) => x.id).first();
}

class Product {
    id?: number;
    price?: number;
}

之前尝试的两种写法都没解决问题：

• first<U = T extends object ? T : never>(): Promise<U>：只是将默认参数设为never，但仍允许调用方法
• first<U = T>(): U extends object ? Promise<U> : never;：返回值为never，但调用时不会触发编译错误

另外有方案能实现调用限制，但无法继承IQuery接口扩展新方法，不符合需求。

以下几种方案既能实现first方法的调用限制，又保留接口的可继承性：

方案1：条件类型组合接口 #

将基础方法和first方法拆分，通过条件类型决定是否包含first方法：

interface IQueryCore<T> {
    sum(): Promise<T>;
    map<TR>(fx: (x: T) => TR): IQuery<TR>;
}

// 仅当T是对象类型时，才包含first方法
type IQuery<T> = T extends object ? IQueryCore<T> & {
    first(): Promise<T>;
} : IQueryCore<T>;

async function fx(q: IQuery<Product>) {
    const total = await q.map(x => x.price).sum(); // 正常通过
    const firstProduct = await q.map(x => x).first(); // 正常通过
    const firstID = await q.map(x => x.id).first(); // 编译错误：属性'first'不存在于类型'IQuery<number | undefined>'
}

class Product {
    id?: number;
    price?: number;
}

方案2：接口合并实现条件方法 #

利用TypeScript的接口合并特性，仅对对象类型的泛型参数添加first方法：

interface IQuery<T> {
    sum(): Promise<T>;
    map<TR>(fx: (x: T) => TR): IQuery<TR>;
}

// 仅当T为对象类型时，合并first方法到IQuery
interface IQuery<T extends object> {
    first(): Promise<T>;
}

// 继承扩展示例
interface IExtendedQuery<T> extends IQuery<T> {
    average(): Promise<number>;
}

async function fx(q: IExtendedQuery<Product>) {
    const total = await q.map(x => x.price).sum(); // 正常
    const avg = await q.map(x => x.price).average(); // 正常调用扩展方法
    const firstProduct = await q.map(x => x).first(); // 正常
    const firstID = await q.map(x => x.id).first(); // 编译错误：属性'first'不存在
}

class Product {
    id?: number;
    price?: number;
}

这个方案完美支持接口继承扩展，同时严格限制了first的调用场景。

方案3：返回值类型约束 #

如果想保留单一接口结构，可通过返回值的条件类型触发错误：

interface IQuery<T> {
    first(): T extends object ? Promise<T> : never;
    sum(): Promise<T>;
    map<TR>(fx: (x: T) => TR): IQuery<TR>;
}

async function fx(q: IQuery<Product>) {
    const total = await q.map(x => x.price).sum(); // 正常
    const firstProduct = await q.map(x => x).first(); // 正常
    const firstID = await q.map(x => x.id).first(); // 编译错误：类型'Promise<never>'不能赋值给其他类型
}

class Product {
    id?: number;
    price?: number;
}

这种方式会在调用时因为返回never而报错，但不如前两种方案直观。

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