TypeScript中MikroORM/TypeORM如何实现Agent与Event的混合关联？

问题描述 #

我需要定义包含Agent的实体，每个Agent可拥有多个未处理Event实体，以及一个已处理Event实体。

最初在MikroORM中尝试如下实现：

import { Collection, Entity, ManyToOne, OneToMany, OneToOne, PrimaryKey, Property, Unique, Rel } from "@mikro-orm/core";

@Entity()
class AgentEntity {    
    @OneToOne(event => event.id, { nullable: true })
    lastEventHandled!: Rel<Event>;

    @OneToMany(() => Event, event => event.agent)
    unhandledEvents = new Collection<Event>(this);
}

@Entity()
class Event {
    @PrimaryKey({ autoincrement: true })
    id!: number;
    
    @ManyToOne()
    agent!: AgentEntity;
}

但这引发了OneToOne与ManyToOne引用同一OneToMany事件属性的冲突问题。

随后我改为在Event实体中添加handled字段标记处理状态：

@Entity()
export class Event {
    @PrimaryKey({ autoincrement: true })
    id!: number;

    @Property()
    blockNumber!: number

    @Property()
    transactionIndex!: number

    @Property()
    logIndex!: number

    @Property()
    handled: boolean = false;

    @ManyToOne(() => AgentEntity)
    agent!: AgentEntity;

    constructor(agent: AgentEntity, event: EvmEvent, handled: boolean) {
        this.blockNumber = event.blockNumber;
        this.transactionIndex = event.transactionIndex;
        this.logIndex = event.logIndex;
        this.handled = handled;
        this.agent = agent;
    }
}

并在AgentEntity中通过方法过滤事件：

@Entity()
class AgentEntity {
    @OneToMany(() => Event, event => event.agent)
    events = new Collection<Event>(this);

    lastEventHandled(): Event | undefined {
        return this.events.getItems().filter(event => event.handled)[0]
    }

    unhandledEvents(): Event[] {
        return this.events.getItems().filter(event => !event.handled)
    }
}

但这个方案需要手动清除旧的已处理事件状态，请问在TypeORM中有没有更简便的实现方式？

TypeORM的几种优化实现方式 #

1. 带条件的关系映射（无需手动过滤） #

TypeORM支持在关系装饰器中直接添加where条件，让关联自动过滤出对应状态的事件，避免在实体方法中手动过滤：

import { Entity, PrimaryGeneratedColumn, Column, OneToMany, OneToOne, JoinColumn, ManyToOne, EntityManager } from "typeorm";

@Entity()
export class Agent {
    @PrimaryGeneratedColumn()
    id: number;

    // 直接关联已处理的事件，自动过滤handled=true的记录
    @OneToOne(() => Event, { nullable: true, eager: false })
    @JoinColumn()
    lastHandledEvent: Event;

    // 自动关联未处理的事件，过滤handled=false的记录
    @OneToMany(() => Event, event => event.agent, {
        where: { handled: false },
        eager: false
    })
    unhandledEvents: Event[];

    // 关联所有事件（用于内部状态维护）
    @OneToMany(() => Event, event => event.agent)
    allEvents: Event[];
}

@Entity()
export class Event {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    blockNumber: number;

    @Column()
    transactionIndex: number;

    @Column()
    logIndex: number;

    @Column({ default: false })
    handled: boolean;

    @ManyToOne(() => Agent, agent => agent.allEvents)
    agent: Agent;

    constructor(agent: Agent, blockNumber: number, transactionIndex: number, logIndex: number) {
        this.agent = agent;
        this.blockNumber = blockNumber;
        this.transactionIndex = transactionIndex;
        this.logIndex = logIndex;
    }
}

2. 自动维护已处理事件的唯一性 #

在设置新的已处理事件时，自动将该Agent下原有的已处理事件标记为未处理，无需手动操作：

// 在Agent实体中添加状态维护方法
async setLastHandledEvent(newEvent: Event, entityManager: EntityManager) {
    // 重置原有已处理事件状态
    if (this.lastHandledEvent) {
        this.lastHandledEvent.handled = false;
        await entityManager.save(this.lastHandledEvent);
    }
    // 标记新事件为已处理并关联
    newEvent.handled = true;
    this.lastHandledEvent = newEvent;
    await entityManager.save(newEvent);
    await entityManager.save(this);
}

3. 数据库层面约束确保唯一性 #

给Event表添加部分唯一约束（如PostgreSQL支持），从数据库层面确保每个Agent只有一条handled=true的记录：

-- 直接在数据库执行（或通过TypeORM的迁移脚本）
CREATE UNIQUE INDEX idx_agent_handled ON event (agent_id) WHERE handled = true;

如果使用不支持部分约束的数据库，也可以用TypeORM的联合约束配合逻辑处理：

// 在Event实体中配置
@Column({ default: false })
@Unique(["agent", "handled"])
handled: boolean;

注：此联合约束需要额外逻辑控制，避免handled=false时的冲突。

4. 使用查询方法替代实体关联 #

若不想依赖带条件的关联映射，可直接通过Repository查询获取对应状态的事件，避免加载全量数据后过滤：

// 在AgentRepository中扩展方法
export class AgentRepository extends Repository<Agent> {
    async getLastHandledEvent(agentId: number): Promise<Event | null> {
        return this.manager.findOne(Event, {
            where: { agent: { id: agentId }, handled: true }
        });
    }

    async getUnhandledEvents(agentId: number): Promise<Event[]> {
        return this.manager.find(Event, {
            where: { agent: { id: agentId }, handled: false }
        });
    }
}

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