出现错误：类型“typeof B”不可分配给扩展 A 的类 B 的类型“typeof A”

Question

可复现的例子here

我的需要是：contentType 参数应该接受从 Content 扩展的任何类对象（PublicContent、AdminContent、PrivateContent 等），并且我想在 execute 方法内从该参数类型调用静态方法。

我有一个带有以下签名的方法：

async execute<U extends ContentProps>(input: {
    contentType: typeof Content;
    contentPropsType: typeof ContentProps; 
}): Promise<Result<U, Failure>>;

类层次结构如下：

// content.entity.ts

export class ContentProps extends EntityProps {}

export class Content<T extends ContentProps> extends Entity<T> {
  public constructor(props: T) {
    super(props);
  }
}

// public-content.entity.ts
export class PublicContentProps extends ContentProps {
  readonly title: string;
  readonly text: string;
}

export class PublicContent extends Content<PublicContentProps> {
  constructor(props: PublicContentProps) {
    super(props);
  }
  // ommited
}

问题是，当我调用 execute 方法并将 PublicContent 作为 contentType 参数传递时，我收到一条错误消息

类型“typeof PublicContent”不可分配给类型“typeof Content”

方法调用为：

const result = await this.getContent.execute({
  contentType: PublicContent,
  contentPropsType: PublicContentProps,
});

我的问题是：为什么我收到此错误，因为 PublicContent 正在扩展 Content？

编辑：应@Chase 的要求，Entity 和 EntityProps 的完整类型：

// entity.ts
export abstract class EntityProps extends BaseEntityProps {
  id?: string;
  createdAt?: Date;
  updatedAt?: Date;
}

export abstract class Entity<T extends EntityProps> extends BaseEntity<T> {
  get id(): string {
    return this.props.id;
  }

  get createdAt(): Date {
    return this.props.createdAt;
  }

  get updatedAt(): Date {
    return this.props.updatedAt;
  }

  protected constructor(entityProps: T) {
    super(entityProps);
  }
}


// base.entity.ts
export abstract class BaseEntityProps {}

export abstract class BaseEntity<T extends BaseEntityProps> extends Equatable {
  protected readonly props: T;

  protected constructor(baseEntityProps: T) {
    super();
    this.props = baseEntityProps;
  }

  static create<T = BaseEntity<BaseEntityProps>, U = BaseEntityProps>(
    this: {
      new (entityProps: U): T;
    },
    propsType: { new (): U },
    props: U,
  ): Result<T, ValidationFailure> {
    const violations = validateSchemaSync(propsType, props);

    return violations?.length
      ? Result.fail(new ValidationFailure(violations))
      : Result.ok(new this({ ...props }));
  }

  toJSON(): T {
    return this.props;
  }
}

Answer 1

尝试让Content实现一个简单的接口，比如IContent，并使用这个接口来获取execute参数上的typeof

Answer 2

您遇到的问题是超类/子类构造函数 并不总是形成类型层次结构，即使它们的实例 确实如此。我们来看一个例子：

class Foo {
  x = 1;
  constructor() { }
  static z = 3;
}

class Bar extends Foo {
  y: string;
  constructor(y: number) {
    super()
    this.y = y.toFixed(1);
  }
}

这里，class Bar extends Foo 表示如果你有一个Bar 类型的值，你可以将它分配给一个Foo 类型的变量：

const bar: Bar = new Bar(2);
const foo: Foo = bar; // okay

但是，如果您尝试将Bar 构造函数（typeof Bar 类型）分配给与Foo 构造函数（typeof Foo 类型）相同类型的值，它失败：

const fooCtor: typeof Foo = Bar; // error!
// Type 'new (y: number) => Bar' is not assignable to type 'new () => Foo'

这是因为Bar 构造函数在调用其构造签名时需要number 类型的参数（即new Bar(2)），而Foo 构造函数根本不带任何参数（即new Foo()） .如果您尝试将Bar 当作Foo 构造函数一样使用，并且不带参数调用它，您将收到运行时错误：

const oopsAtRuntime = new fooCtor(); // TypeError: y is undefined

---

出于同样的原因，您的PublicContent 构造函数不能分配给typeof Content。前者需要PublicContentProps 类型的构造签名参数，而后者将接受扩展ContentProps 类型的任何参数。如果您尝试像使用 Content 构造函数一样使用 PublicContent，则可能会向其传递 PublicContentProps 以外的其他类型的参数，这可能会导致错误。

---

所以让我们退后一步。事实上，您并不关心您作为contentType 传递的对象是否可分配给Content 构造函数类型，因为您不会使用任意ContentProps 调用它的构造签名。你真的只关心它的静态create() 方法的类型。我倾向于将getContent() 写成这样的通用函数：

const getContent = <U extends ContentProps, T extends BaseEntity<U>>(input: {
  contentType: Pick<typeof Content, "create"> & (new (entityProps: U) => T);
  contentPropsType: new () => U;
}): U => { /* impl */ };

这应该与函数内部的现有版本类似，现在您可以毫无错误地调用它，因为PublicContent 匹配Content 的create 方法，并且是类型的构造函数(new (entityProps: PublicContentProps) => PublicContent):

const entity = getContent({
  contentType: PublicContent,
  contentPropsType: PublicContentProps,
}); // okay

Playground link to code