TypeScript中如何类型安全处理静态泛型属性继承问题

我正在尝试为Firestore对象构建基于浅类的接口，用于封装自定义对象转换器。现有两个配置了自定义转换器、集合名称且包含公共docRef方法的类，类中除单个字符串属性外还可定义其他属性，初始实现存在大量重复代码：

class Foo {
  constructor(public fooVal: string) {}

  // 模型绑定的集合/表专属逻辑
  static #firestoreConverter: FirestoreDataConverter<Foo> =
    {
      toFirestore(modelObject) {
        return {
          fooVal: modelObject.fooVal,
        };
      },
      fromFirestore(snapshot, options?) {
        const data = snapshot.data(options);
        return new Foo(data.fooVal);
      },
    };
  static #collectionName = "Foo";
  // --- 待重构的重复逻辑开始 ---
  static #collection = collection(db, this.#collectionName).withConverter(
    this.#firestoreConverter
  );

  static docRef(id: string) {
    return doc(this.#collection, id);
  }
}

class Bar {
  constructor(public barVal: string) {}

  static #firestoreConverter: FirestoreDataConverter<Bar> =
    {
      toFirestore(modelObject) {
        return {
          barVal: modelObject.barVal,
        };
      },
      fromFirestore(snapshot, options?) {
        const data = snapshot.data(options);
        return new Bar(data.barVal);
      },
    };
  static #collectionName = "Bar";
  static #collection = collection(db, this.#collectionName).withConverter(
    this.#firestoreConverter
  );

  static docRef(id: string) {
    return doc(this.#collection, id);
  }
}

重构时遇到类型推导问题：firestoreConverter的返回类型由所属的具体类决定，常规继承方案无法正确推导子类的转换器类型——转换器的返回类型应为子类而非父类类型，但子类定义完成前无法预知子类的具体类型，问题继承实现示例如下：

abstract class BaseModel {
  static collectionName: string;
  // 子类中firestoreConverter的类型会变化，但基类写死为BaseModel
  static firestoreConverter: FirestoreDataConverter<BaseModel>;

  static docRef(id: string) {
    const col = collection(db, this.collectionName).withConverter(
      this.firestoreConverter
    );
    return doc(col, id);
  }
}

// 继承后（比如Foo extends BaseModel），Foo.docRef的类型会被推导为FirestoreDataConverter<BaseModel>
// 但Foo.converter实际类型是FirestoreDataConverter<Foo>，类型不匹配

测试过Mixin（混入）实现方案，同样无法正确推导转换器属性的返回类型。需要找一个类型安全、足够优雅的重构方案消除重复逻辑。

TypeScript 支持对静态方法的this上下文做泛型绑定，不需要混入，用带自引用泛型的抽象基类即可实现完全类型安全的重构，所有重复逻辑收敛到基类，子类类型推导完全正确。

核心实现逻辑：

1. 基类使用自引用泛型T标记子类类型
2. 静态docRef方法显式声明this的类型为子类构造函数，绑定对应泛型的转换器类型，强制子类实现必填的静态属性
3. 可选增加集合引用缓存，和原实现的私有静态属性性能一致

完整实现代码：

import { collection, doc, CollectionReference, DocumentReference, FirestoreDataConverter } from "firebase/firestore";
// 假设db为已初始化的Firestore实例
declare const db: FirebaseFirestore.Firestore;

abstract class BaseModel<T extends BaseModel<T>> {
  // 强制子类实现的静态属性
  static collectionName: string;
  static firestoreConverter: FirestoreDataConverter<any>;
  // 缓存已初始化的带转换器的集合引用，避免重复创建
  static #collectionCache = new WeakMap<Function, CollectionReference<any>>();

  static docRef<T extends BaseModel<T>>(
    this: (new (...args: any[]) => T) & {
      collectionName: string;
      firestoreConverter: FirestoreDataConverter<T>;
    },
    id: string
  ): DocumentReference<T> {
    if (!this.#collectionCache.has(this)) {
      const col = collection(db, this.collectionName).withConverter(this.firestoreConverter);
      this.#collectionCache.set(this, col);
    }
    return doc(this.#collectionCache.get(this)!, id);
  }
}

子类实现只需要保留自身独有的属性、转换器、集合名定义，不需要重复写公共逻辑：

class Foo extends BaseModel<Foo> {
  constructor(public fooVal: string) {
    super();
  }

  static override collectionName = "Foo";
  static override firestoreConverter: FirestoreDataConverter<Foo> = {
    toFirestore(model) {
      return { fooVal: model.fooVal };
    },
    fromFirestore(snapshot, options?) {
      const data = snapshot.data(options);
      return new Foo(data.fooVal);
    }
  };
}

class Bar extends BaseModel<Bar> {
  // 子类可自由扩展任意属性，不受基类限制
  constructor(public barVal: string, public count: number = 0) {
    super();
  }

  static override collectionName = "Bar";
  static override firestoreConverter: FirestoreDataConverter<Bar> = {
    toFirestore(model) {
      return {
        barVal: model.barVal,
        count: model.count
      };
    },
    fromFirestore(snapshot, options?) {
      const data = snapshot.data(options);
      return new Bar(data.barVal, data.count);
    }
  };
}

实现效果 #

• 无重复代码：集合初始化、引用缓存、docRef方法全部收敛到基类
• 类型完全安全：Foo.docRef("id")返回DocumentReference<Foo>，Bar.docRef("id")返回DocumentReference<Bar>，不会出现类型被推导为基类的问题
• 类型校验完备：如果子类忘记实现collectionName或firestoreConverter，TypeScript会直接抛出编译错误
• 扩展性强：子类可以自由定义任意属性、自定义转换器逻辑，没有额外约束

之前继承方案失效的原因是基类将firestoreConverter类型固定为FirestoreDataConverter<BaseModel>，没有利用静态方法的this上下文做动态类型绑定——TypeScript不会自动将父类静态成员的类型协变到子类，必须显式声明this的泛型约束，才能让TS正确推导调用方（子类）的对应类型。

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