TypeORM中如何为ContainableItem建模多对一关联至不同实体

问题核心 #

你要实现的是排他性多对一关联：一个ContainableItem只能属于ItemContainer或ItemLocation中的一个，不能同时关联两者。但TypeORM的many-to-one关联仅支持指向单一实体类型，你当前尝试用target: ItemContainer.name || ItemLocation.name的写法不生效，因为TypeORM无法动态识别多个目标实体。

可行解决方案 #

方案1：双可选关联字段 + 数据库约束（推荐） #

在ContainableItem中分别定义指向两个实体的可选many-to-one字段，再通过数据库检查约束确保两个字段仅一个有值，同时可添加计算属性统一获取"父实体"。

ContainableItem 实体代码

import { Entity, Column, ManyToOne, JoinColumn, Check } from "typeorm";
import { ItemContainer } from "./ItemContainer";
import { ItemLocation } from "./ItemLocation";

@Entity()
// 数据库层面强制排他性：两个外键只能有一个非空
@Check(`("containerId" IS NOT NULL AND "locationId" IS NULL) OR ("containerId" IS NULL AND "locationId" IS NOT NULL)`)
export class ContainableItem {
  // 其他基础字段...

  @ManyToOne(() => ItemContainer, container => container.items, { nullable: true })
  @JoinColumn({ name: "containerId" })
  container: ItemContainer;

  @ManyToOne(() => ItemLocation, location => location.items, { nullable: true })
  @JoinColumn({ name: "locationId" })
  location: ItemLocation;

  // 可选：统一获取父实体的计算属性
  get parent(): ItemContainer | ItemLocation | null {
    return this.container ?? this.location;
  }
}

关联实体的OneToMany配置

ItemContainer和ItemLocation中的关联保持原有写法即可：

// ItemContainer.ts
@OneToMany(() => ContainableItem, item => item.container)
items: ContainableItem[];

// ItemLocation.ts
@OneToMany(() => ContainableItem, item => item.location)
items: ContainableItem[];

优势：

• 数据库约束强制数据一致性，避免出现同时关联两个父实体的错误数据
• 代码逻辑清晰，完全兼容TypeORM的查询和关联操作
• 可针对两种关联分别做独立的业务逻辑处理

方案2：单表继承（适合两实体有共同属性的场景） #

如果ItemContainer和ItemLocation存在较多共同属性，可以抽象出父类，通过单表继承实现统一关联。

1. 定义父类实体

import { Entity, PrimaryGeneratedColumn, DiscriminatorColumn } from "typeorm";

@Entity()
@DiscriminatorColumn({ name: "parentType", type: "varchar" })
export abstract class ItemParent {
  @PrimaryGeneratedColumn()
  id: number;

  // 两实体的共同属性...
}

2. 子类实体实现

// ItemContainer.ts
import { ChildEntity, OneToMany } from "typeorm";
import { ItemParent } from "./ItemParent";
import { ContainableItem } from "./ContainableItem";

@ChildEntity("container")
export class ItemContainer extends ItemParent {
  // 容器专属属性...
  @OneToMany(() => ContainableItem, item => item.parent)
  items: ContainableItem[];
}

// ItemLocation.ts
import { ChildEntity, OneToMany } from "typeorm";
import { ItemParent } from "./ItemParent";
import { ContainableItem } from "./ContainableItem";

@ChildEntity("location")
export class ItemLocation extends ItemParent {
  // 位置专属属性...
  @OneToMany(() => ContainableItem, item => item.parent)
  items: ContainableItem[];
}

3. ContainableItem 关联父类

import { Entity, ManyToOne } from "typeorm";
import { ItemParent } from "./ItemParent";

@Entity()
export class ContainableItem {
  // 其他字段...

  @ManyToOne(() => ItemParent, parent => parent.items)
  parent: ItemParent;
}

注意：此方案会将两个子类数据存入同一张表，通过parentType字段区分。若两实体差异较大，不建议使用。

方案3：自定义类型转换器（不推荐） #

通过自定义类型转换器实现parent字段的动态映射，但需要自行处理查询、关联的逻辑兼容，TypeORM原生支持有限，容易引发兼容性问题，仅适合特殊场景。

总结 #

优先选择方案1，它既满足业务的排他性要求，又符合TypeORM的设计规范，数据库层面的约束也能有效避免数据不一致问题。

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